evlist.c 30.9 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * 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)
 */
9
#include "util.h"
10
#include <api/fs/debugfs.h>
11
#include <poll.h>
12 13
#include "cpumap.h"
#include "thread_map.h"
14
#include "target.h"
15 16
#include "evlist.h"
#include "evsel.h"
A
Adrian Hunter 已提交
17
#include "debug.h"
18
#include <unistd.h>
19

20
#include "parse-events.h"
21
#include "parse-options.h"
22

23 24
#include <sys/mman.h>

25 26 27
#include <linux/bitops.h>
#include <linux/hash.h>

28
#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
29
#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
30

31 32
void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
		       struct thread_map *threads)
33 34 35 36 37 38
{
	int i;

	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
		INIT_HLIST_HEAD(&evlist->heads[i]);
	INIT_LIST_HEAD(&evlist->entries);
39
	perf_evlist__set_maps(evlist, cpus, threads);
40
	evlist->workload.pid = -1;
41 42
}

43
struct perf_evlist *perf_evlist__new(void)
44 45 46
{
	struct perf_evlist *evlist = zalloc(sizeof(*evlist));

47
	if (evlist != NULL)
48
		perf_evlist__init(evlist, NULL, NULL);
49 50 51 52

	return evlist;
}

53 54 55 56 57 58 59 60 61 62 63 64
struct perf_evlist *perf_evlist__new_default(void)
{
	struct perf_evlist *evlist = perf_evlist__new();

	if (evlist && perf_evlist__add_default(evlist)) {
		perf_evlist__delete(evlist);
		evlist = NULL;
	}

	return evlist;
}

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
/**
 * perf_evlist__set_id_pos - set the positions of event ids.
 * @evlist: selected event list
 *
 * Events with compatible sample types all have the same id_pos
 * and is_pos.  For convenience, put a copy on evlist.
 */
void perf_evlist__set_id_pos(struct perf_evlist *evlist)
{
	struct perf_evsel *first = perf_evlist__first(evlist);

	evlist->id_pos = first->id_pos;
	evlist->is_pos = first->is_pos;
}

80 81 82 83
static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

84
	evlist__for_each(evlist, evsel)
85 86 87 88 89
		perf_evsel__calc_id_pos(evsel);

	perf_evlist__set_id_pos(evlist);
}

90 91 92 93
static void perf_evlist__purge(struct perf_evlist *evlist)
{
	struct perf_evsel *pos, *n;

94
	evlist__for_each_safe(evlist, n, pos) {
95 96 97 98 99 100 101
		list_del_init(&pos->node);
		perf_evsel__delete(pos);
	}

	evlist->nr_entries = 0;
}

102
void perf_evlist__exit(struct perf_evlist *evlist)
103
{
104 105
	zfree(&evlist->mmap);
	zfree(&evlist->pollfd);
106 107 108 109
}

void perf_evlist__delete(struct perf_evlist *evlist)
{
110
	perf_evlist__munmap(evlist);
111
	perf_evlist__close(evlist);
112 113 114 115
	cpu_map__delete(evlist->cpus);
	thread_map__delete(evlist->threads);
	evlist->cpus = NULL;
	evlist->threads = NULL;
116 117
	perf_evlist__purge(evlist);
	perf_evlist__exit(evlist);
118 119 120 121 122 123
	free(evlist);
}

void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
{
	list_add_tail(&entry->node, &evlist->entries);
124
	entry->idx = evlist->nr_entries;
125
	entry->tracking = !entry->idx;
126

127 128
	if (!evlist->nr_entries++)
		perf_evlist__set_id_pos(evlist);
129 130
}

131 132 133
void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
				   struct list_head *list,
				   int nr_entries)
134
{
135 136
	bool set_id_pos = !evlist->nr_entries;

137 138
	list_splice_tail(list, &evlist->entries);
	evlist->nr_entries += nr_entries;
139 140
	if (set_id_pos)
		perf_evlist__set_id_pos(evlist);
141 142
}

143 144 145 146 147
void __perf_evlist__set_leader(struct list_head *list)
{
	struct perf_evsel *evsel, *leader;

	leader = list_entry(list->next, struct perf_evsel, node);
148 149 150
	evsel = list_entry(list->prev, struct perf_evsel, node);

	leader->nr_members = evsel->idx - leader->idx + 1;
151

152
	__evlist__for_each(list, evsel) {
153
		evsel->leader = leader;
154 155 156 157
	}
}

void perf_evlist__set_leader(struct perf_evlist *evlist)
158
{
159 160
	if (evlist->nr_entries) {
		evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
161
		__perf_evlist__set_leader(&evlist->entries);
162
	}
163 164
}

