evlist.c 20.7 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 10
#include "util.h"
#include "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"
17
#include <unistd.h>
18

19 20
#include "parse-events.h"

21 22
#include <sys/mman.h>

23 24 25
#include <linux/bitops.h>
#include <linux/hash.h>

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

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

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

41 42
struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
				     struct thread_map *threads)
43 44 45
{
	struct perf_evlist *evlist = zalloc(sizeof(*evlist));

46
	if (evlist != NULL)
47
		perf_evlist__init(evlist, cpus, threads);
48 49 50 51

	return evlist;
}

52 53 54
void perf_evlist__config_attrs(struct perf_evlist *evlist,
			       struct perf_record_opts *opts)
{
55
	struct perf_evsel *evsel, *first;
56 57 58 59

	if (evlist->cpus->map[0] < 0)
		opts->no_inherit = true;

60 61
	first = list_entry(evlist->entries.next, struct perf_evsel, node);

62
	list_for_each_entry(evsel, &evlist->entries, node) {
63
		perf_evsel__config(evsel, opts, first);
64 65 66 67 68 69

		if (evlist->nr_entries > 1)
			evsel->attr.sample_type |= PERF_SAMPLE_ID;
	}
}

70 71 72 73 74 75 76 77 78 79 80 81
static void perf_evlist__purge(struct perf_evlist *evlist)
{
	struct perf_evsel *pos, *n;

	list_for_each_entry_safe(pos, n, &evlist->entries, node) {
		list_del_init(&pos->node);
		perf_evsel__delete(pos);
	}

	evlist->nr_entries = 0;
}

82
void perf_evlist__exit(struct perf_evlist *evlist)
83
{
84
	free(evlist->mmap);
85
	free(evlist->pollfd);
86 87 88 89 90 91 92 93
	evlist->mmap = NULL;
	evlist->pollfd = NULL;
}

void perf_evlist__delete(struct perf_evlist *evlist)
{
	perf_evlist__purge(evlist);
	perf_evlist__exit(evlist);
94 95 96 97 98 99 100 101 102
	free(evlist);
}

void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
{
	list_add_tail(&entry->node, &evlist->entries);
	++evlist->nr_entries;
}

103 104 105
void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
				   struct list_head *list,
				   int nr_entries)
106 107 108 109 110
{
	list_splice_tail(list, &evlist->entries);
	evlist->nr_entries += nr_entries;
}

111 112 113 114 115 116 117 118 119 120 121 122 123 124
void __perf_evlist__set_leader(struct list_head *list)
{
	struct perf_evsel *evsel, *leader;

	leader = list_entry(list->next, struct perf_evsel, node);
	leader->leader = NULL;

	list_for_each_entry(evsel, list, node) {
		if (evsel != leader)
			evsel->leader = leader;
	}
}

void perf_evlist__set_leader(struct perf_evlist *evlist)
125 126
{
	if (evlist->nr_entries)
127
		__perf_evlist__set_leader(&evlist->entries);
128 129
}

130 131 132 133 134 135
int perf_evlist__add_default(struct perf_evlist *evlist)
{
	struct perf_event_attr attr = {
		.type = PERF_TYPE_HARDWARE,
		.config = PERF_COUNT_HW_CPU_CYCLES,
	};
136 137 138
	struct perf_evsel *evsel;

	event_attr_init(&attr);
139

140
	evsel = perf_evsel__new(&attr, 0);
141
	if (evsel == NULL)
142 143 144 145 146 147
		goto error;

	/* use strdup() because free(evsel) assumes name is allocated */
	evsel->name = strdup("cycles");
	if (!evsel->name)
		goto error_free;
148 149 150

	perf_evlist__add(evlist, evsel);
	return 0;
151 152 153 154
error_free:
	perf_evsel__delete(evsel);
error:
	return -ENOMEM;
155
}
156

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
int perf_evlist__add_attrs(struct perf_evlist *evlist,
			   struct perf_event_attr *attrs, size_t nr_attrs)
{
	struct perf_evsel *evsel, *n;
	LIST_HEAD(head);
	size_t i;

