session.c 42.7 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 "vdso.h"
18

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

23
	if (perf_session__read_header(self) < 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 32
	if (!perf_evlist__valid_sample_type(self->evlist)) {
		pr_err("non matching sample_type");
33
		return -1;
34 35 36 37
	}

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

41 42
	if (!perf_evlist__valid_read_format(self->evlist)) {
		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 57
int perf_session__create_kernel_maps(struct perf_session *self)
{
58
	int ret = machine__create_kernel_maps(&self->machines.host);
59 60

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

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

70 71
struct perf_session *perf_session__new(struct perf_data_file *file,
				       bool repipe, struct perf_tool *tool)
72
{
73 74
	struct perf_session *self;

75 76
	self = zalloc(sizeof(*self));
	if (!self)
77 78
		goto out;

T
Tom Zanussi 已提交
79
	self->repipe = repipe;
80
	INIT_LIST_HEAD(&self->ordered_samples.samples);
81
	INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
82
	INIT_LIST_HEAD(&self->ordered_samples.to_free);
83
	machines__init(&self->machines);
84

85 86
	if (file) {
		if (perf_data_file__open(file))
87
			goto out_delete;
88

89
		self->file = file;
90 91 92 93 94 95 96 97 98 99

		if (perf_data_file__is_read(file)) {
			if (perf_session__open(self) < 0)
				goto out_close;

			perf_session__set_id_hdr_size(self);
		}
	}

	if (!file || perf_data_file__is_write(file)) {
100 101
		/*
		 * In O_RDONLY mode this will be performed when reading the
102
		 * kernel MMAP event, in perf_event__process_mmap().
103 104 105 106
		 */
		if (perf_session__create_kernel_maps(self) < 0)
			goto out_delete;
	}
107

108
	if (tool && tool->ordering_requires_timestamps &&
109
	    tool->ordered_samples && !perf_evlist__sample_id_all(self->evlist)) {
110
		dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
111
		tool->ordered_samples = false;
112 113
	}

114
	return self;
115 116 117 118

 out_close:
	perf_data_file__close(file);
 out_delete:
119
	perf_session__delete(self);
120
 out:
121
	return NULL;
122 123
}

124 125
static void perf_session__delete_dead_threads(struct perf_session *session)
{
126
	machine__delete_dead_threads(&session->machines.host);
127 128 129 130
}

static void perf_session__delete_threads(struct perf_session *session)
{
131
	machine__delete_threads(&session->machines.host);
132 133
}

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static void perf_session_env__delete(struct perf_session_env *env)
{
	free(env->hostname);
	free(env->os_release);
	free(env->version);
	free(env->arch);
	free(env->cpu_desc);
	free(env->cpuid);

	free(env->cmdline);
	free(env->sibling_cores);
	free(env->sibling_threads);
	free(env->numa_nodes);
	free(env->pmu_mappings);
}

150 151
void perf_session__delete(struct perf_session *self)
{
152
	perf_session__destroy_kernel_maps(self);
153 154
	perf_session__delete_dead_threads(self);
	perf_session__delete_threads(self);
155
	perf_session_env__delete(&self->header.env);
156
	machines__exit(&self->machines);
157 158
	if (self->file)
		perf_data_file__close(self->file);
159
	free(self);
160
	vdso__exit();
161
}
162

163 164 165
static int process_event_synth_tracing_data_stub(struct perf_tool *tool
						 __maybe_unused,
						 union perf_event *event
166 167 168
						 __maybe_unused,
						 struct perf_session *session
						__maybe_unused)
169 170 171 172 173
{
	dump_printf(": unhandled!\n");
	return 0;
}

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

183 184 185 186 187
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)
188 189 190 191 192
{
	dump_printf(": unhandled!\n");
	return 0;
}

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

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

211
static int process_finished_round(struct perf_tool *tool,
212 213
				  union perf_event *event,
				  struct perf_session *session);
214

215
void perf_tool__fill_defaults(struct perf_tool *tool)
216
{
217 218 219 220
	if (tool->sample == NULL)
		tool->sample = process_event_sample_stub;
	if (tool->mmap == NULL)
		tool->mmap = process_event_stub;
221 222
	if (tool->mmap2 == NULL)
		tool->mmap2 = process_event_stub;
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	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) {
		if (tool->ordered_samples)
			tool->finished_round = process_finished_round;
246
		else
247
			tool->finished_round = process_finished_round_stub;
248
	}
249
}
250 251 252 253 254 255 256 257 258 259
 
void mem_bswap_32(void *src, int byte_size)
{
	u32 *m = src;
	while (byte_size > 0) {
		*m = bswap_32(*m);
		byte_size -= sizeof(u32);
		++m;
	}
}
260

261 262 263 264 265 266 267 268 269 270 271
void mem_bswap_64(void *src, int byte_size)
{
	u64 *m = src;

	while (byte_size > 0) {
		*m = bswap_64(*m);
		byte_size -= sizeof(u64);
		++m;
	}
}

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 468
	[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,
	[PERF_RECORD_HEADER_MAX]	  = NULL,
469 470
};

471 472
struct sample_queue {
	u64			timestamp;
473
	u64			file_offset;
474
	union perf_event	*event;
475 476 477
	struct list_head	list;
};

478 479 480 481
static void perf_session_free_sample_buffers(struct perf_session *session)
{
	struct ordered_samples *os = &session->ordered_samples;

482
	while (!list_empty(&os->to_free)) {
483 484
		struct sample_queue *sq;

485
		sq = list_entry(os->to_free.next, struct sample_queue, list);
486 487 488 489 490
		list_del(&sq->list);
		free(sq);
	}
}

491
static int perf_session_deliver_event(struct perf_session *session,
492
				      union perf_event *event,
493
				      struct perf_sample *sample,
494
				      struct perf_tool *tool,
495
				      u64 file_offset);
496

497
static int flush_sample_queue(struct perf_session *s,
498
		       struct perf_tool *tool)
499
{
500 501
	struct ordered_samples *os = &s->ordered_samples;
	struct list_head *head = &os->samples;
502
	struct sample_queue *tmp, *iter;
503
	struct perf_sample sample;
504 505
	u64 limit = os->next_flush;
	u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
506
	bool show_progress = limit == ULLONG_MAX;
507
	struct ui_progress prog;
508
	int ret;
509

510
	if (!tool->ordered_samples || !limit)
511
		return 0;
512

513 514 515
	if (show_progress)
		ui_progress__init(&prog, os->nr_samples, "Processing time ordered events...");

516
	list_for_each_entry_safe(iter, tmp, head, list) {
517 518 519
		if (session_done())
			return 0;

520
		if (iter->timestamp > limit)
521
			break;
522

523
		ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
524 525
		if (ret)
			pr_err("Can't parse sample, err = %d\n", ret);
526 527 528 529 530 531
		else {
			ret = perf_session_deliver_event(s, iter->event, &sample, tool,
							 iter->file_offset);
			if (ret)
				return ret;
		}
532

533
		os->last_flush = iter->timestamp;
534
		list_del(&iter->list);
535
		list_add(&iter->list, &os->sample_cache);
536 537 538

		if (show_progress)
			ui_progress__update(&prog, 1);
539
	}
540 541 542 543 544 545 546

	if (list_empty(head)) {
		os->last_sample = NULL;
	} else if (last_ts <= limit) {
		os->last_sample =
			list_entry(head->prev, struct sample_queue, list);
	}
547 548

	os->nr_samples = 0;
549 550

	return 0;
551 552
}

553 554 555 556 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
/*
 * 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...
 */
592
static int process_finished_round(struct perf_tool *tool,
593
				  union perf_event *event __maybe_unused,
594
				  struct perf_session *session)
595
{
596 597 598
	int ret = flush_sample_queue(session, tool);
	if (!ret)
		session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
599

600
	return ret;
601 602
}

603
/* The queue is ordered by time */
604
static void __queue_event(struct sample_queue *new, struct perf_session *s)
605
{
606 607 608 609
	struct ordered_samples *os = &s->ordered_samples;
	struct sample_queue *sample = os->last_sample;
	u64 timestamp = new->timestamp;
	struct list_head *p;
610

611
	++os->nr_samples;
612
	os->last_sample = new;
613

614 615 616
	if (!sample) {
		list_add(&new->list, &os->samples);
		os->max_timestamp = timestamp;
617 618 619 620
		return;
	}

	/*
621 622 623
	 * last_sample might point to some random place in the list as it's
	 * the last queued event. We expect that the new event is close to
	 * this.
624
	 */
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
	if (sample->timestamp <= timestamp) {
		while (sample->timestamp <= timestamp) {
			p = sample->list.next;
			if (p == &os->samples) {
				list_add_tail(&new->list, &os->samples);
				os->max_timestamp = timestamp;
				return;
			}
			sample = list_entry(p, struct sample_queue, list);
		}
		list_add_tail(&new->list, &sample->list);
	} else {
		while (sample->timestamp > timestamp) {
			p = sample->list.prev;
			if (p == &os->samples) {
				list_add(&new->list, &os->samples);
				return;
			}
			sample = list_entry(p, struct sample_queue, list);
		}
		list_add(&new->list, &sample->list);
	}
647 648
}

649 650
#define MAX_SAMPLE_BUFFER	(64 * 1024 / sizeof(struct sample_queue))

651
int perf_session_queue_event(struct perf_session *s, union perf_event *event,
652
				    struct perf_sample *sample, u64 file_offset)
653
{
654 655
	struct ordered_samples *os = &s->ordered_samples;
	struct list_head *sc = &os->sample_cache;
656
	u64 timestamp = sample->time;
657 658
	struct sample_queue *new;

659
	if (!timestamp || timestamp == ~0ULL)
660 661
		return -ETIME;

662 663 664 665 666
	if (timestamp < s->ordered_samples.last_flush) {
		printf("Warning: Timestamp below last timeslice flush\n");
		return -EINVAL;
	}

667 668 669
	if (!list_empty(sc)) {
		new = list_entry(sc->next, struct sample_queue, list);
		list_del(&new->list);
670 671 672 673
	} else if (os->sample_buffer) {
		new = os->sample_buffer + os->sample_buffer_idx;
		if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
			os->sample_buffer = NULL;
674
	} else {
675 676
		os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
		if (!os->sample_buffer)
677
			return -ENOMEM;
678 679 680
		list_add(&os->sample_buffer->list, &os->to_free);
		os->sample_buffer_idx = 2;
		new = os->sample_buffer + 1;
681
	}
682 683

	new->timestamp = timestamp;
684
	new->file_offset = file_offset;
685
	new->event = event;
686

687
	__queue_event(new, s);
688 689 690

	return 0;
}
691

692
static void callchain__printf(struct perf_sample *sample)
693 694
{
	unsigned int i;
695

696
	printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
697 698

	for (i = 0; i < sample->callchain->nr; i++)
699 700
		printf("..... %2d: %016" PRIx64 "\n",
		       i, sample->callchain->ips[i]);
701 702
}

703 704 705 706 707 708 709 710 711 712 713 714
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);
}

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
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);
	}
}