165 166 167 168 169 170
int perf_evlist__add_default(struct perf_evlist *evlist)
{
	struct perf_event_attr attr = {
		.type = PERF_TYPE_HARDWARE,
		.config = PERF_COUNT_HW_CPU_CYCLES,
	};
171 172 173
	struct perf_evsel *evsel;

	event_attr_init(&attr);
174

175
	evsel = perf_evsel__new(&attr);
176
	if (evsel == NULL)
177 178 179 180 181 182
		goto error;

	/* use strdup() because free(evsel) assumes name is allocated */
	evsel->name = strdup("cycles");
	if (!evsel->name)
		goto error_free;
183 184 185

	perf_evlist__add(evlist, evsel);
	return 0;
186 187 188 189
error_free:
	perf_evsel__delete(evsel);
error:
	return -ENOMEM;
190
}
191

192 193
static int perf_evlist__add_attrs(struct perf_evlist *evlist,
				  struct perf_event_attr *attrs, size_t nr_attrs)
194 195 196 197 198 199
{
	struct perf_evsel *evsel, *n;
	LIST_HEAD(head);
	size_t i;

	for (i = 0; i < nr_attrs; i++) {
200
		evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i);
201 202 203 204 205 206 207 208 209 210
		if (evsel == NULL)
			goto out_delete_partial_list;
		list_add_tail(&evsel->node, &head);
	}

	perf_evlist__splice_list_tail(evlist, &head, nr_attrs);

	return 0;

out_delete_partial_list:
211
	__evlist__for_each_safe(&head, n, evsel)
212 213 214 215
		perf_evsel__delete(evsel);
	return -1;
}

216 217 218 219 220 221 222 223 224 225 226
int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
				     struct perf_event_attr *attrs, size_t nr_attrs)
{
	size_t i;

	for (i = 0; i < nr_attrs; i++)
		event_attr_init(attrs + i);

	return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
}

227 228
struct perf_evsel *
perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
229 230 231
{
	struct perf_evsel *evsel;

232
	evlist__for_each(evlist, evsel) {
233 234 235 236 237 238 239 240
		if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
		    (int)evsel->attr.config == id)
			return evsel;
	}

	return NULL;
}

241 242 243 244 245 246
struct perf_evsel *
perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
				     const char *name)
{
	struct perf_evsel *evsel;

247
	evlist__for_each(evlist, evsel) {
248 249 250 251 252 253 254 255
		if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
		    (strcmp(evsel->name, name) == 0))
			return evsel;
	}

	return NULL;
}

256 257 258
int perf_evlist__add_newtp(struct perf_evlist *evlist,
			   const char *sys, const char *name, void *handler)
{
259
	struct perf_evsel *evsel = perf_evsel__newtp(sys, name);
260 261 262 263

	if (evsel == NULL)
		return -1;

264
	evsel->handler = handler;
265 266 267 268
	perf_evlist__add(evlist, evsel);
	return 0;
}

269 270 271 272 273 274 275 276 277
static int perf_evlist__nr_threads(struct perf_evlist *evlist,
				   struct perf_evsel *evsel)
{
	if (evsel->system_wide)
		return 1;
	else
		return thread_map__nr(evlist->threads);
}

278 279 280 281
void perf_evlist__disable(struct perf_evlist *evlist)
{
	int cpu, thread;
	struct perf_evsel *pos;
282
	int nr_cpus = cpu_map__nr(evlist->cpus);
283
	int nr_threads;
284

285
	for (cpu = 0; cpu < nr_cpus; cpu++) {
286
		evlist__for_each(evlist, pos) {
287
			if (!perf_evsel__is_group_leader(pos) || !pos->fd)
288
				continue;
289
			nr_threads = perf_evlist__nr_threads(evlist, pos);
290
			for (thread = 0; thread < nr_threads; thread++)
291 292
				ioctl(FD(pos, cpu, thread),
				      PERF_EVENT_IOC_DISABLE, 0);
293 294 295 296
		}
	}
}

297 298 299 300
void perf_evlist__enable(struct perf_evlist *evlist)
{
	int cpu, thread;
	struct perf_evsel *pos;
301
	int nr_cpus = cpu_map__nr(evlist->cpus);
302
	int nr_threads;
303

304
	for (cpu = 0; cpu < nr_cpus; cpu++) {
305
		evlist__for_each(evlist, pos) {
306
			if (!perf_evsel__is_group_leader(pos) || !pos->fd)
307
				continue;
308
			nr_threads = perf_evlist__nr_threads(evlist, pos);
309
			for (thread = 0; thread < nr_threads; thread++)
310 311
				ioctl(FD(pos, cpu, thread),
				      PERF_EVENT_IOC_ENABLE, 0);
312 313 314 315
		}
	}
}

316 317 318 319
int perf_evlist__disable_event(struct perf_evlist *evlist,
			       struct perf_evsel *evsel)
{
	int cpu, thread, err;
320 321
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = perf_evlist__nr_threads(evlist, evsel);
322 323 324 325