	for (i = 0; i < nr_attrs; i++) {
		evsel = perf_evsel__new(attrs + i, evlist->nr_entries + i);
		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:
	list_for_each_entry_safe(evsel, n, &head, node)
		perf_evsel__delete(evsel);
	return -1;
}

181 182 183 184 185 186 187 188 189 190 191
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);
}

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
static int trace_event__id(const char *evname)
{
	char *filename, *colon;
	int err = -1, fd;

	if (asprintf(&filename, "%s/%s/id", tracing_events_path, evname) < 0)
		return -1;

	colon = strrchr(filename, ':');
	if (colon != NULL)
		*colon = '/';

	fd = open(filename, O_RDONLY);
	if (fd >= 0) {
		char id[16];
		if (read(fd, id, sizeof(id)) > 0)
			err = atoi(id);
		close(fd);
	}

	free(filename);
	return err;
}

int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
				 const char *tracepoints[],
				 size_t nr_tracepoints)
{
	int err;
	size_t i;
	struct perf_event_attr *attrs = zalloc(nr_tracepoints * sizeof(*attrs));

	if (attrs == NULL)
		return -1;

	for (i = 0; i < nr_tracepoints; i++) {
		err = trace_event__id(tracepoints[i]);

		if (err < 0)
			goto out_free_attrs;

		attrs[i].type	       = PERF_TYPE_TRACEPOINT;
		attrs[i].config	       = err;
	        attrs[i].sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
236
					  PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD);
237 238 239 240 241 242 243 244 245
		attrs[i].sample_period = 1;
	}

	err = perf_evlist__add_attrs(evlist, attrs, nr_tracepoints);
out_free_attrs:
	free(attrs);
	return err;
}

246 247
struct perf_evsel *
perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
248 249 250 251 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 284 285 286 287
{
	struct perf_evsel *evsel;

	list_for_each_entry(evsel, &evlist->entries, node) {
		if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
		    (int)evsel->attr.config == id)
			return evsel;
	}

	return NULL;
}

int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
					  const struct perf_evsel_str_handler *assocs,
					  size_t nr_assocs)
{
	struct perf_evsel *evsel;
	int err;
	size_t i;

	for (i = 0; i < nr_assocs; i++) {
		err = trace_event__id(assocs[i].name);
		if (err < 0)
			goto out;

		evsel = perf_evlist__find_tracepoint_by_id(evlist, err);
		if (evsel == NULL)
			continue;

		err = -EEXIST;
		if (evsel->handler.func != NULL)
			goto out;
		evsel->handler.func = assocs[i].handler;
	}

	err = 0;
out:
	return err;
}

288 289 290 291 292 293 294 295
void perf_evlist__disable(struct perf_evlist *evlist)
{
	int cpu, thread;
	struct perf_evsel *pos;

	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
		list_for_each_entry(pos, &evlist->entries, node) {
			for (thread = 0; thread < evlist->threads->nr; thread++)
296 297
				ioctl(FD(pos, cpu, thread),
				      PERF_EVENT_IOC_DISABLE, 0);
298 299 300 301
		}
	}
}

302 303 304 305 306 307 308 309
void perf_evlist__enable(struct perf_evlist *evlist)
{
	int cpu, thread;
	struct perf_evsel *pos;

	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
		list_for_each_entry(pos, &evlist->entries, node) {
			for (thread = 0; thread < evlist->threads->nr; thread++)
310 311
				ioctl(FD(pos, cpu, thread),
				      PERF_EVENT_IOC_ENABLE, 0);
312 313 314 315
		}
	}
}

316
static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
317
{
318
	int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
319 320 321
	evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
	return evlist->pollfd != NULL ? 0 : -ENOMEM;
}
322 323 324 325 326 327 328 329

void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
{
	fcntl(fd, F_SETFL, O_NONBLOCK);
	evlist->pollfd[evlist->nr_fds].fd = fd;
	evlist->pollfd[evlist->nr_fds].events = POLLIN;
	evlist->nr_fds++;
}
330