static void regs_user__printf(struct perf_sample *sample, u64 mask)
{
	struct regs_dump *user_regs = &sample->user_regs;

	if (user_regs->regs) {
		printf("... user regs: mask 0x%" PRIx64 "\n", mask);
		regs_dump__printf(mask, user_regs->regs);
	}
}

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

743
static void perf_session__print_tstamp(struct perf_session *session,
744
				       union perf_event *event,
745
				       struct perf_sample *sample)
746
{
747
	u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
748

749
	if (event->header.type != PERF_RECORD_SAMPLE &&
750
	    !perf_evlist__sample_id_all(session->evlist)) {
751 752 753 754
		fputs("-1 -1 ", stdout);
		return;
	}

755
	if ((sample_type & PERF_SAMPLE_CPU))
756 757
		printf("%u ", sample->cpu);

758
	if (sample_type & PERF_SAMPLE_TIME)
759
		printf("%" PRIu64 " ", sample->time);
760 761
}

762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
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);
}

792
static void dump_event(struct perf_session *session, union perf_event *event,
793
		       u64 file_offset, struct perf_sample *sample)
794 795 796 797
{
	if (!dump_trace)
		return;

798 799
	printf("\n%#" PRIx64 " [%#x]: event: %d\n",
	       file_offset, event->header.size, event->header.type);
800 801 802 803 804 805

	trace_event(event);

	if (sample)
		perf_session__print_tstamp(session, event, sample);

806
	printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
807
	       event->header.size, perf_event__name(event->header.type));
