evsel.c 22.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
 *
 * Parts came from builtin-{top,stat,record}.c, see those files for further
 * copyright notes.
 *
 * Released under the GPL v2. (and only v2, not any later version)
 */

10
#include <byteswap.h>
11
#include <linux/bitops.h>
12
#include "asm/bug.h"
13
#include "evsel.h"
14
#include "evlist.h"
15
#include "util.h"
16
#include "cpumap.h"
17
#include "thread_map.h"
18
#include "target.h"
19
#include "../../../include/linux/hw_breakpoint.h"
20 21
#include "../../include/linux/perf_event.h"
#include "perf_regs.h"
22

23
#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
24
#define GROUP_FD(group_fd, cpu) (*(int *)xyarray__entry(group_fd, cpu, 0))
25

26
static int __perf_evsel__sample_size(u64 sample_type)
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
{
	u64 mask = sample_type & PERF_SAMPLE_MASK;
	int size = 0;
	int i;

	for (i = 0; i < 64; i++) {
		if (mask & (1ULL << i))
			size++;
	}

	size *= sizeof(u64);

	return size;
}

42
void hists__init(struct hists *hists)
43 44 45 46 47 48 49 50 51
{
	memset(hists, 0, sizeof(*hists));
	hists->entries_in_array[0] = hists->entries_in_array[1] = RB_ROOT;
	hists->entries_in = &hists->entries_in_array[0];
	hists->entries_collapsed = RB_ROOT;
	hists->entries = RB_ROOT;
	pthread_mutex_init(&hists->lock, NULL);
}

52 53 54 55 56 57
void perf_evsel__init(struct perf_evsel *evsel,
		      struct perf_event_attr *attr, int idx)
{
	evsel->idx	   = idx;
	evsel->attr	   = *attr;
	INIT_LIST_HEAD(&evsel->node);
58
	hists__init(&evsel->hists);
59
	evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
60 61
}

62
struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
63 64 65
{
	struct perf_evsel *evsel = zalloc(sizeof(*evsel));

66 67
	if (evsel != NULL)
		perf_evsel__init(evsel, attr, idx);
68 69 70 71

	return evsel;
}

72 73 74 75 76 77 78 79 80 81 82 83 84
static const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
	"cycles",
	"instructions",
	"cache-references",
	"cache-misses",
	"branches",
	"branch-misses",
	"bus-cycles",
	"stalled-cycles-frontend",
	"stalled-cycles-backend",
	"ref-cycles",
};

85
static const char *__perf_evsel__hw_name(u64 config)
86 87 88 89 90 91 92
{
	if (config < PERF_COUNT_HW_MAX && perf_evsel__hw_names[config])
		return perf_evsel__hw_names[config];

	return "unknown-hardware";
}

93
static int perf_evsel__add_modifiers(struct perf_evsel *evsel, char *bf, size_t size)
94
{
95
	int colon = 0, r = 0;
96 97 98 99 100
	struct perf_event_attr *attr = &evsel->attr;
	bool exclude_guest_default = false;

#define MOD_PRINT(context, mod)	do {					\
		if (!attr->exclude_##context) {				\
101
			if (!colon) colon = ++r;			\
102 103 104 105 106 107 108 109 110 111 112 113
			r += scnprintf(bf + r, size - r, "%c", mod);	\
		} } while(0)

	if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) {
		MOD_PRINT(kernel, 'k');
		MOD_PRINT(user, 'u');
		MOD_PRINT(hv, 'h');
		exclude_guest_default = true;
	}

	if (attr->precise_ip) {
		if (!colon)
114
			colon = ++r;
115 116 117 118 119 120 121 122 123 124
		r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp");
		exclude_guest_default = true;
	}

	if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) {
		MOD_PRINT(host, 'H');
		MOD_PRINT(guest, 'G');
	}
#undef MOD_PRINT
	if (colon)
125
		bf[colon - 1] = ':';
126 127 128
	return r;
}

129 130 131 132 133 134
static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
{
	int r = scnprintf(bf, size, "%s", __perf_evsel__hw_name(evsel->attr.config));
	return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
}

135 136 137 138 139 140 141 142 143 144 145 146
static const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
	"cpu-clock",
	"task-clock",
	"page-faults",
	"context-switches",
	"CPU-migrations",
	"minor-faults",
	"major-faults",
	"alignment-faults",
	"emulation-faults",
};