331 332 333
static void perf_evlist__id_hash(struct perf_evlist *evlist,
				 struct perf_evsel *evsel,
				 int cpu, int thread, u64 id)
334 335 336 337 338 339 340 341 342 343
{
	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]);
}

344 345 346 347 348 349 350 351 352 353
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)
354 355
{
	u64 read_data[4] = { 0, };
356
	int id_idx = 1; /* The first entry is the counter value */
357 358 359 360 361 362 363 364 365 366

	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;

367
	perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
368 369 370
	return 0;
}

371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
{
	struct hlist_head *head;
	struct hlist_node *pos;
	struct perf_sample_id *sid;
	int hash;

	if (evlist->nr_entries == 1)
		return list_entry(evlist->entries.next, struct perf_evsel, node);

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

	hlist_for_each_entry(sid, pos, head, node)
		if (sid->id == id)
			return sid->evsel;
387 388 389 390

	if (!perf_evlist__sample_id_all(evlist))
		return list_entry(evlist->entries.next, struct perf_evsel, node);

391 392
	return NULL;
}
393

394
union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
395 396 397
{
	/* XXX Move this to perf.c, making it generally available */
	unsigned int page_size = sysconf(_SC_PAGE_SIZE);
398
	struct perf_mmap *md = &evlist->mmap[idx];
399 400 401
	unsigned int head = perf_mmap__read_head(md);
	unsigned int old = md->prev;
	unsigned char *data = md->base + page_size;
402
	union perf_event *event = NULL;
403

404
	if (evlist->overwrite) {
405
		/*
406 407 408 409 410 411
		 * 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.
412
		 */
413 414 415 416 417 418 419 420 421
		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;
		}
422 423 424 425 426
	}

	if (old != head) {
		size_t size;

427
		event = (union perf_event *)&data[old & md->mask];
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
		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;
			void *dst = &evlist->event_copy;

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

			event = &evlist->event_copy;
		}

		old += size;
	}

	md->prev = old;
454 455 456 457

	if (!evlist->overwrite)
		perf_mmap__write_tail(md, old);

458 459
	return event;
}
460

461
void perf_evlist__munmap(struct perf_evlist *evlist)
462
{
463
	int i;
464

465 466 467 468
	for (i = 0; i < evlist->nr_mmaps; i++) {
		if (evlist->mmap[i].base != NULL) {
			munmap(evlist->mmap[i].base, evlist->mmap_len);
			evlist->mmap[i].base = NULL;
469 470
		}
	}
471 472 473

	free(evlist->mmap);
	evlist->mmap = NULL;
474 475
}

476
static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
477
{
478 479 480 481
	evlist->nr_mmaps = evlist->cpus->nr;
	if (evlist->cpus->map[0] == -1)
		evlist->nr_mmaps = evlist->threads->nr;
	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
482 483 484
	return evlist->mmap != NULL ? 0 : -ENOMEM;
}

485
static int __perf_evlist__mmap(struct perf_evlist *evlist,
486
			       int idx, int prot, int mask, int fd)
487
{
488 489 490
	evlist->mmap[idx].prev = 0;
	evlist->mmap[idx].mask = mask;
	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
491
				      MAP_SHARED, fd, 0);
492 493
	if (evlist->mmap[idx].base == MAP_FAILED) {
		evlist->mmap[idx].base = NULL;
494
		return -1;
495
	}
496 497 498 499 500

	perf_evlist__add_pollfd(evlist, fd);
	return 0;
}