808 809
}

810
static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
811
			struct perf_sample *sample)
812
{
813 814
	u64 sample_type;

815 816 817
	if (!dump_trace)
		return;

818
	printf("(IP, %d): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
819
	       event->header.misc, sample->pid, sample->tid, sample->ip,
820
	       sample->period, sample->addr);
821

822
	sample_type = evsel->attr.sample_type;
823 824

	if (sample_type & PERF_SAMPLE_CALLCHAIN)
825
		callchain__printf(sample);
826

827
	if (sample_type & PERF_SAMPLE_BRANCH_STACK)
828
		branch_stack__printf(sample);
829 830 831 832 833 834

	if (sample_type & PERF_SAMPLE_REGS_USER)
		regs_user__printf(sample, evsel->attr.sample_regs_user);

	if (sample_type & PERF_SAMPLE_STACK_USER)
		stack_user__printf(&sample->user_stack);
835 836 837

	if (sample_type & PERF_SAMPLE_WEIGHT)
		printf("... weight: %" PRIu64 "\n", sample->weight);
838 839 840

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

842 843 844
	if (sample_type & PERF_SAMPLE_TRANSACTION)
		printf("... transaction: %" PRIx64 "\n", sample->transaction);

845 846
	if (sample_type & PERF_SAMPLE_READ)
		sample_read__printf(sample, evsel->attr.read_format);
847 848
}