	if (!evsel->fd)
		return 0;

326 327
	for (cpu = 0; cpu < nr_cpus; cpu++) {
		for (thread = 0; thread < nr_threads; thread++) {
328 329 330 331 332 333 334 335 336 337 338 339 340
			err = ioctl(FD(evsel, cpu, thread),
				    PERF_EVENT_IOC_DISABLE, 0);
			if (err)
				return err;
		}
	}
	return 0;
}

int perf_evlist__enable_event(struct perf_evlist *evlist,
			      struct perf_evsel *evsel)
{
	int cpu, thread, err;
341 342
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = perf_evlist__nr_threads(evlist, evsel);
343 344 345 346

	if (!evsel->fd)
		return -EINVAL;

347 348
	for (cpu = 0; cpu < nr_cpus; cpu++) {
		for (thread = 0; thread < nr_threads; thread++) {
349 350 351 352 353 354 355 356 357
			err = ioctl(FD(evsel, cpu, thread),
				    PERF_EVENT_IOC_ENABLE, 0);
			if (err)
				return err;
		}
	}
	return 0;
}

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 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 int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
					 struct perf_evsel *evsel, int cpu)
{
	int thread, err;
	int nr_threads = perf_evlist__nr_threads(evlist, evsel);

	if (!evsel->fd)
		return -EINVAL;

	for (thread = 0; thread < nr_threads; thread++) {
		err = ioctl(FD(evsel, cpu, thread),
			    PERF_EVENT_IOC_ENABLE, 0);
		if (err)
			return err;
	}
	return 0;
}

static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,
					    struct perf_evsel *evsel,
					    int thread)
{
	int cpu, err;
	int nr_cpus = cpu_map__nr(evlist->cpus);

	if (!evsel->fd)
		return -EINVAL;

	for (cpu = 0; cpu < nr_cpus; cpu++) {
		err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
		if (err)
			return err;
	}
	return 0;
}

int perf_evlist__enable_event_idx(struct perf_evlist *evlist,
				  struct perf_evsel *evsel, int idx)
{
	bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus);

	if (per_cpu_mmaps)
		return perf_evlist__enable_event_cpu(evlist, evsel, idx);
	else
		return perf_evlist__enable_event_thread(evlist, evsel, idx);
}

405
static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
406
{
407 408
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = thread_map__nr(evlist->threads);
409 410 411 412 413 414 415 416 417 418
	int nfds = 0;
	struct perf_evsel *evsel;

	list_for_each_entry(evsel, &evlist->entries, node) {
		if (evsel->system_wide)
			nfds += nr_cpus;
		else
			nfds += nr_cpus * nr_threads;
	}

419 420 421
	evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
	return evlist->pollfd != NULL ? 0 : -ENOMEM;
}
422 423 424 425 426

void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
{
	fcntl(fd, F_SETFL, O_NONBLOCK);
	evlist->pollfd[evlist->nr_fds].fd = fd;
427
	evlist->pollfd[evlist->nr_fds].events = POLLIN | POLLERR | POLLHUP;
428 429
	evlist->nr_fds++;
}
430

431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
{
	int fd, nr_fds = 0;

	if (evlist->nr_fds == 0)
		return 0;

	for (fd = 0; fd < evlist->nr_fds; ++fd) {
		if (evlist->pollfd[fd].revents & revents_and_mask)
			continue;

		if (fd != nr_fds)
			evlist->pollfd[nr_fds] = evlist->pollfd[fd];

		++nr_fds;
	}

	evlist->nr_fds = nr_fds;
	return nr_fds;
}

452 453 454
static void perf_evlist__id_hash(struct perf_evlist *evlist,
				 struct perf_evsel *evsel,
				 int cpu, int thread, u64 id)
455 456 457 458 459 460 461 462 463 464
{
	int hash;
	struct perf_sample_id *sid = SID(evsel, cpu, thread);

	sid->id = id;
	sid->evsel = evsel;
	hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
	hlist_add_head(&sid->node, &evlist->heads[hash]);
}

465 466 467 468 469 470 471 472 473 474
void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
			 int cpu, int thread, u64 id)
{
	perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
	evsel->id[evsel->ids++] = id;
}

static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
				  struct perf_evsel *evsel,
				  int cpu, int thread, int fd)
475 476
{
	u64 read_data[4] = { 0, };
477
	int id_idx = 1; /* The first entry is the counter value */
478 479 480 481 482 483 484 485 486 487 488
	u64 id;
	int ret;

	ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
	if (!ret)
		goto add;

	if (errno != ENOTTY)
		return -1;

	/* Legacy way to get event id.. All hail to old kernels! */
489

490 491 492 493 494 495 496
	/*
	 * This way does not work with group format read, so bail
	 * out in that case.
	 */
	if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
		return -1;

497 498 499 500 501 502 503 504 505
	if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
	    read(fd, &read_data, sizeof(read_data)) == -1)
		return -1;

	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		++id_idx;
	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		++id_idx;