501 502 503 504 505 506 507 508 509 510 511 512 513 514
static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
{
	struct perf_evsel *evsel;
	int cpu, thread;

	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
		int output = -1;

		for (thread = 0; thread < evlist->threads->nr; thread++) {
			list_for_each_entry(evsel, &evlist->entries, node) {
				int fd = FD(evsel, cpu, thread);

				if (output == -1) {
					output = fd;
515
					if (__perf_evlist__mmap(evlist, cpu,
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
								prot, mask, output) < 0)
						goto out_unmap;
				} else {
					if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
						goto out_unmap;
				}

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

	return 0;

out_unmap:
	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
		if (evlist->mmap[cpu].base != NULL) {
			munmap(evlist->mmap[cpu].base, evlist->mmap_len);
			evlist->mmap[cpu].base = NULL;
		}
	}
	return -1;
}

static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
{
	struct perf_evsel *evsel;
	int thread;

	for (thread = 0; thread < evlist->threads->nr; thread++) {
		int output = -1;

		list_for_each_entry(evsel, &evlist->entries, node) {
			int fd = FD(evsel, 0, thread);

			if (output == -1) {
				output = fd;
555
				if (__perf_evlist__mmap(evlist, thread,
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
							prot, mask, output) < 0)
					goto out_unmap;
			} else {
				if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
					goto out_unmap;
			}

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

	return 0;

out_unmap:
	for (thread = 0; thread < evlist->threads->nr; thread++) {
		if (evlist->mmap[thread].base != NULL) {
			munmap(evlist->mmap[thread].base, evlist->mmap_len);
			evlist->mmap[thread].base = NULL;
		}
	}
	return -1;
}

581 582 583 584 585 586 587 588 589 590 591 592
/** perf_evlist__mmap - Create per cpu maps to receive events
 *
 * @evlist - list of events
 * @pages - map length in pages
 * @overwrite - overwrite older events?
 *
 * If overwrite is false the user needs to signal event consuption using:
 *
 *	struct perf_mmap *m = &evlist->mmap[cpu];
 *	unsigned int head = perf_mmap__read_head(m);
 *
 *	perf_mmap__write_tail(m, head)
593 594
 *
 * Using perf_evlist__read_on_cpu does this automatically.
595
 */
596 597
int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
		      bool overwrite)
598 599
{
	unsigned int page_size = sysconf(_SC_PAGE_SIZE);
600
	struct perf_evsel *evsel;
601 602
	const struct cpu_map *cpus = evlist->cpus;
	const struct thread_map *threads = evlist->threads;
603 604 605 606 607
	int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;

        /* 512 kiB: default amount of unprivileged mlocked memory */
        if (pages == UINT_MAX)
                pages = (512 * 1024) / page_size;
608 609
	else if (!is_power_of_2(pages))
		return -EINVAL;
610 611

	mask = pages * page_size - 1;
612

613
	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
614 615
		return -ENOMEM;

616
	if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
617 618 619 620 621 622 623
		return -ENOMEM;

	evlist->overwrite = overwrite;
	evlist->mmap_len = (pages + 1) * page_size;

	list_for_each_entry(evsel, &evlist->entries, node) {
		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
624
		    evsel->sample_id == NULL &&
625 626 627 628
		    perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
			return -ENOMEM;
	}

629 630
	if (evlist->cpus->map[0] == -1)
		return perf_evlist__mmap_per_thread(evlist, prot, mask);
631

632
	return perf_evlist__mmap_per_cpu(evlist, prot, mask);
633
}
634

635 636
int perf_evlist__create_maps(struct perf_evlist *evlist,
			     struct perf_target *target)
637
{
638 639
	evlist->threads = thread_map__new_str(target->pid, target->tid,
					      target->uid);
640 641 642 643

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

644
	if (perf_target__has_task(target))
645
		evlist->cpus = cpu_map__dummy_new();
N
Namhyung Kim 已提交
646 647
	else if (!perf_target__has_cpu(target) && !target->uses_mmap)
		evlist->cpus = cpu_map__dummy_new();
648 649
	else
		evlist->cpus = cpu_map__new(target->cpu_list);
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667

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

	return 0;

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

void perf_evlist__delete_maps(struct perf_evlist *evlist)
{
	cpu_map__delete(evlist->cpus);
	thread_map__delete(evlist->threads);
	evlist->cpus	= NULL;
	evlist->threads = NULL;
}
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

int perf_evlist__set_filters(struct perf_evlist *evlist)
{
	const struct thread_map *threads = evlist->threads;
	const struct cpu_map *cpus = evlist->cpus;
	struct perf_evsel *evsel;
	char *filter;
	int thread;
	int cpu;
	int err;
	int fd;

	list_for_each_entry(evsel, &evlist->entries, node) {
		filter = evsel->filter;
		if (!filter)
			continue;
		for (cpu = 0; cpu < cpus->nr; cpu++) {
			for (thread = 0; thread < threads->nr; thread++) {
				fd = FD(evsel, cpu, thread);
				err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
				if (err)
					return err;
			}
		}
	}

	return 0;
}
696

697
bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
698
{
699 700 701 702 703 704 705
	struct perf_evsel *pos, *first;

	pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);

	list_for_each_entry_continue(pos, &evlist->entries, node) {
		if (first->attr.sample_type != pos->attr.sample_type)
			return false;
706 707
	}

708
	return true;
709 710
}

711 712 713 714 715 716 717 718
u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
{
	struct perf_evsel *first;

	first = list_entry(evlist->entries.next, struct perf_evsel, node);
	return first->attr.sample_type;
}

719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist)
{
	struct perf_evsel *first;
	struct perf_sample *data;
	u64 sample_type;
	u16 size = 0;

	first = list_entry(evlist->entries.next, struct perf_evsel, node);

	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;
out:
	return size;
}

751
bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
752
{
753 754 755 756 757 758 759
	struct perf_evsel *pos, *first;

	pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);

	list_for_each_entry_continue(pos, &evlist->entries, node) {
		if (first->attr.sample_id_all != pos->attr.sample_id_all)
			return false;
760 761
	}

762 763 764 765 766 767 768 769 770
	return true;
}

bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
{
	struct perf_evsel *first;

	first = list_entry(evlist->entries.next, struct perf_evsel, node);
	return first->attr.sample_id_all;
771
}
772 773 774 775 776 777

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

779
int perf_evlist__open(struct perf_evlist *evlist)
780
{
781
	struct perf_evsel *evsel;
782 783 784
	int err, ncpus, nthreads;

	list_for_each_entry(evsel, &evlist->entries, node) {
785
		err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
786 787 788 789 790 791 792 793 794 795 796 797
		if (err < 0)
			goto out_err;
	}

	return 0;
out_err:
	ncpus = evlist->cpus ? evlist->cpus->nr : 1;
	nthreads = evlist->threads ? evlist->threads->nr : 1;

	list_for_each_entry_reverse(evsel, &evlist->entries, node)
		perf_evsel__close(evsel, ncpus, nthreads);

798
	errno = -err;
799 800
	return err;
}
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857

int perf_evlist__prepare_workload(struct perf_evlist *evlist,
				  struct perf_record_opts *opts,
				  const char *argv[])
{
	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) {
		if (opts->pipe_output)
			dup2(2, 1);

		close(child_ready_pipe[0]);
		close(go_pipe[1]);
		fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);

		/*
		 * Do a dummy execvp to get the PLT entry resolved,
		 * so we avoid the resolver overhead on the real
		 * execvp call.
		 */
		execvp("", (char **)argv);

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

		/*
		 * Wait until the parent tells us to go.
		 */
		if (read(go_pipe[0], &bf, 1) == -1)
			perror("unable to read pipe");

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

		perror(argv[0]);
		kill(getppid(), SIGUSR1);
		exit(-1);
	}

858
	if (perf_target__none(&opts->target))
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
		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;
	}

	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) {
		/*
		 * Remove the cork, let it rip!
		 */
		return close(evlist->workload.cork_fd);
	}

	return 0;
}
895

896
int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
897 898 899
			      struct perf_sample *sample, bool swapped)
{
	struct perf_evsel *e = list_entry(evlist->entries.next, struct perf_evsel, node);
900
	return perf_evsel__parse_sample(e, event, sample, swapped);
901
}