147
static const char *__perf_evsel__sw_name(u64 config)
148 149 150 151 152 153 154 155 156 157 158 159
{
	if (config < PERF_COUNT_SW_MAX && perf_evsel__sw_names[config])
		return perf_evsel__sw_names[config];
	return "unknown-software";
}

static int perf_evsel__sw_name(struct perf_evsel *evsel, char *bf, size_t size)
{
	int r = scnprintf(bf, size, "%s", __perf_evsel__sw_name(evsel->attr.config));
	return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
}

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
static int __perf_evsel__bp_name(char *bf, size_t size, u64 addr, u64 type)
{
	int r;

	r = scnprintf(bf, size, "mem:0x%" PRIx64 ":", addr);

	if (type & HW_BREAKPOINT_R)
		r += scnprintf(bf + r, size - r, "r");

	if (type & HW_BREAKPOINT_W)
		r += scnprintf(bf + r, size - r, "w");

	if (type & HW_BREAKPOINT_X)
		r += scnprintf(bf + r, size - r, "x");

	return r;
}

static int perf_evsel__bp_name(struct perf_evsel *evsel, char *bf, size_t size)
{
	struct perf_event_attr *attr = &evsel->attr;
	int r = __perf_evsel__bp_name(bf, size, attr->bp_addr, attr->bp_type);
	return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
}

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
				[PERF_EVSEL__MAX_ALIASES] = {
 { "L1-dcache",	"l1-d",		"l1d",		"L1-data",		},
 { "L1-icache",	"l1-i",		"l1i",		"L1-instruction",	},
 { "LLC",	"L2",							},
 { "dTLB",	"d-tlb",	"Data-TLB",				},
 { "iTLB",	"i-tlb",	"Instruction-TLB",			},
 { "branch",	"branches",	"bpu",		"btb",		"bpc",	},
 { "node",								},
};

const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
				   [PERF_EVSEL__MAX_ALIASES] = {
 { "load",	"loads",	"read",					},
 { "store",	"stores",	"write",				},
 { "prefetch",	"prefetches",	"speculative-read", "speculative-load",	},
};

const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
				       [PERF_EVSEL__MAX_ALIASES] = {
 { "refs",	"Reference",	"ops",		"access",		},
 { "misses",	"miss",							},
};

#define C(x)		PERF_COUNT_HW_CACHE_##x
#define CACHE_READ	(1 << C(OP_READ))
#define CACHE_WRITE	(1 << C(OP_WRITE))
#define CACHE_PREFETCH	(1 << C(OP_PREFETCH))
#define COP(x)		(1 << x)

/*
 * cache operartion stat
 * L1I : Read and prefetch only
 * ITLB and BPU : Read-only
 */
static unsigned long perf_evsel__hw_cache_stat[C(MAX)] = {
 [C(L1D)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(L1I)]	= (CACHE_READ | CACHE_PREFETCH),
 [C(LL)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(DTLB)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 [C(ITLB)]	= (CACHE_READ),
 [C(BPU)]	= (CACHE_READ),
 [C(NODE)]	= (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
};

bool perf_evsel__is_cache_op_valid(u8 type, u8 op)
{
	if (perf_evsel__hw_cache_stat[type] & COP(op))
		return true;	/* valid */
	else
		return false;	/* invalid */
}

int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
					    char *bf, size_t size)
{
	if (result) {
		return scnprintf(bf, size, "%s-%s-%s", perf_evsel__hw_cache[type][0],
				 perf_evsel__hw_cache_op[op][0],
				 perf_evsel__hw_cache_result[result][0]);
	}

	return scnprintf(bf, size, "%s-%s", perf_evsel__hw_cache[type][0],
			 perf_evsel__hw_cache_op[op][1]);
}

251
static int __perf_evsel__hw_cache_name(u64 config, char *bf, size_t size)
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
{
	u8 op, result, type = (config >>  0) & 0xff;
	const char *err = "unknown-ext-hardware-cache-type";

	if (type > PERF_COUNT_HW_CACHE_MAX)
		goto out_err;

	op = (config >>  8) & 0xff;
	err = "unknown-ext-hardware-cache-op";
	if (op > PERF_COUNT_HW_CACHE_OP_MAX)
		goto out_err;

	result = (config >> 16) & 0xff;
	err = "unknown-ext-hardware-cache-result";
	if (result > PERF_COUNT_HW_CACHE_RESULT_MAX)
		goto out_err;

	err = "invalid-cache";
	if (!perf_evsel__is_cache_op_valid(type, op))
		goto out_err;

	return __perf_evsel__hw_cache_type_op_res_name(type, op, result, bf, size);
out_err:
	return scnprintf(bf, size, "%s", err);
}

static int perf_evsel__hw_cache_name(struct perf_evsel *evsel, char *bf, size_t size)
{
	int ret = __perf_evsel__hw_cache_name(evsel->attr.config, bf, size);
	return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
}

284 285 286 287 288 289
static int perf_evsel__raw_name(struct perf_evsel *evsel, char *bf, size_t size)
{
	int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->attr.config);
	return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
}