506 507 508 509
	id = read_data[id_idx];

 add:
	perf_evlist__id_add(evlist, evsel, cpu, thread, id);
510 511 512
	return 0;
}

513
struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
514 515 516 517 518 519 520 521
{
	struct hlist_head *head;
	struct perf_sample_id *sid;
	int hash;

	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
	head = &evlist->heads[hash];

522
	hlist_for_each_entry(sid, head, node)
523
		if (sid->id == id)
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
			return sid;

	return NULL;
}

struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
{
	struct perf_sample_id *sid;

	if (evlist->nr_entries == 1)
		return perf_evlist__first(evlist);

	sid = perf_evlist__id2sid(evlist, id);
	if (sid)
		return sid->evsel;
539 540

	if (!perf_evlist__sample_id_all(evlist))
541
		return perf_evlist__first(evlist);
542

543 544
	return NULL;
}
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
static int perf_evlist__event2id(struct perf_evlist *evlist,
				 union perf_event *event, u64 *id)
{
	const u64 *array = event->sample.array;
	ssize_t n;

	n = (event->header.size - sizeof(event->header)) >> 3;

	if (event->header.type == PERF_RECORD_SAMPLE) {
		if (evlist->id_pos >= n)
			return -1;
		*id = array[evlist->id_pos];
	} else {
		if (evlist->is_pos > n)
			return -1;
		n -= evlist->is_pos;
		*id = array[n];
	}
	return 0;
}

static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
						   union perf_event *event)
{
570
	struct perf_evsel *first = perf_evlist__first(evlist);
571 572 573 574 575 576
	struct hlist_head *head;
	struct perf_sample_id *sid;
	int hash;
	u64 id;

	if (evlist->nr_entries == 1)
577 578 579 580 581
		return first;

	if (!first->attr.sample_id_all &&
	    event->header.type != PERF_RECORD_SAMPLE)
		return first;
582 583 584 585 586 587

	if (perf_evlist__event2id(evlist, event, &id))
		return NULL;

	/* Synthesized events have an id of zero */
	if (!id)
588
		return first;
589 590 591 592 593 594 595 596 597 598 599

	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
	head = &evlist->heads[hash];

	hlist_for_each_entry(sid, head, node) {
		if (sid->id == id)
			return sid->evsel;
	}
	return NULL;
}

600
union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
601
{
602
	struct perf_mmap *md = &evlist->mmap[idx];
603 604 605
	unsigned int head = perf_mmap__read_head(md);
	unsigned int old = md->prev;
	unsigned char *data = md->base + page_size;
606
	union perf_event *event = NULL;
607

608
	if (evlist->overwrite) {
609
		/*
610 611 612 613 614 615
		 * If we're further behind than half the buffer, there's a chance
		 * the writer will bite our tail and mess up the samples under us.
		 *
		 * If we somehow ended up ahead of the head, we got messed up.
		 *
		 * In either case, truncate and restart at head.
616
		 */
617 618 619 620 621 622 623 624 625
		int diff = head - old;
		if (diff > md->mask / 2 || diff < 0) {
			fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");

			/*
			 * head points to a known good entry, start there.
			 */
			old = head;
		}
626 627 628 629 630
	}

	if (old != head) {
		size_t size;

631
		event = (union perf_event *)&data[old & md->mask];
632 633 634 635 636 637 638 639 640
		size = event->header.size;

		/*
		 * Event straddles the mmap boundary -- header should always
		 * be inside due to u64 alignment of output.
		 */
		if ((old & md->mask) + size != ((old + size) & md->mask)) {
			unsigned int offset = old;
			unsigned int len = min(sizeof(*event), size), cpy;
641
			void *dst = md->event_copy;
642 643 644 645 646 647 648 649 650

			do {
				cpy = min(md->mask + 1 - (offset & md->mask), len);
				memcpy(dst, &data[offset & md->mask], cpy);
				offset += cpy;
				dst += cpy;
				len -= cpy;
			} while (len);

651
			event = (union perf_event *) md->event_copy;
652 653 654 655 656 657
		}

		old += size;
	}

	md->prev = old;
658

659 660
	return event;
}
661

662 663 664 665 666 667 668 669 670 671
void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
{
	if (!evlist->overwrite) {
		struct perf_mmap *md = &evlist->mmap[idx];
		unsigned int old = md->prev;

		perf_mmap__write_tail(md, old);
	}
}

672 673 674 675 676 677 678 679
static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
{
	if (evlist->mmap[idx].base != NULL) {
		munmap(evlist->mmap[idx].base, evlist->mmap_len);
		evlist->mmap[idx].base = NULL;
	}
}

680
void perf_evlist__munmap(struct perf_evlist *evlist)
681
{
682
	int i;
683

684 685 686
	if (evlist->mmap == NULL)
		return;

687 688
	for (i = 0; i < evlist->nr_mmaps; i++)
		__perf_evlist__munmap(evlist, i);
689

690
	zfree(&evlist->mmap);
691 692
}

