Release 4.10 tools/perf/util/evlist.c

Directory: tools/perf/util
/*
 * 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)
 */
#include "util.h"
#include <api/fs/fs.h>
#include <poll.h>
#include "cpumap.h"
#include "thread_map.h"
#include "target.h"
#include "evlist.h"
#include "evsel.h"
#include "debug.h"
#include "asm/bug.h"
#include <unistd.h>

#include "parse-events.h"
#include <subcmd/parse-options.h>

#include <sys/mman.h>

#include <linux/bitops.h>
#include <linux/hash.h>
#include <linux/log2.h>
#include <linux/err.h>

static void perf_mmap__munmap(struct perf_mmap *map);
static void perf_mmap__put(struct perf_mmap *map);


#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))

#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)



void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
		       struct thread_map *threads)
{
	int i;

	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
		INIT_HLIST_HEAD(&evlist->heads[i]);
	INIT_LIST_HEAD(&evlist->entries);
	perf_evlist__set_maps(evlist, cpus, threads);
	fdarray__init(&evlist->pollfd, 64);
	evlist->workload.pid = -1;
	evlist->bkw_mmap_state = BKW_MMAP_NOTREADY;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 83 93.26% 6 85.71%
wang nan wang nan 6 6.74% 1 14.29%
Total 89 100.00% 7 100.00%



struct perf_evlist *perf_evlist__new(void)
{
	struct perf_evlist *evlist = zalloc(sizeof(*evlist));

	if (evlist != NULL)
		perf_evlist__init(evlist, NULL, NULL);

	return evlist;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 38 92.68% 3 75.00%
namhyung kim namhyung kim 3 7.32% 1 25.00%
Total 41 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%



struct perf_evlist *perf_evlist__new_dummy(void)
{
	struct perf_evlist *evlist = perf_evlist__new();

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

	return evlist;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%

/**
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel)
		perf_evsel__calc_id_pos(evsel);

	perf_evlist__set_id_pos(evlist);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 29 90.62% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 3 9.38% 2 66.67%
Total 32 100.00% 3 100.00%



static void perf_evlist__purge(struct perf_evlist *evlist)
{
	struct perf_evsel *pos, *n;

	evlist__for_each_entry_safe(evlist, n, pos) {
		list_del_init(&pos->node);
		pos->evlist = NULL;
		perf_evsel__delete(pos);
	}

	evlist->nr_entries = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 54 100.00% 4 100.00%
Total 54 100.00% 4 100.00%



void perf_evlist__exit(struct perf_evlist *evlist)
{
	zfree(&evlist->mmap);
	zfree(&evlist->backward_mmap);
	fdarray__exit(&evlist->pollfd);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 26 76.47% 6 85.71%
wang nan wang nan 8 23.53% 1 14.29%
Total 34 100.00% 7 100.00%



void perf_evlist__delete(struct perf_evlist *evlist)
{
	if (evlist == NULL)
		return;

	perf_evlist__munmap(evlist);
	perf_evlist__close(evlist);
	cpu_map__put(evlist->cpus);
	thread_map__put(evlist->threads);
	evlist->cpus = NULL;
	evlist->threads = NULL;
	perf_evlist__purge(evlist);
	perf_evlist__exit(evlist);
	free(evlist);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 66 97.06% 7 77.78%
jiri olsa jiri olsa 2 2.94% 2 22.22%
Total 68 100.00% 9 100.00%



static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,
					  struct perf_evsel *evsel)
{
	/*
         * We already have cpus for evsel (via PMU sysfs) so
         * keep it, if there's no target cpu list defined.
         */
	if (!evsel->own_cpus || evlist->has_user_cpus) {
		cpu_map__put(evsel->cpus);
		evsel->cpus = cpu_map__get(evlist->cpus);
	} else if (evsel->cpus != evsel->own_cpus) {
		cpu_map__put(evsel->cpus);
		evsel->cpus = cpu_map__get(evsel->own_cpus);
	}

	thread_map__put(evsel->threads);
	evsel->threads = thread_map__get(evlist->threads);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static void perf_evlist__propagate_maps(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel)
		__perf_evlist__propagate_maps(evlist, evsel);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 28 96.55% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



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

	if (!evlist->nr_entries++)
		perf_evlist__set_id_pos(evlist);

	__perf_evlist__propagate_maps(evlist, entry);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 46 64.79% 3 50.00%
adrian hunter adrian hunter 25 35.21% 3 50.00%
Total 71 100.00% 6 100.00%



void perf_evlist__remove(struct perf_evlist *evlist, struct perf_evsel *evsel)
{
	evsel->evlist = NULL;
	list_del_init(&evsel->node);
	evlist->nr_entries -= 1;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
				   struct list_head *list)
{
	struct perf_evsel *evsel, *temp;