290
const char *perf_evsel__name(struct perf_evsel *evsel)
291
{
292
	char bf[128];
293

294 295
	if (evsel->name)
		return evsel->name;
296 297 298

	switch (evsel->attr.type) {
	case PERF_TYPE_RAW:
299
		perf_evsel__raw_name(evsel, bf, sizeof(bf));
300 301 302
		break;

	case PERF_TYPE_HARDWARE:
303
		perf_evsel__hw_name(evsel, bf, sizeof(bf));
304
		break;
305 306

	case PERF_TYPE_HW_CACHE:
307
		perf_evsel__hw_cache_name(evsel, bf, sizeof(bf));
308 309
		break;

310
	case PERF_TYPE_SOFTWARE:
311
		perf_evsel__sw_name(evsel, bf, sizeof(bf));
312 313
		break;

314
	case PERF_TYPE_TRACEPOINT:
315
		scnprintf(bf, sizeof(bf), "%s", "unknown tracepoint");
316 317
		break;

318 319 320 321
	case PERF_TYPE_BREAKPOINT:
		perf_evsel__bp_name(evsel, bf, sizeof(bf));
		break;

322
	default:
323
		scnprintf(bf, sizeof(bf), "%s", "unknown attr type");
324
		break;
325 326
	}

327 328 329
	evsel->name = strdup(bf);

	return evsel->name ?: "unknown";
330 331
}

332 333
void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
			struct perf_evsel *first)
334 335 336 337
{
	struct perf_event_attr *attr = &evsel->attr;
	int track = !evsel->idx; /* only the first counter needs these */

338
	attr->disabled = 1;
339
	attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
	attr->inherit	    = !opts->no_inherit;
	attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
			      PERF_FORMAT_TOTAL_TIME_RUNNING |
			      PERF_FORMAT_ID;

	attr->sample_type  |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;

	/*
	 * We default some events to a 1 default interval. But keep
	 * it a weak assumption overridable by the user.
	 */
	if (!attr->sample_period || (opts->user_freq != UINT_MAX &&
				     opts->user_interval != ULLONG_MAX)) {
		if (opts->freq) {
			attr->sample_type	|= PERF_SAMPLE_PERIOD;
			attr->freq		= 1;
			attr->sample_freq	= opts->freq;
		} else {
			attr->sample_period = opts->default_interval;
		}
	}

	if (opts->no_samples)
		attr->sample_freq = 0;

	if (opts->inherit_stat)
		attr->inherit_stat = 1;

	if (opts->sample_address) {
		attr->sample_type	|= PERF_SAMPLE_ADDR;
		attr->mmap_data = track;
	}

373
	if (opts->call_graph) {
374 375
		attr->sample_type	|= PERF_SAMPLE_CALLCHAIN;

376 377 378 379 380 381 382 383 384
		if (opts->call_graph == CALLCHAIN_DWARF) {
			attr->sample_type |= PERF_SAMPLE_REGS_USER |
					     PERF_SAMPLE_STACK_USER;
			attr->sample_regs_user = PERF_REGS_MASK;
			attr->sample_stack_user = opts->stack_dump_size;
			attr->exclude_callchain_user = 1;
		}
	}

385
	if (perf_target__has_cpu(&opts->target))
386 387
		attr->sample_type	|= PERF_SAMPLE_CPU;

388 389 390
	if (opts->period)
		attr->sample_type	|= PERF_SAMPLE_PERIOD;

391
	if (!opts->sample_id_all_missing &&
392
	    (opts->sample_time || !opts->no_inherit ||
393
	     perf_target__has_cpu(&opts->target)))
394 395 396 397 398 399 400 401 402 403 404 405
		attr->sample_type	|= PERF_SAMPLE_TIME;

	if (opts->raw_samples) {
		attr->sample_type	|= PERF_SAMPLE_TIME;
		attr->sample_type	|= PERF_SAMPLE_RAW;
		attr->sample_type	|= PERF_SAMPLE_CPU;
	}

	if (opts->no_delay) {
		attr->watermark = 0;
		attr->wakeup_events = 1;
	}
406 407 408 409
	if (opts->branch_stack) {
		attr->sample_type	|= PERF_SAMPLE_BRANCH_STACK;
		attr->branch_sample_type = opts->branch_stack;
	}
410 411 412 413

	attr->mmap = track;
	attr->comm = track;

414 415
	if (perf_target__none(&opts->target) &&
	    (!opts->group || evsel == first)) {
416 417 418 419
		attr->enable_on_exec = 1;
	}
}