693
static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
694
{
695
	evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
696
	if (cpu_map__empty(evlist->cpus))
697
		evlist->nr_mmaps = thread_map__nr(evlist->threads);
698
	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
699 700 701
	return evlist->mmap != NULL ? 0 : -ENOMEM;
}

702 703 704 705 706 707 708
struct mmap_params {
	int prot;
	int mask;
};

static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
			       struct mmap_params *mp, int fd)
709
{
710
	evlist->mmap[idx].prev = 0;
711 712
	evlist->mmap[idx].mask = mp->mask;
	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
713
				      MAP_SHARED, fd, 0);
714
	if (evlist->mmap[idx].base == MAP_FAILED) {
715 716
		pr_debug2("failed to mmap perf event ring buffer, error %d\n",
			  errno);
717
		evlist->mmap[idx].base = NULL;
718
		return -1;
719
	}
720 721 722 723 724

	perf_evlist__add_pollfd(evlist, fd);
	return 0;
}

725
static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
726 727
				       struct mmap_params *mp, int cpu,
				       int thread, int *output)
728 729
{
	struct perf_evsel *evsel;
730

731
	evlist__for_each(evlist, evsel) {
732 733 734 735 736 737
		int fd;

		if (evsel->system_wide && thread)
			continue;

		fd = FD(evsel, cpu, thread);
738 739 740

		if (*output == -1) {
			*output = fd;
741
			if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
742 743 744 745 746 747 748 749 750 751 752 753 754 755
				return -1;
		} else {
			if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
				return -1;
		}

		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
		    perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
			return -1;
	}

	return 0;
}

756 757
static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
				     struct mmap_params *mp)
758
{
759
	int cpu, thread;
760 761
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = thread_map__nr(evlist->threads);
762

A
Adrian Hunter 已提交
763
	pr_debug2("perf event ring buffer mmapped per cpu\n");
764
	for (cpu = 0; cpu < nr_cpus; cpu++) {
765 766
		int output = -1;

767
		for (thread = 0; thread < nr_threads; thread++) {
768 769
			if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
							thread, &output))
770
				goto out_unmap;
771 772 773 774 775 776
		}
	}

	return 0;

out_unmap:
777 778
	for (cpu = 0; cpu < nr_cpus; cpu++)
		__perf_evlist__munmap(evlist, cpu);
779 780 781
	return -1;
}

782 783
static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
					struct mmap_params *mp)
784 785
{
	int thread;
786
	int nr_threads = thread_map__nr(evlist->threads);
787

A
Adrian Hunter 已提交
788
	pr_debug2("perf event ring buffer mmapped per thread\n");
789
	for (thread = 0; thread < nr_threads; thread++) {
790 791
		int output = -1;

792 793
		if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
						&output))
794
			goto out_unmap;
795 796 797 798 799
	}

	return 0;

out_unmap:
800 801
	for (thread = 0; thread < nr_threads; thread++)
		__perf_evlist__munmap(evlist, thread);
802 803 804
	return -1;
}

805 806 807 808 809 810 811 812 813 814 815
static size_t perf_evlist__mmap_size(unsigned long pages)
{
	/* 512 kiB: default amount of unprivileged mlocked memory */
	if (pages == UINT_MAX)
		pages = (512 * 1024) / page_size;
	else if (!is_power_of_2(pages))
		return 0;

	return (pages + 1) * page_size;
}

816 817
static long parse_pages_arg(const char *str, unsigned long min,
			    unsigned long max)
818
{
819
	unsigned long pages, val;
820 821 822 823 824 825 826
	static struct parse_tag tags[] = {
		{ .tag  = 'B', .mult = 1       },
		{ .tag  = 'K', .mult = 1 << 10 },
		{ .tag  = 'M', .mult = 1 << 20 },
		{ .tag  = 'G', .mult = 1 << 30 },
		{ .tag  = 0 },
	};
827

828
	if (str == NULL)
829
		return -EINVAL;
830

831
	val = parse_tag_value(str, tags);
832
	if (val != (unsigned long) -1) {
833 834 835 836 837 838
		/* we got file size value */
		pages = PERF_ALIGN(val, page_size) / page_size;
	} else {
		/* we got pages count value */
		char *eptr;
		pages = strtoul(str, &eptr, 10);
839 840
		if (*eptr != '\0')
			return -EINVAL;
841 842
	}

843
	if (pages == 0 && min == 0) {
844
		/* leave number of pages at 0 */
845
	} else if (!is_power_of_2(pages)) {
846
		/* round pages up to next power of 2 */
847 848 849
		pages = next_pow2_l(pages);
		if (!pages)
			return -EINVAL;
850 851
		pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",
			pages * page_size, pages);
852 853
	}

854 855 856 857 858 859 860 861 862 863 864 865 866
	if (pages > max)
		return -EINVAL;

	return pages;
}