849 850
static struct machine *
	perf_session__find_machine_for_cpumode(struct perf_session *session,
851 852
					       union perf_event *event,
					       struct perf_sample *sample)
853 854 855
{
	const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;

856 857 858
	if (perf_guest &&
	    ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
	     (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
859 860
		u32 pid;

861 862
		if (event->header.type == PERF_RECORD_MMAP
		    || event->header.type == PERF_RECORD_MMAP2)
863 864
			pid = event->mmap.pid;
		else
865
			pid = sample->pid;
866

867
		return perf_session__findnew_machine(session, pid);
868
	}
869

870
	return &session->machines.host;
871 872
}

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
static int deliver_sample_value(struct perf_session *session,
				struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct sample_read_value *v,
				struct machine *machine)
{
	struct perf_sample_id *sid;

	sid = perf_evlist__id2sid(session->evlist, v->id);
	if (sid) {
		sample->id     = v->id;
		sample->period = v->value - sid->period;
		sid->period    = v->value;
	}

	if (!sid || sid->evsel == NULL) {
		++session->stats.nr_unknown_id;
		return 0;
	}

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

static int deliver_sample_group(struct perf_session *session,
				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++) {
		ret = deliver_sample_value(session, tool, event, sample,
					   &sample->read.group.values[i],
					   machine);
		if (ret)
			break;
	}

	return ret;
}

static int
perf_session__deliver_sample(struct perf_session *session,
			     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)
		return deliver_sample_group(session, tool, event, sample,
					    machine);
	else
		return deliver_sample_value(session, tool, event, sample,
					    &sample->read.one, machine);
}

942
static int perf_session_deliver_event(struct perf_session *session,
943
				      union perf_event *event,
944
				      struct perf_sample *sample,
945
				      struct perf_tool *tool,
946
				      u64 file_offset)
947
{
948
	struct perf_evsel *evsel;
949
	struct machine *machine;
950

951 952
	dump_event(session, event, file_offset, sample);

953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
	evsel = perf_evlist__id2evsel(session->evlist, sample->id);
	if (evsel != NULL && event->header.type != PERF_RECORD_SAMPLE) {
		/*
		 * XXX We're leaving PERF_RECORD_SAMPLE unnacounted here
		 * because the tools right now may apply filters, discarding
		 * some of the samples. For consistency, in the future we
		 * should have something like nr_filtered_samples and remove
		 * the sample->period from total_sample_period, etc, KISS for
		 * now tho.
		 *
		 * Also testing against NULL allows us to handle files without
		 * attr.sample_id_all and/or without PERF_SAMPLE_ID. In the
		 * future probably it'll be a good idea to restrict event
		 * processing via perf_session to files with both set.
		 */
		hists__inc_nr_events(&evsel->hists, event->header.type);
	}

971 972
	machine = perf_session__find_machine_for_cpumode(session, event,
							 sample);
973

974 975
	switch (event->header.type) {
	case PERF_RECORD_SAMPLE:
976
		dump_sample(evsel, event, sample);
977
		if (evsel == NULL) {
978
			++session->stats.nr_unknown_id;
979
			return 0;
980
		}
981
		if (machine == NULL) {
982
			++session->stats.nr_unprocessable_samples;
983
			return 0;
984
		}
985 986
		return perf_session__deliver_sample(session, tool, event,
						    sample, evsel, machine);
987
	case PERF_RECORD_MMAP:
988
		return tool->mmap(tool, event, sample, machine);
989 990
	case PERF_RECORD_MMAP2:
		return tool->mmap2(tool, event, sample, machine);
991
	case PERF_RECORD_COMM:
992
		return tool->comm(tool, event, sample, machine);
993
	case PERF_RECORD_FORK:
994
		return tool->fork(tool, event, sample, machine);
995
	case PERF_RECORD_EXIT:
996
		return tool->exit(tool, event, sample, machine);
997
	case PERF_RECORD_LOST:
998
		if (tool->lost == perf_event__process_lost)
999
			session->stats.total_lost += event->lost.lost;
1000
		return tool->lost(tool, event, sample, machine);
1001
	case PERF_RECORD_READ:
1002
		return tool->read(tool, event, sample, evsel, machine);
1003
	case PERF_RECORD_THROTTLE:
1004
		return tool->throttle(tool, event, sample, machine);
1005
	case PERF_RECORD_UNTHROTTLE:
1006
		return tool->unthrottle(tool, event, sample, machine);
1007
	default:
1008
		++session->stats.nr_unknown_events;
1009 1010 1011 1012
		return -1;
	}
}