	__evlist__for_each_entry_safe(list, temp, evsel) {
		list_del_init(&evsel->node);
		perf_evlist__add(evlist, evsel);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 25 52.08% 2 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 23 47.92% 2 50.00%
Total 48 100.00% 4 100.00%



void __perf_evlist__set_leader(struct list_head *list)
{
	struct perf_evsel *evsel, *leader;

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

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

	__evlist__for_each_entry(list, evsel) {
		evsel->leader = leader;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 45 60.81% 3 60.00%
namhyung kim namhyung kim 28 37.84% 1 20.00%
jiri olsa jiri olsa 1 1.35% 1 20.00%
Total 74 100.00% 5 100.00%



void perf_evlist__set_leader(struct perf_evlist *evlist)
{
	if (evlist->nr_entries) {
		evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
		__perf_evlist__set_leader(&evlist->entries);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 21 52.50% 1 33.33%
namhyung kim namhyung kim 16 40.00% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 3 7.50% 1 33.33%
Total 40 100.00% 3 100.00%



void perf_event_attr__set_max_precise_ip(struct perf_event_attr *attr)
{
	attr->precise_ip = 3;

	while (attr->precise_ip != 0) {
		int fd = sys_perf_event_open(attr, 0, -1, -1, 0);
		if (fd != -1) {
			close(fd);
			break;
		}
		--attr->precise_ip;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%



int perf_evlist__add_default(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel = perf_evsel__new_cycles();

	if (evsel == NULL)
		return -ENOMEM;

	perf_evlist__add(evlist, evsel);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 37 97.37% 2 66.67%
joerg roedel joerg roedel 1 2.63% 1 33.33%
Total 38 100.00% 3 100.00%



int perf_evlist__add_dummy(struct perf_evlist *evlist)
{
	struct perf_event_attr attr = {
		.type	= PERF_TYPE_SOFTWARE,
		.config = PERF_COUNT_SW_DUMMY,
		.size	= sizeof(attr), /* to capture ABI version */
	};
	struct perf_evsel *evsel = perf_evsel__new(&attr);

	if (evsel == NULL)
		return -ENOMEM;

	perf_evlist__add(evlist, evsel);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 67 100.00% 1 100.00%
Total 67 100.00% 1 100.00%



static 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_idx(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);

	return 0;

out_delete_partial_list:
	__evlist__for_each_entry_safe(&head, n, evsel)
		perf_evsel__delete(evsel);
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 115 100.00% 5 100.00%
Total 115 100.00% 5 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%


struct perf_evsel *

perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
{
	struct perf_evsel *evsel;

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

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 50 90.91% 3 75.00%
david ahern david ahern 5 9.09% 1 25.00%
Total 55 100.00% 4 100.00%


struct perf_evsel *

perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
				     const char *name)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel) {
		if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
		    (strcmp(evsel->name, name) == 0))
			return evsel;
	}

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
david ahern david ahern 53 86.89% 1 25.00%
arnaldo carvalho de melo arnaldo carvalho de melo 8 13.11% 3 75.00%
Total 61 100.00% 4 100.00%



int perf_evlist__add_newtp(struct perf_evlist *evlist,
			   const char *sys, const char *name, void *handler)
{
	struct perf_evsel *evsel = perf_evsel__newtp(sys, name);

	if (IS_ERR(evsel))
		return -1;

	evsel->handler = handler;
	perf_evlist__add(evlist, evsel);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 60 95.24% 2 66.67%
jiri olsa jiri olsa 3 4.76% 1 33.33%
Total 63 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



void perf_evlist__disable(struct perf_evlist *evlist)
{
	struct perf_evsel *pos;

	evlist__for_each_entry(evlist, pos) {
		if (!perf_evsel__is_group_leader(pos) || !pos->fd)
			continue;
		perf_evsel__disable(pos);
	}

	evlist->enabled = false;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 35 72.92% 5 55.56%
jiri olsa jiri olsa 6 12.50% 2 22.22%
adrian hunter adrian hunter 5 10.42% 1 11.11%
namhyung kim namhyung kim 2 4.17% 1 11.11%
Total 48 100.00% 9 100.00%



void perf_evlist__enable(struct perf_evlist *evlist)
{
	struct perf_evsel *pos;

	evlist__for_each_entry(evlist, pos) {
		if (!perf_evsel__is_group_leader(pos) || !pos->fd)
			continue;
		perf_evsel__enable(pos);
	}

	evlist->enabled = true;
}

Contributors
Person Tokens Prop Commits CommitProp
david ahern david ahern 23 47.92% 1 11.11%
arnaldo carvalho de melo arnaldo carvalho de melo 12 25.00% 4 44.44%
jiri olsa jiri olsa 6 12.50% 2 22.22%
adrian hunter adrian hunter 5 10.42% 1 11.11%
namhyung kim namhyung kim 2 4.17% 1 11.11%
Total 48 100.00% 9 100.00%



void perf_evlist__toggle_enable(struct perf_evlist *evlist)
{
	(evlist->enabled ? perf_evlist__disable : perf_evlist__enable)(evlist);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 22 95.65% 1 50.00%
david ahern david ahern 1 4.35% 1 50.00%
Total 23 100.00% 2 100.00%



static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
					 struct perf_evsel *evsel, int cpu)
{
	int thread;
	int nr_threads = perf_evlist__nr_threads(evlist, evsel);

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

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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 84 96.55% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 3 3.45% 1 50.00%
Total 87 100.00% 2 100.00%



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

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

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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 84 96.55% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 3 3.45% 1 50.00%
Total 87 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
{
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = thread_map__nr(evlist->threads);
	int nfds = 0;
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel) {
		if (evsel->system_wide)
			nfds += nr_cpus;
		else
			nfds += nr_cpus * nr_threads;
	}

	if (fdarray__available_entries(&evlist->pollfd) < nfds &&
	    fdarray__grow(&evlist->pollfd, nfds) < 0)
		return -ENOMEM;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 55 57.29% 7 77.78%
adrian hunter adrian hunter 26 27.08% 1 11.11%
namhyung kim namhyung kim 15 15.62% 1 11.11%
Total 96 100.00% 9 100.00%



static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd,
				     struct perf_mmap *map, short revent)
{
	int pos = fdarray__add(&evlist->pollfd, fd, revent | POLLERR | POLLHUP);
	/*
         * Save the idx so that when we filter out fds POLLHUP'ed we can
         * close the associated evlist->mmap[] entry.
         */
	if (pos >= 0) {
		evlist->pollfd.priv[pos].ptr = map;

		fcntl(fd, F_SETFL, O_NONBLOCK);
	}

	return pos;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 65 86.67% 4 66.67%
wang nan wang nan 10 13.33% 2 33.33%
Total 75 100.00% 6 100.00%



int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
{
	return __perf_evlist__add_pollfd(evlist, fd, NULL, POLLIN);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 22 88.00% 4 66.67%
wang nan wang nan 3 12.00% 2 33.33%
Total 25 100.00% 6 100.00%



static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd,
					 void *arg __maybe_unused)
{
	struct perf_mmap *map = fda->priv[fd].ptr;

	if (map)
		perf_mmap__put(map);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 26 61.90% 1 33.33%
wang nan wang nan 16 38.10% 2 66.67%
Total 42 100.00% 3 100.00%



int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
{
	return fdarray__filter(&evlist->pollfd, revents_and_mask,
			       perf_evlist__munmap_filtered, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 26 92.86% 4 80.00%
wang nan wang nan 2 7.14% 1 20.00%
Total 28 100.00% 5 100.00%



int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
{
	return fdarray__poll(&evlist->pollfd, timeout);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 24 100.00% 2 100.00%
Total 24 100.00% 2 100.00%



static void perf_evlist__id_hash(struct perf_evlist *evlist,
				 struct perf_evsel *evsel,
				 int cpu, int thread, u64 id)
{
	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]);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 81 100.00% 3 100.00%
Total 81 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



int perf_evlist__id_add_fd(struct perf_evlist *evlist,
			   struct perf_evsel *evsel,
			   int cpu, int thread, int fd)
{
	u64 read_data[4] = { 0, };
	int id_idx = 1; /* The first entry is the counter value */
	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! */

	/*
         * 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;

	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;

	id = read_data[id_idx];

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

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 114 65.14% 3 60.00%
jiri olsa jiri olsa 61 34.86% 2 40.00%
Total 175 100.00% 5 100.00%



static void perf_evlist__set_sid_idx(struct perf_evlist *evlist,
				     struct perf_evsel *evsel, int idx, int cpu,
				     int thread)
{
	struct perf_sample_id *sid = SID(evsel, cpu, thread);
	sid->idx = idx;
	if (evlist->cpus && cpu >= 0)
		sid->cpu = evlist->cpus->map[cpu];
	else
		sid->cpu = -1;
	if (!evsel->system_wide && evlist->threads && thread >= 0)
		sid->tid = thread_map__pid(evlist->threads, thread);
	else
		sid->tid = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 108 96.43% 1 50.00%
jiri olsa jiri olsa 4 3.57% 1 50.00%
Total 112 100.00% 2 100.00%



struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
{
	struct hlist_head *head;
	struct perf_sample_id *sid;
	int hash;

	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;

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 62 89.86% 1 50.00%
jiri olsa jiri olsa 7 10.14% 1 50.00%
Total 69 100.00% 2 100.00%



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

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

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

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

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 48 66.67% 1 20.00%
namhyung kim namhyung kim 13 18.06% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 8 11.11% 2 40.00%
adrian hunter adrian hunter 3 4.17% 1 20.00%
Total 72 100.00% 5 100.00%



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

	if (!id)
		return NULL;

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

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 119 100.00% 1 100.00%
Total 119 100.00% 1 100.00%



struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
					    union perf_event *event)
{
	struct perf_evsel *first = perf_evlist__first(evlist);
	struct hlist_head *head;
	struct perf_sample_id *sid;
	int hash;
	u64 id;

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

	if (!first->attr.sample_id_all &&
	    event->header.type != PERF_RECORD_SAMPLE)
		return first;

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

	/* Synthesized events have an id of zero */
	if (!id)
		return first;

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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 143 100.00% 2 100.00%
Total 143 100.00% 2 100.00%



static int perf_evlist__set_paused(struct perf_evlist *evlist, bool value)
{
	int i;

	if (!evlist->backward_mmap)
		return 0;

	for (i = 0; i < evlist->nr_mmaps; i++) {
		int fd = evlist->backward_mmap[i].fd;
		int err;

		if (fd < 0)
			continue;
		err = ioctl(fd, PERF_EVENT_IOC_PAUSE_OUTPUT, value ? 1 : 0);
		if (err)
			return err;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 91 100.00% 2 100.00%
Total 91 100.00% 2 100.00%



static int perf_evlist__pause(struct perf_evlist *evlist)
{
	return perf_evlist__set_paused(evlist, true);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 19 100.00% 2 100.00%
Total 19 100.00% 2 100.00%



static int perf_evlist__resume(struct perf_evlist *evlist)
{
	return perf_evlist__set_paused(evlist, false);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 19 100.00% 2 100.00%
Total 19 100.00% 2 100.00%

/* When check_messup is true, 'end' must points to a good entry */

static union perf_event *

perf_mmap__read(struct perf_mmap *md, bool check_messup, u64 start,
		u64 end, u64 *prev)
{
	unsigned char *data = md->base + page_size;
	union perf_event *event = NULL;
	int diff = end - start;

	if (check_messup) {
		/*
                 * 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 'end', we got messed up.
                 *
                 * In either case, truncate and restart at 'end'.
                 */
		if (diff > md->mask / 2 || diff < 0) {
			fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");

			/*
                         * 'end' points to a known good entry, start there.
                         */
			start = end;
			diff = 0;
		}
	}

	if (diff >= (int)sizeof(event->header)) {
		size_t size;

		event = (union perf_event *)&data[start & md->mask];
		size = event->header.size;

		if (size < sizeof(event->header) || diff < (int)size) {
			event = NULL;
			goto broken_event;
		}

		/*
                 * Event straddles the mmap boundary -- header should always
                 * be inside due to u64 alignment of output.
                 */
		if ((start & md->mask) + size != ((start + size) & md->mask)) {
			unsigned int offset = start;
			unsigned int len = min(sizeof(*event), size), cpy;
			void *dst = md->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 = (union perf_event *) md->event_copy;
		}

		start += size;
	}

broken_event:
	if (prev)
		*prev = start;

	return event;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 212 69.28% 3 30.00%
wang nan wang nan 81 26.47% 3 30.00%
jiri olsa jiri olsa 5 1.63% 1 10.00%
david ahern david ahern 4 1.31% 2 20.00%
zhouyi zhou zhouyi zhou 4 1.31% 1 10.00%
Total 306 100.00% 10 100.00%



union perf_event *perf_mmap__read_forward(struct perf_mmap *md, bool check_messup)
{
	u64 head;
	u64 old = md->prev;

	/*
         * Check if event was unmapped due to a POLLHUP/POLLERR.
         */
	if (!atomic_read(&md->refcnt))
		return NULL;

	head = perf_mmap__read_head(md);

	return perf_mmap__read(md, check_messup, old, head, &md->prev);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 64 100.00% 3 100.00%
Total 64 100.00% 3 100.00%


union perf_event *

perf_mmap__read_backward(struct perf_mmap *md)
{
	u64 head, end;
	u64 start = md->prev;

	/*
         * Check if event was unmapped due to a POLLHUP/POLLERR.
         */
	if (!atomic_read(&md->refcnt))
		return NULL;

	head = perf_mmap__read_head(md);
	if (!head)
		return NULL;

	/*
         * 'head' pointer starts from 0. Kernel minus sizeof(record) form
         * it each time when kernel writes to it, so in fact 'head' is
         * negative. 'end' pointer is made manually by adding the size of
         * the ring buffer to 'head' pointer, means the validate data can
         * read is the whole ring buffer. If 'end' is positive, the ring
         * buffer has not fully filled, so we must adjust 'end' to 0.
         *
         * However, since both 'head' and 'end' is unsigned, we can't
         * simply compare 'end' against 0. Here we compare '-head' and
         * the size of the ring buffer, where -head is the number of bytes
         * kernel write to the ring buffer.
         */
	if (-head < (u64)(md->mask + 1))
		end = 0;
	else
		end = head + md->mask + 1;

	return perf_mmap__read(md, false, start, end, &md->prev);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 103 100.00% 2 100.00%
Total 103 100.00% 2 100.00%



union perf_event *perf_evlist__mmap_read_forward(struct perf_evlist *evlist, int idx)
{
	struct perf_mmap *md = &evlist->mmap[idx];

	/*
         * Check messup is required for forward overwritable ring buffer:
         * memory pointed by md->prev can be overwritten in this case.
         * No need for read-write ring buffer: kernel stop outputting when
         * it hit md->prev (perf_mmap__consume()).
         */
	return perf_mmap__read_forward(md, evlist->overwrite);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 39 100.00% 2 100.00%
Total 39 100.00% 2 100.00%



union perf_event *perf_evlist__mmap_read_backward(struct perf_evlist *evlist, int idx)
{
	struct perf_mmap *md = &evlist->mmap[idx];

	/*
         * No need to check messup for backward ring buffer:
         * We can always read arbitrary long data from a backward
         * ring buffer unless we forget to pause it before reading.
         */
	return perf_mmap__read_backward(md);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 35 100.00% 2 100.00%
Total 35 100.00% 2 100.00%



union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
{
	return perf_evlist__mmap_read_forward(evlist, idx);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



void perf_mmap__read_catchup(struct perf_mmap *md)
{
	u64 head;

	if (!atomic_read(&md->refcnt))
		return;

	head = perf_mmap__read_head(md);
	md->prev = head;
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 38 100.00% 2 100.00%
Total 38 100.00% 2 100.00%



void perf_evlist__mmap_read_catchup(struct perf_evlist *evlist, int idx)
{
	perf_mmap__read_catchup(&evlist->mmap[idx]);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static bool perf_mmap__empty(struct perf_mmap *md)
{
	return perf_mmap__read_head(md) == md->prev && !md->auxtrace_mmap.base;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 20 71.43% 1 33.33%
adrian hunter adrian hunter 7 25.00% 1 33.33%
he kuang he kuang 1 3.57% 1 33.33%
Total 28 100.00% 3 100.00%



static void perf_mmap__get(struct perf_mmap *map)
{
	atomic_inc(&map->refcnt);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 14 73.68% 2 50.00%
wang nan wang nan 4 21.05% 1 25.00%
zhouyi zhou zhouyi zhou 1 5.26% 1 25.00%
Total 19 100.00% 4 100.00%



static void perf_mmap__put(struct perf_mmap *md)
{
	BUG_ON(md->base && atomic_read(&md->refcnt) == 0);

	if (atomic_dec_and_test(&md->refcnt))
		perf_mmap__munmap(md);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 21 48.84% 3 50.00%
wang nan wang nan 20 46.51% 2 33.33%
zhouyi zhou zhouyi zhou 2 4.65% 1 16.67%
Total 43 100.00% 6 100.00%



void perf_mmap__consume(struct perf_mmap *md, bool overwrite)
{
	if (!overwrite) {
		u64 old = md->prev;

		perf_mmap__write_tail(md, old);
	}

	if (atomic_read(&md->refcnt) == 1 && perf_mmap__empty(md))
		perf_mmap__put(md);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 27 48.21% 3 50.00%
wang nan wang nan 21 37.50% 1 16.67%
zhouyi zhou zhouyi zhou 7 12.50% 1 16.67%
david ahern david ahern 1 1.79% 1 16.67%
Total 56 100.00% 6 100.00%



void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
{
	perf_mmap__consume(&evlist->mmap[idx], evlist->overwrite);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 22 78.57% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 6 21.43% 2 66.67%
Total 28 100.00% 3 100.00%



int __weak auxtrace_mmap__mmap(struct auxtrace_mmap *mm __maybe_unused,
			       struct auxtrace_mmap_params *mp __maybe_unused,
			       void *userpg __maybe_unused,
			       int fd __maybe_unused)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



void __weak auxtrace_mmap__munmap(struct auxtrace_mmap *mm __maybe_unused)
{
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%



void __weak auxtrace_mmap_params__init(
			struct auxtrace_mmap_params *mp __maybe_unused,
			off_t auxtrace_offset __maybe_unused,
			unsigned int auxtrace_pages __maybe_unused,
			bool auxtrace_overwrite __maybe_unused)
{
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



void __weak auxtrace_mmap_params__set_idx(
			struct auxtrace_mmap_params *mp __maybe_unused,
			struct perf_evlist *evlist __maybe_unused,
			int idx __maybe_unused,
			bool per_cpu __maybe_unused)
{
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static void perf_mmap__munmap(struct perf_mmap *map)
{
	if (map->base != NULL) {
		munmap(map->base, perf_mmap__mmap_len(map));
		map->base = NULL;
		map->fd = -1;
		atomic_set(&map->refcnt, 0);
	}
	auxtrace_mmap__munmap(&map->auxtrace_mmap);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 35 54.69% 3 42.86%
wang nan wang nan 24 37.50% 2 28.57%
adrian hunter adrian hunter 5 7.81% 2 28.57%
Total 64 100.00% 7 100.00%



static void perf_evlist__munmap_nofree(struct perf_evlist *evlist)
{
	int i;

	if (evlist->mmap)
		for (i = 0; i < evlist->nr_mmaps; i++)
			perf_mmap__munmap(&evlist->mmap[i]);

	if (evlist->backward_mmap)
		for (i = 0; i < evlist->nr_mmaps; i++)
			perf_mmap__munmap(&evlist->backward_mmap[i]);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 44 56.41% 3 60.00%
adrian hunter adrian hunter 28 35.90% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 6 7.69% 1 20.00%
Total 78 100.00% 5 100.00%



void perf_evlist__munmap(struct perf_evlist *evlist)
{
	perf_evlist__munmap_nofree(evlist);
	zfree(&evlist->mmap);
	zfree(&evlist->backward_mmap);
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 20 64.52% 2 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 9 29.03% 3 50.00%
adrian hunter adrian hunter 2 6.45% 1 16.67%
Total 31 100.00% 6 100.00%



static struct perf_mmap *perf_evlist__alloc_mmap(struct perf_evlist *evlist)
{
	int i;
	struct perf_mmap *map;

	evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
	if (cpu_map__empty(evlist->cpus))
		evlist->nr_mmaps = thread_map__nr(evlist->threads);
	map = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
	if (!map)
		return NULL;

	for (i = 0; i < evlist->nr_mmaps; i++)
		map[i].fd = -1;
	return map;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 53 51.46% 5 50.00%
wang nan wang nan 46 44.66% 3 30.00%
namhyung kim namhyung kim 3 2.91% 1 10.00%
sukadev bhattiprolu sukadev bhattiprolu 1 0.97% 1 10.00%
Total 103 100.00% 10 100.00%


struct mmap_params {
	
int prot;
	
int mask;
	
struct auxtrace_mmap_params auxtrace_mp;
};



static int perf_mmap__mmap(struct perf_mmap *map,
			   struct mmap_params *mp, int fd)
{
	/*
         * The last one will be done at perf_evlist__mmap_consume(), so that we
         * make sure we don't prevent tools from consuming every last event in
         * the ring buffer.
         *
         * I.e. we can get the POLLHUP meaning that the fd doesn't exist
         * anymore, but the last events for it are still in the ring buffer,
         * waiting to be consumed.
         *
         * Tools can chose to ignore this at their own discretion, but the
         * evlist layer can't just drop it when filtering events in
         * perf_evlist__filter_pollfd().
         */
	atomic_set(&map->refcnt, 2);
	map->prev = 0;
	map->mask = mp->mask;
	map->base = mmap(NULL, perf_mmap__mmap_len(map), mp->prot,
			 MAP_SHARED, fd, 0);
	if (map->base == MAP_FAILED) {
		pr_debug2("failed to mmap perf event ring buffer, error %d\n",
			  errno);
		map->base = NULL;
		return -1;
	}
	map->fd = fd;

	if (auxtrace_mmap__mmap(&map->auxtrace_mmap,
				&mp->auxtrace_mp, map->base, fd))
		return -1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 63 48.84% 3 33.33%
adrian hunter adrian hunter 38 29.46% 3 33.33%
wang nan wang nan 21 16.28% 2 22.22%
nelson elhage nelson elhage 7 5.43% 1 11.11%
Total 129 100.00% 9 100.00%


static bool

perf_evlist__should_poll(struct perf_evlist *evlist __maybe_unused,
			 struct perf_evsel *evsel)
{
	if (evsel->attr.write_backward)
		return false;
	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 28 90.32% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 3 9.68% 1 50.00%
Total 31 100.00% 2 100.00%



static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
				       struct mmap_params *mp, int cpu_idx,
				       int thread, int *_output, int *_output_backward)
{
	struct perf_evsel *evsel;
	int revent;
	int evlist_cpu = cpu_map__cpu(evlist->cpus, cpu_idx);

	evlist__for_each_entry(evlist, evsel) {
		struct perf_mmap *maps = evlist->mmap;
		int *output = _output;
		int fd;
		int cpu;

		if (evsel->attr.write_backward) {
			output = _output_backward;
			maps = evlist->backward_mmap;

			if (!maps) {
				maps = perf_evlist__alloc_mmap(evlist);
				if (!maps)
					return -1;
				evlist->backward_mmap = maps;
				if (evlist->bkw_mmap_state == BKW_MMAP_NOTREADY)
					perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_RUNNING);
			}
		}

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

		cpu = cpu_map__idx(evsel->cpus, evlist_cpu);
		if (cpu == -1)
			continue;

		fd = FD(evsel, cpu, thread);

		if (*output == -1) {
			*output = fd;

			if (perf_mmap__mmap(&maps[idx], mp, *output)  < 0)
				return -1;
		} else {
			if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
				return -1;

			perf_mmap__get(&maps[idx]);
		}

		revent = perf_evlist__should_poll(evlist, evsel) ? POLLIN : 0;

		/*
                 * The system_wide flag causes a selected event to be opened
                 * always without a pid.  Consequently it will never get a
                 * POLLHUP, but it is used for tracking in combination with
                 * other events, so it should not need to be polled anyway.
                 * Therefore don't add it for polling.
                 */
		if (!evsel->system_wide &&
		    __perf_evlist__add_pollfd(evlist, fd, &maps[idx], revent) < 0) {
			perf_mmap__put(&maps[idx]);
			return -1;
		}

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 126 35.59% 9 47.37%
wang nan wang nan 118 33.33% 4 21.05%
adrian hunter adrian hunter 75 21.19% 5 26.32%
mark rutland mark rutland 35 9.89% 1 5.26%
Total 354 100.00% 19 100.00%



static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
				     struct mmap_params *mp)
{
	int cpu, thread;
	int nr_cpus = cpu_map__nr(evlist->cpus);
	int nr_threads = thread_map__nr(evlist->threads);

	pr_debug2("perf event ring buffer mmapped per cpu\n");
	for (cpu = 0; cpu < nr_cpus; cpu++) {
		int output = -1;
		int output_backward = -1;

		auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, cpu,
					      true);

		for (thread = 0; thread < nr_threads; thread++) {
			if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
							thread, &output, &output_backward))
				goto out_unmap;
		}
	}

	return 0;

out_unmap:
	perf_evlist__munmap_nofree(evlist);
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 112 80.00% 4 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 18 12.86% 2 25.00%
wang nan wang nan 10 7.14% 2 25.00%
Total 140 100.00% 8 100.00%



static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
					struct mmap_params *mp)
{
	int thread;
	int nr_threads = thread_map__nr(evlist->threads);

	pr_debug2("perf event ring buffer mmapped per thread\n");
	for (thread = 0; thread < nr_threads; thread++) {
		int output = -1;
		int output_backward = -1;

		auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, thread,
					      false);

		if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
						&output, &output_backward))
			goto out_unmap;
	}

	return 0;

out_unmap:
	perf_evlist__munmap_nofree(evlist);
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 64 56.64% 2 20.00%
adrian hunter adrian hunter 28 24.78% 5 50.00%
namhyung kim namhyung kim 11 9.73% 1 10.00%
wang nan wang nan 10 8.85% 2 20.00%
Total 113 100.00% 10 100.00%



unsigned long perf_event_mlock_kb_in_pages(void)
{
	unsigned long pages;
	int max;

	if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) {
		/*
                 * Pick a once upon a time good value, i.e. things look
                 * strange since we can't read a sysctl value, but lets not
                 * die yet...
                 */
		max = 512;
	} else {
		max -= (page_size / 1024);
	}

	pages = (max * 1024) / page_size;
	if (!is_power_of_2(pages))
		pages = rounddown_pow_of_two(pages);

	return pages;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 59 80.82% 3 75.00%
jiri olsa jiri olsa 14 19.18% 1 25.00%
Total 73 100.00% 4 100.00%



static size_t perf_evlist__mmap_size(unsigned long pages)
{
	if (pages == UINT_MAX)
		pages = perf_event_mlock_kb_in_pages();
	else if (!is_power_of_2(pages))
		return 0;

	return (pages + 1) * page_size;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 22 52.38% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 20 47.62% 1 50.00%
Total 42 100.00% 2 100.00%



static long parse_pages_arg(const char *str, unsigned long min,
			    unsigned long max)
{
	unsigned long pages, val;
	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 },
        };

	if (str == NULL)
		return -EINVAL;

	val = parse_tag_value(str, tags);
	if (val != (unsigned long) -1) {
		/* 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);
		if (*eptr != '\0')
			return -EINVAL;
	}

	if (pages == 0 && min == 0) {
		/* leave number of pages at 0 */
	} else if (!is_power_of_2(pages)) {
		/* round pages up to next power of 2 */
		pages = roundup_pow_of_two(pages);
		if (!pages)
			return -EINVAL;
		pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",
			pages * page_size, pages);
	}

	if (pages > max)
		return -EINVAL;

	return pages;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 148 63.25% 2 25.00%
david ahern david ahern 62 26.50% 3 37.50%
adrian hunter adrian hunter 23 9.83% 2 25.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 0.43% 1 12.50%
Total 234 100.00% 8 100.00%



int __perf_evlist__parse_mmap_pages(unsigned int *mmap_pages, const char *str)
{
	unsigned long max = UINT_MAX;
	long pages;

	if (max > SIZE_MAX / page_size)
		max = SIZE_MAX / page_size;

	pages = parse_pages_arg(str, 1, max);
	if (pages < 0) {
		pr_err("Invalid argument for --mmap_pages/-m\n");
		return -1;
	}

	*mmap_pages = pages;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david ahern david ahern 49 66.22% 2 40.00%
jiri olsa jiri olsa 20 27.03% 1 20.00%
adrian hunter adrian hunter 5 6.76% 2 40.00%
Total 74 100.00% 5 100.00%



int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
				  int unset __maybe_unused)
{
	return __perf_evlist__parse_mmap_pages(opt->value, str);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

/**
 * perf_evlist__mmap_ex - Create mmaps to receive events.
 * @evlist: list of events
 * @pages: map length in pages
 * @overwrite: overwrite older events?
 * @auxtrace_pages - auxtrace map length in pages
 * @auxtrace_overwrite - overwrite older auxtrace data?
 *
 * If @overwrite is %false the user needs to signal event consumption using
 * perf_mmap__write_tail().  Using perf_evlist__mmap_read() does this
 * automatically.
 *
 * Similarly, if @auxtrace_overwrite is %false the user needs to signal data
 * consumption using auxtrace_mmap__write_tail().
 *
 * Return: %0 on success, negative error code otherwise.
 */


int perf_evlist__mmap_ex(struct perf_evlist *evlist, unsigned int pages,
			 bool overwrite, unsigned int auxtrace_pages,
			 bool auxtrace_overwrite)
{
	struct perf_evsel *evsel;
	const struct cpu_map *cpus = evlist->cpus;
	const struct thread_map *threads = evlist->threads;
	struct mmap_params mp = {
		.prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
        };

	if (!evlist->mmap)
		evlist->mmap = perf_evlist__alloc_mmap(evlist);
	if (!evlist->mmap)
		return -ENOMEM;

	if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
		return -ENOMEM;

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

	auxtrace_mmap_params__init(&mp.auxtrace_mp, evlist->mmap_len,
				   auxtrace_pages, auxtrace_overwrite);

	evlist__for_each_entry(evlist, evsel) {
		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
		    evsel->sample_id == NULL &&
		    perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
			return -ENOMEM;
	}

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

	return perf_evlist__mmap_per_cpu(evlist, &mp);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 164 68.62% 6 46.15%
adrian hunter adrian hunter 41 17.15% 3 23.08%
jiri olsa jiri olsa 20 8.37% 2 15.38%
wang nan wang nan 13 5.44% 1 7.69%
sukadev bhattiprolu sukadev bhattiprolu 1 0.42% 1 7.69%
Total 239 100.00% 13 100.00%



int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
		      bool overwrite)
{
	return perf_evlist__mmap_ex(evlist, pages, overwrite, 0, false);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
{
	struct cpu_map *cpus;
	struct thread_map *threads;

	threads = thread_map__new_str(target->pid, target->tid, target->uid);

	if (!threads)
		return -1;

	if (target__uses_dummy_map(target))
		cpus = cpu_map__dummy_new();
	else
		cpus = cpu_map__new(target->cpu_list);

	if (!cpus)
		goto out_delete_threads;

	evlist->has_user_cpus = !!target->cpu_list;

	perf_evlist__set_maps(evlist, cpus, threads);

	return 0;

out_delete_threads:
	thread_map__put(threads);
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 54 47.37% 3 20.00%
adrian hunter adrian hunter 26 22.81% 3 20.00%
namhyung kim namhyung kim 24 21.05% 4 26.67%
jiri olsa jiri olsa 8 7.02% 3 20.00%
dongsheng yang dongsheng yang 1 0.88% 1 6.67%
david ahern david ahern 1 0.88% 1 6.67%
Total 114 100.00% 15 100.00%



void perf_evlist__set_maps(struct perf_evlist *evlist, struct cpu_map *cpus,
			   struct thread_map *threads)
{
	/*
         * Allow for the possibility that one or another of the maps isn't being
         * changed i.e. don't put it.  Note we are assuming the maps that are
         * being applied are brand new and evlist is taking ownership of the
         * original reference count of 1.  If that is not the case it is up to
         * the caller to increase the reference count.
         */
	if (cpus != evlist->cpus) {
		cpu_map__put(evlist->cpus);
		evlist->cpus = cpu_map__get(cpus);
	}

	if (threads != evlist->threads) {
		thread_map__put(evlist->threads);
		evlist->threads = thread_map__get(threads);
	}

	perf_evlist__propagate_maps(evlist);
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 61 78.21% 1 25.00%
adrian hunter adrian hunter 11 14.10% 2 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 6 7.69% 1 25.00%
Total 78 100.00% 4 100.00%



void __perf_evlist__set_sample_bit(struct perf_evlist *evlist,
				   enum perf_event_sample_format bit)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel)
		__perf_evsel__set_sample_bit(evsel, bit);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 32 100.00% 2 100.00%
Total 32 100.00% 2 100.00%



void __perf_evlist__reset_sample_bit(struct perf_evlist *evlist,
				     enum perf_event_sample_format bit)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel)
		__perf_evsel__reset_sample_bit(evsel, bit);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 32 100.00% 2 100.00%
Total 32 100.00% 2 100.00%



int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel)
{
	struct perf_evsel *evsel;
	int err = 0;
	const int ncpus = cpu_map__nr(evlist->cpus),
		  nthreads = thread_map__nr(evlist->threads);

	evlist__for_each_entry(evlist, evsel) {
		if (evsel->filter == NULL)
			continue;

		/*
                 * filters only work for tracepoint event, which doesn't have cpu limit.
                 * So evlist and evsel should always be same.
                 */
		err = perf_evsel__apply_filter(evsel, ncpus, nthreads, evsel->filter);
		if (err) {
			*err_evsel = evsel;
			break;
		}
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 59 62.77% 6 66.67%
frederic weisbecker frederic weisbecker 31 32.98% 1 11.11%
namhyung kim namhyung kim 3 3.19% 1 11.11%
kan liang kan liang 1 1.06% 1 11.11%
Total 94 100.00% 9 100.00%



int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
{
	struct perf_evsel *evsel;
	int err = 0;

	evlist__for_each_entry(evlist, evsel) {
		if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
			continue;

		err = perf_evsel__set_filter(evsel, filter);
		if (err)
			break;
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 32 52.46% 4 66.67%
frederic weisbecker frederic weisbecker 18 29.51% 1 16.67%
wang nan wang nan 11 18.03% 1 16.67%
Total 61 100.00% 6 100.00%



int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids)
{
	char *filter;
	int ret = -1;
	size_t i;

	for (i = 0; i < npids; ++i) {
		if (i == 0) {
			if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)
				return -1;
		} else {
			char *tmp;

			if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)
				goto out_free;

			free(filter);
			filter = tmp;
		}
	}

	ret = perf_evlist__set_filter(evlist, filter);
out_free:
	free(filter);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 131 100.00% 2 100.00%
Total 131 100.00% 2 100.00%



int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid)
{
	return perf_evlist__set_filter_pids(evlist, 1, &pid);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
{
	struct perf_evsel *pos;

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

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

	evlist__for_each_entry(evlist, pos) {
		if (pos->id_pos != evlist->id_pos ||
		    pos->is_pos != evlist->is_pos)
			return false;
	}

	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 39 52.00% 1 16.67%
frederic weisbecker frederic weisbecker 21 28.00% 1 16.67%
arnaldo carvalho de melo arnaldo carvalho de melo 15 20.00% 4 66.67%
Total 75 100.00% 6 100.00%



u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

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

	evlist__for_each_entry(evlist, evsel)
		evlist->combined_sample_type |= evsel->attr.sample_type;

	return evlist->combined_sample_type;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 27 57.45% 1 16.67%
arnaldo carvalho de melo arnaldo carvalho de melo 19 40.43% 4 66.67%
frederic weisbecker frederic weisbecker 1 2.13% 1 16.67%
Total 47 100.00% 6 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 20 90.91% 1 50.00%
frederic weisbecker frederic weisbecker 2 9.09% 1 50.00%
Total 22 100.00% 2 100.00%



u64 perf_evlist__combined_branch_type(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;
	u64 branch_type = 0;

	evlist__for_each_entry(evlist, evsel)
		branch_type |= evsel->attr.branch_sample_type;
	return branch_type;
}

Contributors
Person Tokens Prop Commits CommitProp
andi kleen andi kleen 36 97.30% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 2.70% 1 50.00%
Total 37 100.00% 2 100.00%



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;

	evlist__for_each_entry(evlist, pos) {
		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;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 85 96.59% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 3 3.41% 2 66.67%
Total 88 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
{
	struct perf_evsel *first = perf_evlist__first(evlist);
	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;

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

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 137 90.13% 2 66.67%
adrian hunter adrian hunter 15 9.87% 1 33.33%
Total 152 100.00% 3 100.00%



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

	evlist__for_each_entry_continue(evlist, pos) {
		if (first->attr.sample_id_all != pos->attr.sample_id_all)
			return false;
	}

	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 29 54.72% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 24 45.28% 4 80.00%
Total 53 100.00% 5 100.00%



bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
{
	struct perf_evsel *first = perf_evlist__first(evlist);
	return first->attr.sample_id_all;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 22 81.48% 2 66.67%
frederic weisbecker frederic weisbecker 5 18.52% 1 33.33%
Total 27 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



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

	evlist__for_each_entry_reverse(evlist, evsel) {
		int n = evsel->cpus ? evsel->cpus->nr : ncpus;
		perf_evsel__close(evsel, n, nthreads);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
namhyung kim namhyung kim 46 68.66% 1 20.00%
stephane eranian stephane eranian 15 22.39% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 6 8.96% 3 60.00%
Total 67 100.00% 5 100.00%



static int perf_evlist__create_syswide_maps(struct perf_evlist *evlist)
{
	struct cpu_map	  *cpus;
	struct thread_map *threads;
	int err = -ENOMEM;

	/*
         * Try reading /sys/devices/system/cpu/online to get
         * an all cpus map.
         *
         * FIXME: -ENOMEM is the best we can do here, the cpu_map
         * code needs an overhaul to properly forward the
         * error, and we may not want to do that fallback to a
         * default cpu identity map :-\
         */
	cpus = cpu_map__new(NULL);
	if (!cpus)
		goto out;

	threads = thread_map__new_dummy();
	if (!threads)
		goto out_put;

	perf_evlist__set_maps(evlist, cpus, threads);
out:
	return err;
out_put:
	cpu_map__put(cpus);
	goto out;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 57 71.25% 1 33.33%
adrian hunter adrian hunter 22 27.50% 1 33.33%
jiri olsa jiri olsa 1 1.25% 1 33.33%
Total 80 100.00% 3 100.00%



int perf_evlist__open(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;
	int err;

	/*
         * Default: one fd per CPU, all threads, aka systemwide
         * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL
         */
	if (evlist->threads == NULL && evlist->cpus == NULL) {
		err = perf_evlist__create_syswide_maps(evlist);
		if (err < 0)
			goto out_err;
	}

	perf_evlist__update_id_pos(evlist);

	evlist__for_each_entry(evlist, evsel) {
		err = perf_evsel__open(evsel, evsel->cpus, evsel->threads);
		if (err < 0)
			goto out_err;
	}

	return 0;
out_err:
	perf_evlist__close(evlist);
	errno = -err;
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 93 87.74% 4 50.00%
adrian hunter adrian hunter 7 6.60% 2 25.00%
namhyung kim namhyung kim 6 5.66% 2 25.00%
Total 106 100.00% 8 100.00%



int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target,
				  const char *argv[], bool pipe_output,
				  void (*exec_error)(int signo, siginfo_t *info, void *ucontext))
{
	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) {
		int ret;

		if (pipe_output)
			dup2(2, 1);

		signal(SIGTERM, SIG_DFL);

		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.
                 */
		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 actually 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);
		}

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

		if (exec_error) {
			union sigval val;

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

	if (exec_error) {
		struct sigaction act = {
			.sa_flags     = SA_SIGINFO,
			.sa_sigaction = exec_error,
                };
		sigaction(SIGUSR1, &act, NULL);
	}

	if (target__none(target)) {
		if (evlist->threads == NULL) {
			fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",
				__func__, __LINE__);
			goto out_close_pipes;
		}
		thread_map__set_pid(evlist->threads, 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;
	}

	fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
	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;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 465 93.00% 7 46.67%
namhyung kim namhyung kim 23 4.60% 6 40.00%
david ahern david ahern 7 1.40% 1 6.67%
jiri olsa jiri olsa 5 1.00% 1 6.67%
Total 500 100.00% 15 100.00%



int perf_evlist__start_workload(struct perf_evlist *evlist)
{
	if (evlist->workload.cork_fd > 0) {
		char bf = 0;
		int ret;
		/*
                 * Remove the cork, let it rip!
                 */
		ret = write(evlist->workload.cork_fd, &bf, 1);
		if (ret < 0)
			perror("enable to write to pipe");

		close(evlist->workload.cork_fd);
		return ret;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
namhyung kim namhyung kim 36 49.32% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 35 47.95% 1 33.33%
david ahern david ahern 2 2.74% 1 33.33%
Total 73 100.00% 3 100.00%



int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
			      struct perf_sample *sample)
{
	struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);

	if (!evsel)
		return -EFAULT;
	return perf_evsel__parse_sample(evsel, event, sample);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 39 76.47% 3 75.00%
adrian hunter adrian hunter 12 23.53% 1 25.00%
Total 51 100.00% 4 100.00%



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

	evlist__for_each_entry(evlist, evsel) {
		printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
				   perf_evsel__name(evsel));
	}

	return printed + fprintf(fp, "\n");
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 64 100.00% 3 100.00%
Total 64 100.00% 3 100.00%



int perf_evlist__strerror_open(struct perf_evlist *evlist,
			       int err, char *buf, size_t size)
{
	int printed, value;
	char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));

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

		value = perf_event_paranoid();

		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,
				     "For system wide tracing it needs to be set to -1.\n");

		printed += scnprintf(buf + printed, size - printed,
				    "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
				    "Hint:\tThe current value is %d.", value);
		break;
	case EINVAL: {
		struct perf_evsel *first = perf_evlist__first(evlist);
		int max_freq;

		if (sysctl__read_int("kernel/perf_event_max_sample_rate", &max_freq) < 0)
			goto out_default;

		if (first->attr.sample_freq < (u64)max_freq)
			goto out_default;

		printed = scnprintf(buf, size,
				    "Error:\t%s.\n"
				    "Hint:\tCheck /proc/sys/kernel/perf_event_max_sample_rate.\n"
				    "Hint:\tThe current value is %d and %" PRIu64 " is being requested.",
				    emsg, max_freq, first->attr.sample_freq);
		break;
	}
	default:
out_default:
		scnprintf(buf, size, "%s", emsg);
		break;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 237 97.93% 5 71.43%
adrian hunter adrian hunter 4 1.65% 1 14.29%
masami hiramatsu masami hiramatsu 1 0.41% 1 14.29%
Total 242 100.00% 7 100.00%



int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size)
{
	char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));
	int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0;

	switch (err) {
	case EPERM:
		sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user);
		printed += scnprintf(buf + printed, size - printed,
				     "Error:\t%s.\n"
				     "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"
				     "Hint:\tTried using %zd kB.\n",
				     emsg, pages_max_per_user, pages_attempted);

		if (pages_attempted >= pages_max_per_user) {
			printed += scnprintf(buf + printed, size - printed,
					     "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",
					     pages_max_per_user + pages_attempted);
		}

		printed += scnprintf(buf + printed, size - printed,
				     "Hint:\tTry using a smaller -m/--mmap-pages value.");
		break;
	default:
		scnprintf(buf, size, "%s", emsg);
		break;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 155 100.00% 5 100.00%
Total 155 100.00% 5 100.00%



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;

	evlist__for_each_entry_safe(evlist, n, evsel) {
		if (evsel->leader == move_evsel->leader)
			list_move_tail(&evsel->node, &move);
	}

	list_splice(&move, &evlist->entries);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 77 96.25% 1 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 3 3.75% 2 66.67%
Total 80 100.00% 3 100.00%



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_entry(evlist, evsel) {
		if (evsel != tracking_evsel)
			evsel->tracking = false;
	}

	tracking_evsel->tracking = true;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hunter adrian hunter 52 98.11% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 1.89% 1 50.00%
Total 53 100.00% 2 100.00%


struct perf_evsel *

perf_evlist__find_evsel_by_str(struct perf_evlist *evlist,
			       const char *str)
{
	struct perf_evsel *evsel;

	evlist__for_each_entry(evlist, evsel) {
		if (!evsel->name)
			continue;
		if (strcmp(str, evsel->name) == 0)
			return evsel;
	}

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 56 98.25% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 1 1.75% 1 50.00%
Total 57 100.00% 2 100.00%



void perf_evlist__toggle_bkw_mmap(struct perf_evlist *evlist,
				  enum bkw_mmap_state state)
{
	enum bkw_mmap_state old_state = evlist->bkw_mmap_state;
	enum action {
		NONE,
		PAUSE,
		RESUME,
        } action = NONE;

	if (!evlist->backward_mmap)
		return;

	switch (old_state) {
	case BKW_MMAP_NOTREADY: {
		if (state != BKW_MMAP_RUNNING)
			goto state_err;;
		break;
	}
	case BKW_MMAP_RUNNING: {
		if (state != BKW_MMAP_DATA_PENDING)
			goto state_err;
		action = PAUSE;
		break;
	}
	case BKW_MMAP_DATA_PENDING: {
		if (state != BKW_MMAP_EMPTY)
			goto state_err;
		break;
	}
	case BKW_MMAP_EMPTY: {
		if (state != BKW_MMAP_RUNNING)
			goto state_err;
		action = RESUME;
		break;
	}
	default:
		WARN_ONCE(1, "Shouldn't get there\n");
	}

	evlist->bkw_mmap_state = state;

	switch (action) {
	case PAUSE:
		perf_evlist__pause(evlist);
		break;
	case RESUME:
		perf_evlist__resume(evlist);
		break;
	case NONE:
	default:
		break;
	}

state_err:
	return;
}
Contributors
Person Tokens Prop Commits CommitProp
wang nan wang nan 164 100.00% 1 100.00%
Total 164 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 4240 49.33% 88 43.56%
adrian hunter adrian hunter 1836 21.36% 35 17.33%
wang nan wang nan 1235 14.37% 20 9.90%
jiri olsa jiri olsa 620 7.21% 18 8.91%
namhyung kim namhyung kim 234 2.72% 17 8.42%
david ahern david ahern 208 2.42% 10 4.95%
frederic weisbecker frederic weisbecker 107 1.24% 2 0.99%
andi kleen andi kleen 36 0.42% 1 0.50%
mark rutland mark rutland 35 0.41% 1 0.50%
stephane eranian stephane eranian 15 0.17% 1 0.50%
zhouyi zhou zhouyi zhou 14 0.16% 1 0.50%
nelson elhage nelson elhage 7 0.08% 1 0.50%
sukadev bhattiprolu sukadev bhattiprolu 2 0.02% 1 0.50%
josh poimboeuf josh poimboeuf 1 0.01% 1 0.50%
kan liang kan liang 1 0.01% 1 0.50%
masami hiramatsu masami hiramatsu 1 0.01% 1 0.50%
joerg roedel joerg roedel 1 0.01% 1 0.50%
he kuang he kuang 1 0.01% 1 0.50%
dongsheng yang dongsheng yang 1 0.01% 1 0.50%
Total 8595 100.00% 202 100.00%
Directory: tools/perf/util

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
arnaldo carvalho de melo	arnaldo carvalho de melo	83	93.26%	6	85.71%
wang nan	wang nan	6	6.74%	1	14.29%
	Total	89	100.00%	7	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 tools/perf/util/evlist.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