int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
				  int unset __maybe_unused)
{
	unsigned int *mmap_pages = opt->value;
	unsigned long max = UINT_MAX;
	long pages;

A
Adrian Hunter 已提交
867
	if (max > SIZE_MAX / page_size)
868 869 870 871 872
		max = SIZE_MAX / page_size;

	pages = parse_pages_arg(str, 1, max);
	if (pages < 0) {
		pr_err("Invalid argument for --mmap_pages/-m\n");
873 874 875 876 877 878 879
		return -1;
	}

	*mmap_pages = pages;
	return 0;
}

880 881 882 883 884
/**
 * perf_evlist__mmap - Create mmaps to receive events.
 * @evlist: list of events
 * @pages: map length in pages
 * @overwrite: overwrite older events?
885
 *
886 887 888
 * If @overwrite is %false the user needs to signal event consumption using
 * perf_mmap__write_tail().  Using perf_evlist__mmap_read() does this
 * automatically.
889
 *
890
 * Return: %0 on success, negative error code otherwise.
891
 */
892 893
int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
		      bool overwrite)
894
{
895
	struct perf_evsel *evsel;
896 897
	const struct cpu_map *cpus = evlist->cpus;
	const struct thread_map *threads = evlist->threads;
898 899 900
	struct mmap_params mp = {
		.prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
	};
901

902
	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
903 904
		return -ENOMEM;

905
	if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
906 907 908
		return -ENOMEM;

	evlist->overwrite = overwrite;
909
	evlist->mmap_len = perf_evlist__mmap_size(pages);
910
	pr_debug("mmap size %zuB\n", evlist->mmap_len);
911
	mp.mask = evlist->mmap_len - page_size - 1;
912

913
	evlist__for_each(evlist, evsel) {
914
		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
915
		    evsel->sample_id == NULL &&
916
		    perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
917 918 919
			return -ENOMEM;
	}

920
	if (cpu_map__empty(cpus))
921
		return perf_evlist__mmap_per_thread(evlist, &mp);
922

923
	return perf_evlist__mmap_per_cpu(evlist, &mp);
924
}
925

926
int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
927
{
928 929
	evlist->threads = thread_map__new_str(target->pid, target->tid,
					      target->uid);
930 931 932 933

	if (evlist->threads == NULL)
		return -1;

934
	if (target__uses_dummy_map(target))
N
Namhyung Kim 已提交
935
		evlist->cpus = cpu_map__dummy_new();
936 937
	else
		evlist->cpus = cpu_map__new(target->cpu_list);
938 939 940 941 942 943 944 945 946 947 948

	if (evlist->cpus == NULL)
		goto out_delete_threads;

	return 0;

out_delete_threads:
	thread_map__delete(evlist->threads);
	return -1;
}

949
int perf_evlist__apply_filters(struct perf_evlist *evlist)
950 951
{
	struct perf_evsel *evsel;
952 953
	int err = 0;
	const int ncpus = cpu_map__nr(evlist->cpus),
954
		  nthreads = thread_map__nr(evlist->threads);
955

956
	evlist__for_each(evlist, evsel) {
957
		if (evsel->filter == NULL)
958
			continue;
959 960 961 962

		err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
		if (err)
			break;
963 964
	}

965 966 967 968 969 970 971 972
	return err;
}

int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
{
	struct perf_evsel *evsel;
	int err = 0;
	const int ncpus = cpu_map__nr(evlist->cpus),
973
		  nthreads = thread_map__nr(evlist->threads);
974

975
	evlist__for_each(evlist, evsel) {
976 977 978 979 980 981
		err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
		if (err)
			break;
	}

	return err;
982
}
983

984
bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
985
{
986
	struct perf_evsel *pos;
987

988 989 990 991 992 993
	if (evlist->nr_entries == 1)
		return true;

	if (evlist->id_pos < 0 || evlist->is_pos < 0)
		return false;

994
	evlist__for_each(evlist, pos) {
995 996
		if (pos->id_pos != evlist->id_pos ||
		    pos->is_pos != evlist->is_pos)
997
			return false;
998 999
	}

1000
	return true;
1001 1002
}

1003
u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
1004
{
1005 1006 1007 1008 1009
	struct perf_evsel *evsel;

	if (evlist->combined_sample_type)
		return evlist->combined_sample_type;

1010
	evlist__for_each(evlist, evsel)
1011 1012 1013 1014 1015 1016 1017 1018 1019
		evlist->combined_sample_type |= evsel->attr.sample_type;

	return evlist->combined_sample_type;
}

u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
{
	evlist->combined_sample_type = 0;
	return __perf_evlist__combined_sample_type(evlist);
1020 1021
}