1013
static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
1014
					    struct perf_tool *tool, u64 file_offset)
1015
{
1016
	int fd = perf_data_file__fd(session->file);
1017 1018
	int err;

1019
	dump_event(session, event, file_offset, NULL);
1020

1021
	/* These events are processed right away */
1022
	switch (event->header.type) {
1023
	case PERF_RECORD_HEADER_ATTR:
1024
		err = tool->attr(tool, event, &session->evlist);
1025
		if (err == 0)
1026
			perf_session__set_id_hdr_size(session);
1027
		return err;
1028 1029
	case PERF_RECORD_HEADER_TRACING_DATA:
		/* setup for reading amidst mmap */
1030
		lseek(fd, file_offset, SEEK_SET);
1031
		return tool->tracing_data(tool, event, session);
1032
	case PERF_RECORD_HEADER_BUILD_ID:
1033
		return tool->build_id(tool, event, session);
1034
	case PERF_RECORD_FINISHED_ROUND:
1035
		return tool->finished_round(tool, event, session);
1036
	default:
1037
		return -EINVAL;
1038
	}
1039 1040
}

1041 1042 1043 1044 1045 1046 1047 1048 1049
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);
}

1050 1051 1052 1053
static int perf_session__process_event(struct perf_session *session,
				       union perf_event *event,
				       struct perf_tool *tool,
				       u64 file_offset)
1054
{
1055
	struct perf_sample sample;
1056 1057
	int ret;

1058
	if (session->header.needs_swap)
1059
		event_swap(event, perf_evlist__sample_id_all(session->evlist));
1060 1061 1062 1063

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

1064
	events_stats__inc(&session->stats, event->header.type);
1065 1066

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

1069 1070 1071
	/*
	 * For all kernel events we get the sample data
	 */
1072
	ret = perf_evlist__parse_sample(session->evlist, event, &sample);
1073 1074
	if (ret)
		return ret;
1075

1076
	if (tool->ordered_samples) {
1077 1078
		ret = perf_session_queue_event(session, event, &sample,
					       file_offset);
1079 1080 1081 1082
		if (ret != -ETIME)
			return ret;
	}

1083
	return perf_session_deliver_event(session, event, &sample, tool,
1084
					  file_offset);
1085 1086
}

1087 1088 1089 1090 1091 1092 1093
void perf_event_header__bswap(struct perf_event_header *self)
{
	self->type = bswap_32(self->type);
	self->misc = bswap_16(self->misc);
	self->size = bswap_16(self->size);
}

1094 1095
struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
{
1096
	return machine__findnew_thread(&session->machines.host, 0, pid);
1097 1098
}

1099 1100 1101 1102
static struct thread *perf_session__register_idle_thread(struct perf_session *self)
{
	struct thread *thread = perf_session__findnew(self, 0);

1103
	if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
1104 1105 1106 1107 1108 1109 1110
		pr_err("problem inserting idle task.\n");
		thread = NULL;
	}

	return thread;
}

1111
static void perf_session__warn_about_errors(const struct perf_session *session,
1112
					    const struct perf_tool *tool)
1113
{
1114
	if (tool->lost == perf_event__process_lost &&
1115
	    session->stats.nr_events[PERF_RECORD_LOST] != 0) {
1116 1117
		ui__warning("Processed %d events and lost %d chunks!\n\n"
			    "Check IO/CPU overload!\n\n",
1118 1119
			    session->stats.nr_events[0],
			    session->stats.nr_events[PERF_RECORD_LOST]);
1120 1121
	}

1122
	if (session->stats.nr_unknown_events != 0) {
1123 1124 1125 1126 1127
		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",
1128
			    session->stats.nr_unknown_events);
1129 1130
	}