420 421
int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
{
422
	int cpu, thread;
423
	evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
424 425 426 427 428 429 430 431 432

	if (evsel->fd) {
		for (cpu = 0; cpu < ncpus; cpu++) {
			for (thread = 0; thread < nthreads; thread++) {
				FD(evsel, cpu, thread) = -1;
			}
		}
	}

433 434 435
	return evsel->fd != NULL ? 0 : -ENOMEM;
}

436 437
int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
{
438 439 440 441 442 443 444 445 446 447 448 449
	evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
	if (evsel->sample_id == NULL)
		return -ENOMEM;

	evsel->id = zalloc(ncpus * nthreads * sizeof(u64));
	if (evsel->id == NULL) {
		xyarray__delete(evsel->sample_id);
		evsel->sample_id = NULL;
		return -ENOMEM;
	}

	return 0;
450 451
}

452 453 454 455 456 457 458
int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
{
	evsel->counts = zalloc((sizeof(*evsel->counts) +
				(ncpus * sizeof(struct perf_counts_values))));
	return evsel->counts != NULL ? 0 : -ENOMEM;
}

459 460 461 462 463 464
void perf_evsel__free_fd(struct perf_evsel *evsel)
{
	xyarray__delete(evsel->fd);
	evsel->fd = NULL;
}

465 466
void perf_evsel__free_id(struct perf_evsel *evsel)
{
467 468 469
	xyarray__delete(evsel->sample_id);
	evsel->sample_id = NULL;
	free(evsel->id);
470 471 472
	evsel->id = NULL;
}

473 474 475 476 477 478 479 480 481 482 483
void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
{
	int cpu, thread;

	for (cpu = 0; cpu < ncpus; cpu++)
		for (thread = 0; thread < nthreads; ++thread) {
			close(FD(evsel, cpu, thread));
			FD(evsel, cpu, thread) = -1;
		}
}

484
void perf_evsel__exit(struct perf_evsel *evsel)
485 486 487
{
	assert(list_empty(&evsel->node));
	xyarray__delete(evsel->fd);
488 489
	xyarray__delete(evsel->sample_id);
	free(evsel->id);
490 491 492 493 494
}

void perf_evsel__delete(struct perf_evsel *evsel)
{
	perf_evsel__exit(evsel);
S
Stephane Eranian 已提交
495
	close_cgroup(evsel->cgrp);
496
	free(evsel->name);
497 498
	free(evsel);
}
499 500 501 502 503 504 505 506 507 508

int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
			      int cpu, int thread, bool scale)
{
	struct perf_counts_values count;
	size_t nv = scale ? 3 : 1;

	if (FD(evsel, cpu, thread) < 0)
		return -EINVAL;

509 510 511
	if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1) < 0)
		return -ENOMEM;

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
	if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
		return -errno;

	if (scale) {
		if (count.run == 0)
			count.val = 0;
		else if (count.run < count.ena)
			count.val = (u64)((double)count.val * count.ena / count.run + 0.5);
	} else
		count.ena = count.run = 0;

	evsel->counts->cpu[cpu] = count;
	return 0;
}