1022 1023 1024 1025 1026 1027
bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
{
	struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
	u64 read_format = first->attr.read_format;
	u64 sample_type = first->attr.sample_type;

1028
	evlist__for_each(evlist, pos) {
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
		if (read_format != pos->attr.read_format)
			return false;
	}

	/* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
	if ((sample_type & PERF_SAMPLE_READ) &&
	    !(read_format & PERF_FORMAT_ID)) {
		return false;
	}

	return true;
}

u64 perf_evlist__read_format(struct perf_evlist *evlist)
{
	struct perf_evsel *first = perf_evlist__first(evlist);
	return first->attr.read_format;
}

1048
u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
1049
{
1050
	struct perf_evsel *first = perf_evlist__first(evlist);
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	struct perf_sample *data;
	u64 sample_type;
	u16 size = 0;

	if (!first->attr.sample_id_all)
		goto out;

	sample_type = first->attr.sample_type;

	if (sample_type & PERF_SAMPLE_TID)
		size += sizeof(data->tid) * 2;

       if (sample_type & PERF_SAMPLE_TIME)
		size += sizeof(data->time);

	if (sample_type & PERF_SAMPLE_ID)
		size += sizeof(data->id);

	if (sample_type & PERF_SAMPLE_STREAM_ID)
		size += sizeof(data->stream_id);

	if (sample_type & PERF_SAMPLE_CPU)
		size += sizeof(data->cpu) * 2;
1074 1075 1076

	if (sample_type & PERF_SAMPLE_IDENTIFIER)
		size += sizeof(data->id);
1077 1078 1079 1080
out:
	return size;
}

1081
bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
1082
{
1083
	struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
1084

1085
	evlist__for_each_continue(evlist, pos) {
1086 1087
		if (first->attr.sample_id_all != pos->attr.sample_id_all)
			return false;
1088 1089
	}

1090 1091 1092
	return true;
}

1093
bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
1094
{
1095
	struct perf_evsel *first = perf_evlist__first(evlist);
1096
	return first->attr.sample_id_all;
1097
}
1098 1099 1100 1101 1102 1103

void perf_evlist__set_selected(struct perf_evlist *evlist,
			       struct perf_evsel *evsel)
{
	evlist->selected = evsel;
}
1104

1105 1106 1107 1108 1109
void perf_evlist__close(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;
	int ncpus = cpu_map__nr(evlist->cpus);
	int nthreads = thread_map__nr(evlist->threads);
1110
	int n;
1111

1112 1113 1114 1115
	evlist__for_each_reverse(evlist, evsel) {
		n = evsel->cpus ? evsel->cpus->nr : ncpus;
		perf_evsel__close(evsel, n, nthreads);
	}
1116 1117
}

1118
int perf_evlist__open(struct perf_evlist *evlist)
1119
{
1120
	struct perf_evsel *evsel;
1121
	int err;
1122

1123 1124
	perf_evlist__update_id_pos(evlist);

1125
	evlist__for_each(evlist, evsel) {
1126
		err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
1127 1128 1129 1130 1131 1132
		if (err < 0)
			goto out_err;
	}

	return 0;
out_err:
1133
	perf_evlist__close(evlist);
1134
	errno = -err;
1135 1136
	return err;
}
1137

1138
int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target,
1139
				  const char *argv[], bool pipe_output,
1140
				  void (*exec_error)(int signo, siginfo_t *info, void *ucontext))
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
{
	int child_ready_pipe[2], go_pipe[2];
	char bf;

	if (pipe(child_ready_pipe) < 0) {
		perror("failed to create 'ready' pipe");
		return -1;
	}

	if (pipe(go_pipe) < 0) {
		perror("failed to create 'go' pipe");
		goto out_close_ready_pipe;
	}

	evlist->workload.pid = fork();
	if (evlist->workload.pid < 0) {
		perror("failed to fork");
		goto out_close_pipes;
	}

	if (!evlist->workload.pid) {
1162 1163
		int ret;

1164
		if (pipe_output)
1165 1166
			dup2(2, 1);

1167 1168
		signal(SIGTERM, SIG_DFL);

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
		close(child_ready_pipe[0]);
		close(go_pipe[1]);
		fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);

		/*
		 * Tell the parent we're ready to go
		 */
		close(child_ready_pipe[1]);

		/*
		 * Wait until the parent tells us to go.
		 */
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
		ret = read(go_pipe[0], &bf, 1);
		/*
		 * The parent will ask for the execvp() to be performed by
		 * writing exactly one byte, in workload.cork_fd, usually via
		 * perf_evlist__start_workload().
		 *
		 * For cancelling the workload without actuallin running it,
		 * the parent will just close workload.cork_fd, without writing
		 * anything, i.e. read will return zero and we just exit()
		 * here.
		 */
		if (ret != 1) {
			if (ret == -1)
				perror("unable to read pipe");
			exit(ret);
		}
1197 1198 1199

		execvp(argv[0], (char **)argv);

1200
		if (exec_error) {
1201 1202 1203 1204 1205 1206 1207
			union sigval val;

			val.sival_int = errno;
			if (sigqueue(getppid(), SIGUSR1, val))
				perror(argv[0]);
		} else
			perror(argv[0]);
1208 1209 1210
		exit(-1);
	}