1131
	if (session->stats.nr_unknown_id != 0) {
1132
		ui__warning("%u samples with id not present in the header\n",
1133
			    session->stats.nr_unknown_id);
1134 1135
	}

1136
 	if (session->stats.nr_invalid_chains != 0) {
1137 1138 1139
 		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",
1140 1141
 			    session->stats.nr_invalid_chains,
 			    session->stats.nr_events[PERF_RECORD_SAMPLE]);
1142
 	}
1143

1144
	if (session->stats.nr_unprocessable_samples != 0) {
1145 1146
		ui__warning("%u unprocessable samples recorded.\n"
			    "Do you have a KVM guest running and not using 'perf kvm'?\n",
1147
			    session->stats.nr_unprocessable_samples);
1148
	}
1149 1150
}

1151 1152 1153
volatile int session_done;

static int __perf_session__process_pipe_events(struct perf_session *self,
1154
					       struct perf_tool *tool)
1155
{
1156
	int fd = perf_data_file__fd(self->file);
1157 1158 1159
	union perf_event *event;
	uint32_t size, cur_size = 0;
	void *buf = NULL;
1160 1161 1162 1163 1164
	int skip = 0;
	u64 head;
	int err;
	void *p;

1165
	perf_tool__fill_defaults(tool);
1166 1167

	head = 0;
1168 1169 1170 1171 1172
	cur_size = sizeof(union perf_event);

	buf = malloc(cur_size);
	if (!buf)
		return -errno;
1173
more:
1174
	event = buf;
1175
	err = readn(fd, event, sizeof(struct perf_event_header));
1176 1177 1178 1179 1180 1181 1182 1183 1184
	if (err <= 0) {
		if (err == 0)
			goto done;

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

	if (self->header.needs_swap)
1185
		perf_event_header__bswap(&event->header);
1186

1187
	size = event->header.size;
1188 1189 1190 1191
	if (size < sizeof(struct perf_event_header)) {
		pr_err("bad event header size\n");
		goto out_err;
	}
1192

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	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;
1204 1205
	p += sizeof(struct perf_event_header);

1206
	if (size - sizeof(struct perf_event_header)) {
1207
		err = readn(fd, p, size - sizeof(struct perf_event_header));
1208 1209 1210 1211 1212
		if (err <= 0) {
			if (err == 0) {
				pr_err("unexpected end of event stream\n");
				goto done;
			}
1213

1214 1215 1216
			pr_err("failed to read event data\n");
			goto out_err;
		}
1217 1218
	}

1219
	if ((skip = perf_session__process_event(self, event, tool, head)) < 0) {
1220
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1221
		       head, event->header.size, event->header.type);
1222 1223
		err = -EINVAL;
		goto out_err;
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
	}

	head += size;

	if (skip > 0)
		head += skip;

	if (!session_done())
		goto more;
done:
1234 1235 1236
	/* do the final flush for ordered samples */
	self->ordered_samples.next_flush = ULLONG_MAX;
	err = flush_sample_queue(self, tool);
1237
out_err:
1238
	free(buf);
1239
	perf_session__warn_about_errors(self, tool);
1240
	perf_session_free_sample_buffers(self);
1241 1242 1243
	return err;
}

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
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);

1262 1263 1264 1265
	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);
1266
		return NULL;
1267
	}