int __perf_evsel__read(struct perf_evsel *evsel,
		       int ncpus, int nthreads, bool scale)
{
	size_t nv = scale ? 3 : 1;
	int cpu, thread;
	struct perf_counts_values *aggr = &evsel->counts->aggr, count;

534
	aggr->val = aggr->ena = aggr->run = 0;
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569

	for (cpu = 0; cpu < ncpus; cpu++) {
		for (thread = 0; thread < nthreads; thread++) {
			if (FD(evsel, cpu, thread) < 0)
				continue;

			if (readn(FD(evsel, cpu, thread),
				  &count, nv * sizeof(u64)) < 0)
				return -errno;

			aggr->val += count.val;
			if (scale) {
				aggr->ena += count.ena;
				aggr->run += count.run;
			}
		}
	}

	evsel->counts->scaled = 0;
	if (scale) {
		if (aggr->run == 0) {
			evsel->counts->scaled = -1;
			aggr->val = 0;
			return 0;
		}

		if (aggr->run < aggr->ena) {
			evsel->counts->scaled = 1;
			aggr->val = (u64)((double)aggr->val * aggr->ena / aggr->run + 0.5);
		}
	} else
		aggr->ena = aggr->run = 0;

	return 0;
}
570

571
static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
572 573
			      struct thread_map *threads, bool group,
			      struct xyarray *group_fds)
574
{
575
	int cpu, thread;
S
Stephane Eranian 已提交
576
	unsigned long flags = 0;
577
	int pid = -1, err;
578

579 580
	if (evsel->fd == NULL &&
	    perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
581
		return -ENOMEM;
582

S
Stephane Eranian 已提交
583 584 585 586 587
	if (evsel->cgrp) {
		flags = PERF_FLAG_PID_CGROUP;
		pid = evsel->cgrp->fd;
	}

588
	for (cpu = 0; cpu < cpus->nr; cpu++) {
589
		int group_fd = group_fds ? GROUP_FD(group_fds, cpu) : -1;
590

591
		for (thread = 0; thread < threads->nr; thread++) {
S
Stephane Eranian 已提交
592 593 594 595

			if (!evsel->cgrp)
				pid = threads->map[thread];

596
			FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
S
Stephane Eranian 已提交
597
								     pid,
598
								     cpus->map[cpu],
S
Stephane Eranian 已提交
599
								     group_fd, flags);
600 601
			if (FD(evsel, cpu, thread) < 0) {
				err = -errno;
602
				goto out_close;
603
			}
604 605 606

			if (group && group_fd == -1)
				group_fd = FD(evsel, cpu, thread);
607
		}
608 609 610 611 612
	}

	return 0;

out_close:
613 614 615 616 617 618 619
	do {
		while (--thread >= 0) {
			close(FD(evsel, cpu, thread));
			FD(evsel, cpu, thread) = -1;
		}
		thread = threads->nr;
	} while (--cpu >= 0);
620 621 622 623 624 625 626 627 628 629 630
	return err;
}

void perf_evsel__close(struct perf_evsel *evsel, int ncpus, int nthreads)
{
	if (evsel->fd == NULL)
		return;

	perf_evsel__close_fd(evsel, ncpus, nthreads);
	perf_evsel__free_fd(evsel);
	evsel->fd = NULL;
631 632
}

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
static struct {
	struct cpu_map map;
	int cpus[1];
} empty_cpu_map = {
	.map.nr	= 1,
	.cpus	= { -1, },
};

static struct {
	struct thread_map map;
	int threads[1];
} empty_thread_map = {
	.map.nr	 = 1,
	.threads = { -1, },
};

649
int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
650 651
		     struct thread_map *threads, bool group,
		     struct xyarray *group_fd)
652
{
653 654 655
	if (cpus == NULL) {
		/* Work around old compiler warnings about strict aliasing */
		cpus = &empty_cpu_map.map;
656 657
	}

658 659
	if (threads == NULL)
		threads = &empty_thread_map.map;
660

661
	return __perf_evsel__open(evsel, cpus, threads, group, group_fd);
662 663
}

664
int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
665 666
			     struct cpu_map *cpus, bool group,
			     struct xyarray *group_fd)
667
{
668 669
	return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group,
				  group_fd);
670
}
671

672
int perf_evsel__open_per_thread(struct perf_evsel *evsel,
673 674
				struct thread_map *threads, bool group,
				struct xyarray *group_fd)
675
{
676 677
	return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group,
				  group_fd);
678
}
679

680
static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
681 682
				       struct perf_sample *sample,
				       bool swapped)