1211 1212 1213 1214 1215 1216 1217 1218
	if (exec_error) {
		struct sigaction act = {
			.sa_flags     = SA_SIGINFO,
			.sa_sigaction = exec_error,
		};
		sigaction(SIGUSR1, &act, NULL);
	}

1219
	if (target__none(target))
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
		evlist->threads->map[0] = evlist->workload.pid;

	close(child_ready_pipe[1]);
	close(go_pipe[0]);
	/*
	 * wait for child to settle
	 */
	if (read(child_ready_pipe[0], &bf, 1) == -1) {
		perror("unable to read pipe");
		goto out_close_pipes;
	}

1232
	fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
	evlist->workload.cork_fd = go_pipe[1];
	close(child_ready_pipe[0]);
	return 0;

out_close_pipes:
	close(go_pipe[0]);
	close(go_pipe[1]);
out_close_ready_pipe:
	close(child_ready_pipe[0]);
	close(child_ready_pipe[1]);
	return -1;
}

int perf_evlist__start_workload(struct perf_evlist *evlist)
{
	if (evlist->workload.cork_fd > 0) {
1249
		char bf = 0;
1250
		int ret;
1251 1252 1253
		/*
		 * Remove the cork, let it rip!
		 */
1254 1255 1256 1257 1258 1259
		ret = write(evlist->workload.cork_fd, &bf, 1);
		if (ret < 0)
			perror("enable to write to pipe");

		close(evlist->workload.cork_fd);
		return ret;
1260 1261 1262 1263
	}

	return 0;
}
1264

1265
int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
1266
			      struct perf_sample *sample)
1267
{
1268 1269 1270 1271
	struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);

	if (!evsel)
		return -EFAULT;
1272
	return perf_evsel__parse_sample(evsel, event, sample);
1273
}
1274 1275 1276 1277 1278 1279

size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
{
	struct perf_evsel *evsel;
	size_t printed = 0;

1280
	evlist__for_each(evlist, evsel) {
1281 1282 1283 1284
		printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
				   perf_evsel__name(evsel));
	}

1285
	return printed + fprintf(fp, "\n");
1286
}
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313

int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,
			     int err, char *buf, size_t size)
{
	char sbuf[128];

	switch (err) {
	case ENOENT:
		scnprintf(buf, size, "%s",
			  "Error:\tUnable to find debugfs\n"
			  "Hint:\tWas your kernel was compiled with debugfs support?\n"
			  "Hint:\tIs the debugfs filesystem mounted?\n"
			  "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
		break;
	case EACCES:
		scnprintf(buf, size,
			  "Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
			  "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
			  debugfs_mountpoint, debugfs_mountpoint);
		break;
	default:
		scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
		break;
	}

	return 0;
}
1314 1315 1316 1317 1318

int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
			       int err, char *buf, size_t size)
{
	int printed, value;
1319
	char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1320 1321 1322 1323 1324 1325 1326 1327

	switch (err) {
	case EACCES:
	case EPERM:
		printed = scnprintf(buf, size,
				    "Error:\t%s.\n"
				    "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);

1328
		value = perf_event_paranoid();
1329 1330 1331 1332 1333 1334 1335 1336

		printed += scnprintf(buf + printed, size - printed, "\nHint:\t");

		if (value >= 2) {
			printed += scnprintf(buf + printed, size - printed,
					     "For your workloads it needs to be <= 1\nHint:\t");
		}
		printed += scnprintf(buf + printed, size - printed,
1337
				     "For system wide tracing it needs to be set to -1.\n");
1338 1339

		printed += scnprintf(buf + printed, size - printed,
1340 1341
				    "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
				    "Hint:\tThe current value is %d.", value);
1342 1343 1344 1345 1346 1347 1348 1349
		break;
	default:
		scnprintf(buf, size, "%s", emsg);
		break;
	}

	return 0;
}
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359

void perf_evlist__to_front(struct perf_evlist *evlist,
			   struct perf_evsel *move_evsel)
{
	struct perf_evsel *evsel, *n;
	LIST_HEAD(move);

	if (move_evsel == perf_evlist__first(evlist))
		return;

1360
	evlist__for_each_safe(evlist, n, evsel) {
1361 1362 1363 1364 1365 1366
		if (evsel->leader == move_evsel->leader)
			list_move_tail(&evsel->node, &move);
	}

	list_splice(&move, &evlist->entries);
}
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382

void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
				     struct perf_evsel *tracking_evsel)
{
	struct perf_evsel *evsel;

	if (tracking_evsel->tracking)
		return;

	evlist__for_each(evlist, evsel) {
		if (evsel != tracking_evsel)
			evsel->tracking = false;
	}

	tracking_evsel->tracking = true;
}