1268 1269 1270 1271

	return event;
}

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
/*
 * 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

1284
int __perf_session__process_events(struct perf_session *session,
1285
				   u64 data_offset, u64 data_size,
1286
				   u64 file_size, struct perf_tool *tool)
1287
{
1288
	int fd = perf_data_file__fd(session->file);
1289
	u64 head, page_offset, file_offset, file_pos;
1290
	int err, mmap_prot, mmap_flags, map_idx = 0;
1291
	size_t	mmap_size;
1292
	char *buf, *mmaps[NUM_MMAPS];
1293
	union perf_event *event;
1294
	uint32_t size;
1295
	struct ui_progress prog;
1296

1297
	perf_tool__fill_defaults(tool);
1298

1299 1300 1301
	page_offset = page_size * (data_offset / page_size);
	file_offset = page_offset;
	head = data_offset - page_offset;
1302

1303
	if (data_size && (data_offset + data_size < file_size))
1304 1305
		file_size = data_offset + data_size;

1306
	ui_progress__init(&prog, file_size, "Processing events...");
1307

1308
	mmap_size = MMAP_SIZE;
1309 1310 1311
	if (mmap_size > file_size)
		mmap_size = file_size;

1312 1313
	memset(mmaps, 0, sizeof(mmaps));

1314 1315 1316
	mmap_prot  = PROT_READ;
	mmap_flags = MAP_SHARED;

1317
	if (session->header.needs_swap) {
1318 1319 1320
		mmap_prot  |= PROT_WRITE;
		mmap_flags = MAP_PRIVATE;
	}
1321
remap:
1322
	buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
1323
		   file_offset);
1324 1325 1326 1327 1328
	if (buf == MAP_FAILED) {
		pr_err("failed to mmap file\n");
		err = -errno;
		goto out_err;
	}
1329 1330
	mmaps[map_idx] = buf;
	map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
1331
	file_pos = file_offset + head;
1332 1333

more:
1334 1335
	event = fetch_mmaped_event(session, head, mmap_size, buf);
	if (!event) {
1336 1337 1338 1339
		if (mmaps[map_idx]) {
			munmap(mmaps[map_idx], mmap_size);
			mmaps[map_idx] = NULL;
		}
1340

1341 1342 1343
		page_offset = page_size * (head / page_size);
		file_offset += page_offset;
		head -= page_offset;
1344 1345 1346 1347 1348
		goto remap;
	}

	size = event->header.size;

1349
	if (size < sizeof(struct perf_event_header) ||
1350
	    perf_session__process_event(session, event, tool, file_pos) < 0) {
1351 1352 1353 1354 1355
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
		       file_offset + head, event->header.size,
		       event->header.type);
		err = -EINVAL;
		goto out_err;
1356 1357 1358
	}

	head += size;
1359
	file_pos += size;
1360

1361
	ui_progress__update(&prog, size);
1362

1363
	if (session_done())
1364
		goto out;
1365

1366
	if (file_pos < file_size)
1367
		goto more;
1368

1369
out:
1370
	/* do the final flush for ordered samples */
1371
	session->ordered_samples.next_flush = ULLONG_MAX;
1372
	err = flush_sample_queue(session, tool);
1373
out_err:
N
Namhyung Kim 已提交
1374
	ui_progress__finish();
1375
	perf_session__warn_about_errors(session, tool);
1376
	perf_session_free_sample_buffers(session);
1377 1378
	return err;
}
1379

1380
int perf_session__process_events(struct perf_session *self,
1381
				 struct perf_tool *tool)
1382
{
1383
	u64 size = perf_data_file__size(self->file);
1384 1385 1386 1387 1388
	int err;

	if (perf_session__register_idle_thread(self) == NULL)
		return -ENOMEM;

1389
	if (!perf_data_file__is_pipe(self->file))
1390 1391 1392
		err = __perf_session__process_events(self,
						     self->header.data_offset,
						     self->header.data_size,
1393
						     size, tool);
1394
	else
1395
		err = __perf_session__process_pipe_events(self, tool);
1396

1397 1398 1399
	return err;
}

1400
bool perf_session__has_traces(struct perf_session *session, const char *msg)
1401
{
1402 1403 1404 1405 1406
	struct perf_evsel *evsel;

	list_for_each_entry(evsel, &session->evlist->entries, node) {
		if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
			return true;
1407 1408
	}

1409 1410
	pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
	return false;
1411
}
1412

1413 1414
int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
				     const char *symbol_name, u64 addr)
1415 1416
{
	char *bracket;
1417
	enum map_type i;
1418 1419 1420 1421 1422
	struct ref_reloc_sym *ref;

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

1424 1425 1426
	ref->name = strdup(symbol_name);
	if (ref->name == NULL) {
		free(ref);
1427
		return -ENOMEM;
1428
	}
1429

1430
	bracket = strchr(ref->name, ']');
1431 1432 1433
	if (bracket)
		*bracket = '\0';

1434
	ref->addr = addr;
1435 1436

	for (i = 0; i < MAP__NR_TYPES; ++i) {
1437 1438
		struct kmap *kmap = map__kmap(maps[i]);
		kmap->ref_reloc_sym = ref;
1439 1440
	}

1441 1442
	return 0;
}
1443 1444 1445

size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
{
1446
	return machines__fprintf_dsos(&self->machines, fp);
1447
}
1448 1449

size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
1450
					  bool (skip)(struct dso *dso, int parm), int parm)