683 684
{
	const u64 *array = event->sample.array;
685
	union u64_swap u;
686 687 688 689 690

	array += ((event->header.size -
		   sizeof(event->header)) / sizeof(u64)) - 1;

	if (type & PERF_SAMPLE_CPU) {
691 692 693 694 695 696 697 698
		u.val64 = *array;
		if (swapped) {
			/* undo swap of u64, then swap on individual u32s */
			u.val64 = bswap_64(u.val64);
			u.val32[0] = bswap_32(u.val32[0]);
		}

		sample->cpu = u.val32[0];
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
		array--;
	}

	if (type & PERF_SAMPLE_STREAM_ID) {
		sample->stream_id = *array;
		array--;
	}

	if (type & PERF_SAMPLE_ID) {
		sample->id = *array;
		array--;
	}

	if (type & PERF_SAMPLE_TIME) {
		sample->time = *array;
		array--;
	}

	if (type & PERF_SAMPLE_TID) {
718 719 720 721 722 723 724 725 726 727
		u.val64 = *array;
		if (swapped) {
			/* undo swap of u64, then swap on individual u32s */
			u.val64 = bswap_64(u.val64);
			u.val32[0] = bswap_32(u.val32[0]);
			u.val32[1] = bswap_32(u.val32[1]);
		}

		sample->pid = u.val32[0];
		sample->tid = u.val32[1];
728 729 730 731 732
	}

	return 0;
}

733 734 735 736 737 738 739 740 741 742 743
static bool sample_overlap(const union perf_event *event,
			   const void *offset, u64 size)
{
	const void *base = event;

	if (offset + size > base + event->header.size)
		return true;

	return false;
}

744
int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
745
			     struct perf_sample *data, bool swapped)
746
{
747
	u64 type = evsel->attr.sample_type;
748
	u64 regs_user = evsel->attr.sample_regs_user;
749 750
	const u64 *array;

751 752 753 754
	/*
	 * used for cross-endian analysis. See git commit 65014ab3
	 * for why this goofiness is needed.
	 */
755
	union u64_swap u;
756

757
	memset(data, 0, sizeof(*data));
758 759
	data->cpu = data->pid = data->tid = -1;
	data->stream_id = data->id = data->time = -1ULL;
760
	data->period = 1;
761 762

	if (event->header.type != PERF_RECORD_SAMPLE) {
763
		if (!evsel->attr.sample_id_all)
764
			return 0;
765
		return perf_event__parse_id_sample(event, type, data, swapped);
766 767 768 769
	}

	array = event->sample.array;

770
	if (evsel->sample_size + sizeof(event->header) > event->header.size)
771 772
		return -EFAULT;

773 774 775 776 777 778
	if (type & PERF_SAMPLE_IP) {
		data->ip = event->ip.ip;
		array++;
	}

	if (type & PERF_SAMPLE_TID) {
779 780 781 782 783 784 785 786 787 788
		u.val64 = *array;
		if (swapped) {
			/* undo swap of u64, then swap on individual u32s */
			u.val64 = bswap_64(u.val64);
			u.val32[0] = bswap_32(u.val32[0]);
			u.val32[1] = bswap_32(u.val32[1]);
		}

		data->pid = u.val32[0];
		data->tid = u.val32[1];
789 790 791 792 793 794 795 796
		array++;
	}

	if (type & PERF_SAMPLE_TIME) {
		data->time = *array;
		array++;
	}

797
	data->addr = 0;
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
	if (type & PERF_SAMPLE_ADDR) {
		data->addr = *array;
		array++;
	}

	data->id = -1ULL;
	if (type & PERF_SAMPLE_ID) {
		data->id = *array;
		array++;
	}

	if (type & PERF_SAMPLE_STREAM_ID) {
		data->stream_id = *array;
		array++;
	}

	if (type & PERF_SAMPLE_CPU) {
815 816 817 818 819 820 821 822 823

		u.val64 = *array;
		if (swapped) {
			/* undo swap of u64, then swap on individual u32s */
			u.val64 = bswap_64(u.val64);
			u.val32[0] = bswap_32(u.val32[0]);
		}

		data->cpu = u.val32[0];
824 825 826 827 828 829 830 831 832
		array++;
	}

	if (type & PERF_SAMPLE_PERIOD) {
		data->period = *array;
		array++;
	}

	if (type & PERF_SAMPLE_READ) {
M
Masanari Iida 已提交
833
		fprintf(stderr, "PERF_SAMPLE_READ is unsupported for now\n");
834 835 836 837
		return -1;
	}

	if (type & PERF_SAMPLE_CALLCHAIN) {
838 839 840
		if (sample_overlap(event, array, sizeof(data->callchain->nr)))
			return -EFAULT;

841
		data->callchain = (struct ip_callchain *)array;
842 843 844 845

		if (sample_overlap(event, array, data->callchain->nr))
			return -EFAULT;

846 847 848 849
		array += 1 + data->callchain->nr;
	}

	if (type & PERF_SAMPLE_RAW) {
J
Jiri Olsa 已提交
850 851
		const u64 *pdata;

852 853 854 855 856 857 858 859
		u.val64 = *array;
		if (WARN_ONCE(swapped,
			      "Endianness of raw data not corrected!\n")) {
			/* undo swap of u64, then swap on individual u32s */
			u.val64 = bswap_64(u.val64);
			u.val32[0] = bswap_32(u.val32[0]);
			u.val32[1] = bswap_32(u.val32[1]);
		}
860 861 862 863

		if (sample_overlap(event, array, sizeof(u32)))
			return -EFAULT;

864
		data->raw_size = u.val32[0];
J
Jiri Olsa 已提交
865
		pdata = (void *) array + sizeof(u32);
866

J
Jiri Olsa 已提交
867
		if (sample_overlap(event, pdata, data->raw_size))
868 869
			return -EFAULT;

J
Jiri Olsa 已提交
870
		data->raw_data = (void *) pdata;
871 872

		array = (void *)array + data->raw_size + sizeof(u32);
873 874
	}

875 876 877 878 879 880 881 882 883 884
	if (type & PERF_SAMPLE_BRANCH_STACK) {
		u64 sz;

		data->branch_stack = (struct branch_stack *)array;
		array++; /* nr */

		sz = data->branch_stack->nr * sizeof(struct branch_entry);
		sz /= sizeof(u64);
		array += sz;
	}
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

	if (type & PERF_SAMPLE_REGS_USER) {
		/* First u64 tells us if we have any regs in sample. */
		u64 avail = *array++;

		if (avail) {
			data->user_regs.regs = (u64 *)array;
			array += hweight_long(regs_user);
		}
	}

	if (type & PERF_SAMPLE_STACK_USER) {
		u64 size = *array++;

		data->user_stack.offset = ((char *)(array - 1)
					  - (char *) event);

		if (!size) {
			data->user_stack.size = 0;
		} else {
			data->user_stack.data = (char *)array;
			array += size / sizeof(*array);
			data->user_stack.size = *array;
		}
	}

911 912
	return 0;
}
913 914 915 916 917 918 919 920 921 922 923