1451
{
1452
	return machines__fprintf_dsos_buildid(&self->machines, fp, skip, parm);
1453
}
1454 1455 1456 1457 1458 1459

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

1460
	ret += events_stats__fprintf(&session->stats, fp);
1461 1462

	list_for_each_entry(pos, &session->evlist->entries, node) {
1463
		ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
1464
		ret += events_stats__fprintf(&pos->hists.stats, fp);
1465 1466 1467 1468
	}

	return ret;
}
1469

1470 1471 1472 1473 1474 1475
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...
	 */
1476
	return machine__fprintf(&session->machines.host, fp);
1477 1478
}

1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
					      unsigned int type)
{
	struct perf_evsel *pos;

	list_for_each_entry(pos, &session->evlist->entries, node) {
		if (pos->attr.type == type)
			return pos;
	}
	return NULL;
}

1491 1492
void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
			  struct perf_sample *sample, struct machine *machine,
1493
			  unsigned int print_opts, unsigned int stack_depth)
1494 1495 1496
{
	struct addr_location al;
	struct callchain_cursor_node *node;
1497 1498 1499 1500
	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;
1501 1502
	int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
	char s = print_oneline ? ' ' : '\t';
1503

1504
	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
1505 1506 1507 1508 1509 1510 1511
		error("problem processing %d event, skipping it.\n",
			event->header.type);
		return;
	}

	if (symbol_conf.use_callchain && sample->callchain) {

1512
		if (machine__resolve_callchain(machine, evsel, al.thread,
1513 1514
					       sample, NULL, NULL,
					       PERF_MAX_STACK_DEPTH) != 0) {
1515 1516 1517 1518
			if (verbose)
				error("Failed to resolve callchain. Skipping\n");
			return;
		}
1519
		callchain_cursor_commit(&callchain_cursor);
1520

1521
		while (stack_depth) {
1522
			node = callchain_cursor_current(&callchain_cursor);
1523 1524 1525
			if (!node)
				break;

1526
			if (print_ip)
1527
				printf("%c%16" PRIx64, s, node->ip);
1528

1529
			if (print_sym) {
1530
				printf(" ");
1531 1532
				if (print_symoffset) {
					al.addr = node->ip;
1533
					al.map  = node->map;
1534 1535 1536
					symbol__fprintf_symname_offs(node->sym, &al, stdout);
				} else
					symbol__fprintf_symname(node->sym, stdout);
1537
			}
1538

1539
			if (print_dso) {
1540
				printf(" (");
1541
				map__fprintf_dsoname(node->map, stdout);
1542
				printf(")");
1543
			}
1544 1545 1546

			if (!print_oneline)
				printf("\n");
1547

1548
			callchain_cursor_advance(&callchain_cursor);
1549 1550

			stack_depth--;
1551 1552 1553
		}

	} else {
1554 1555 1556
		if (print_ip)
			printf("%16" PRIx64, sample->ip);

1557
		if (print_sym) {
1558
			printf(" ");
1559 1560 1561 1562 1563
			if (print_symoffset)
				symbol__fprintf_symname_offs(al.sym, &al,
							     stdout);
			else
				symbol__fprintf_symname(al.sym, stdout);
1564 1565 1566
		}

		if (print_dso) {
1567 1568 1569
			printf(" (");
			map__fprintf_dsoname(al.map, stdout);
			printf(")");
1570
		}
1571 1572
	}
}
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594

int perf_session__cpu_bitmap(struct perf_session *session,
			     const char *cpu_list, unsigned long *cpu_bitmap)
{
	int i;
	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);
1595 1596 1597 1598
	if (map == NULL) {
		pr_err("Invalid cpu_list\n");
		return -1;
	}
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613

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

		set_bit(cpu, cpu_bitmap);
	}

	return 0;
}
1614 1615 1616 1617

void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
				bool full)
{
1618
	int fd = perf_data_file__fd(session->file);
1619 1620 1621 1622 1623 1624
	struct stat st;
	int ret;

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

1625
	ret = fstat(fd, &st);
1626 1627 1628 1629 1630 1631 1632 1633
	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");
}
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644


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++) {
1645 1646 1647 1648 1649
		/*
		 * 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);
1650
		if (evsel == NULL)
1651
			continue;
1652 1653 1654

		err = -EEXIST;
		if (evsel->handler.func != NULL)
1655
			goto out;
1656 1657 1658 1659 1660 1661 1662
		evsel->handler.func = assocs[i].handler;
	}

	err = 0;
out:
	return err;
}