int perf_event__synthesize_sample(union perf_event *event, u64 type,
				  const struct perf_sample *sample,
				  bool swapped)
{
	u64 *array;

	/*
	 * used for cross-endian analysis. See git commit 65014ab3
	 * for why this goofiness is needed.
	 */
924
	union u64_swap u;
925 926 927 928 929 930 931 932 933 934 935 936 937

	array = event->sample.array;

	if (type & PERF_SAMPLE_IP) {
		event->ip.ip = sample->ip;
		array++;
	}

	if (type & PERF_SAMPLE_TID) {
		u.val32[0] = sample->pid;
		u.val32[1] = sample->tid;
		if (swapped) {
			/*
938
			 * Inverse of what is done in perf_evsel__parse_sample
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
			 */
			u.val32[0] = bswap_32(u.val32[0]);
			u.val32[1] = bswap_32(u.val32[1]);
			u.val64 = bswap_64(u.val64);
		}

		*array = u.val64;
		array++;
	}

	if (type & PERF_SAMPLE_TIME) {
		*array = sample->time;
		array++;
	}

	if (type & PERF_SAMPLE_ADDR) {
		*array = sample->addr;
		array++;
	}

	if (type & PERF_SAMPLE_ID) {
		*array = sample->id;
		array++;
	}

	if (type & PERF_SAMPLE_STREAM_ID) {
		*array = sample->stream_id;
		array++;
	}

	if (type & PERF_SAMPLE_CPU) {
		u.val32[0] = sample->cpu;
		if (swapped) {
			/*
973
			 * Inverse of what is done in perf_evsel__parse_sample
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
			 */
			u.val32[0] = bswap_32(u.val32[0]);
			u.val64 = bswap_64(u.val64);
		}
		*array = u.val64;
		array++;
	}

	if (type & PERF_SAMPLE_PERIOD) {
		*array = sample->period;
		array++;
	}

	return 0;
}