perf: Rework/fix the whole read vs group stuff (3dab77fb) · Commits · 戴 / test

include/linux/perf_counter.h

+36 −11

Original line number	Diff line number	Diff line
		@@ -115,7 +115,7 @@ enum perf_counter_sample_format {
		PERF_SAMPLE_TID = 1U << 1,
		PERF_SAMPLE_TIME = 1U << 2,
		PERF_SAMPLE_ADDR = 1U << 3,
		PERF_SAMPLE_GROUP = 1U << 4,
		PERF_SAMPLE_READ = 1U << 4,
		PERF_SAMPLE_CALLCHAIN = 1U << 5,
		PERF_SAMPLE_ID = 1U << 6,
		PERF_SAMPLE_CPU = 1U << 7,
		@@ -127,16 +127,32 @@ enum perf_counter_sample_format {
		};

		/*
		* Bits that can be set in attr.read_format to request that
		* reads on the counter should return the indicated quantities,
		* in increasing order of bit value, after the counter value.
		* The format of the data returned by read() on a perf counter fd,
		* as specified by attr.read_format:
		*
		* struct read_format {
		* { u64 value;
		* { u64 time_enabled; } && PERF_FORMAT_ENABLED
		* { u64 time_running; } && PERF_FORMAT_RUNNING
		* { u64 id; } && PERF_FORMAT_ID
		* } && !PERF_FORMAT_GROUP
		*
		* { u64 nr;
		* { u64 time_enabled; } && PERF_FORMAT_ENABLED
		* { u64 time_running; } && PERF_FORMAT_RUNNING
		* { u64 value;
		* { u64 id; } && PERF_FORMAT_ID
		* } cntr[nr];
		* } && PERF_FORMAT_GROUP
		* };
		*/
		enum perf_counter_read_format {
		PERF_FORMAT_TOTAL_TIME_ENABLED = 1U << 0,
		PERF_FORMAT_TOTAL_TIME_RUNNING = 1U << 1,
		PERF_FORMAT_ID = 1U << 2,
		PERF_FORMAT_GROUP = 1U << 3,

		PERF_FORMAT_MAX = 1U << 3, /* non-ABI */
		PERF_FORMAT_MAX = 1U << 4, /* non-ABI */
		};

		#define PERF_ATTR_SIZE_VER0 64 /* sizeof first published struct */
		@@ -343,10 +359,8 @@ enum perf_event_type {
		* struct {
		* struct perf_event_header header;
		* u32 pid, tid;
		* u64 value;
		* { u64 time_enabled; } && PERF_FORMAT_ENABLED
		* { u64 time_running; } && PERF_FORMAT_RUNNING
		* { u64 parent_id; } && PERF_FORMAT_ID
		*
		* struct read_format values;
		* };
		*/
		PERF_EVENT_READ = 8,
		@@ -364,11 +378,22 @@ enum perf_event_type {
		* { u32 cpu, res; } && PERF_SAMPLE_CPU
		* { u64 period; } && PERF_SAMPLE_PERIOD
		*
		* { u64 nr;
		* { u64 id, val; } cnt[nr]; } && PERF_SAMPLE_GROUP
		* { struct read_format values; } && PERF_SAMPLE_READ
		*
		* { u64 nr,
		* u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
		*
		* #
		* # The RAW record below is opaque data wrt the ABI
		* #
		* # That is, the ABI doesn't make any promises wrt to
		* # the stability of its content, it may vary depending
		* # on event, hardware, kernel version and phase of
		* # the moon.
		* #
		* # In other words, PERF_SAMPLE_RAW contents are not an ABI.
		* #
		*
		* { u32 size;
		* char data[size];}&& PERF_SAMPLE_RAW
		* };

kernel/perf_counter.c

+202 −72

Original line number	Diff line number	Diff line
		@@ -1692,7 +1692,32 @@ static int perf_release(struct inode inode, struct file file)
		return 0;
		}

		static u64 perf_counter_read_tree(struct perf_counter *counter)
		static int perf_counter_read_size(struct perf_counter *counter)
		{
		int entry = sizeof(u64); /* value */
		int size = 0;
		int nr = 1;

		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		size += sizeof(u64);

		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		size += sizeof(u64);

		if (counter->attr.read_format & PERF_FORMAT_ID)
		entry += sizeof(u64);

		if (counter->attr.read_format & PERF_FORMAT_GROUP) {
		nr += counter->group_leader->nr_siblings;
		size += sizeof(u64);
		}

		size += entry * nr;

		return size;
		}

		static u64 perf_counter_read_value(struct perf_counter *counter)
		{
		struct perf_counter *child;
		u64 total = 0;
		@@ -1704,14 +1729,96 @@ static u64 perf_counter_read_tree(struct perf_counter *counter)
		return total;
		}

		static int perf_counter_read_entry(struct perf_counter *counter,
		u64 read_format, char __user *buf)
		{
		int n = 0, count = 0;
		u64 values[2];

		values[n++] = perf_counter_read_value(counter);
		if (read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(counter);

		count = n * sizeof(u64);

		if (copy_to_user(buf, values, count))
		return -EFAULT;

		return count;
		}

		static int perf_counter_read_group(struct perf_counter *counter,
		u64 read_format, char __user *buf)
		{
		struct perf_counter leader = counter->group_leader, sub;
		int n = 0, size = 0, err = -EFAULT;
		u64 values[3];

		values[n++] = 1 + leader->nr_siblings;
		if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		values[n++] = leader->total_time_enabled +
		atomic64_read(&leader->child_total_time_enabled);
		}
		if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		values[n++] = leader->total_time_running +
		atomic64_read(&leader->child_total_time_running);
		}

		size = n * sizeof(u64);

		if (copy_to_user(buf, values, size))
		return -EFAULT;

		err = perf_counter_read_entry(leader, read_format, buf + size);
		if (err < 0)
		return err;

		size += err;

		list_for_each_entry(sub, &leader->sibling_list, list_entry) {
		err = perf_counter_read_entry(counter, read_format,
		buf + size);
		if (err < 0)
		return err;

		size += err;
		}

		return size;
		}

		static int perf_counter_read_one(struct perf_counter *counter,
		u64 read_format, char __user *buf)
		{
		u64 values[4];
		int n = 0;

		values[n++] = perf_counter_read_value(counter);
		if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		values[n++] = counter->total_time_enabled +
		atomic64_read(&counter->child_total_time_enabled);
		}
		if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		values[n++] = counter->total_time_running +
		atomic64_read(&counter->child_total_time_running);
		}
		if (read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(counter);

		if (copy_to_user(buf, values, n * sizeof(u64)))
		return -EFAULT;

		return n * sizeof(u64);
		}

		/*
		* Read the performance counter - simple non blocking version for now
		*/
		static ssize_t
		perf_read_hw(struct perf_counter counter, char __user buf, size_t count)
		{
		u64 values[4];
		int n;
		u64 read_format = counter->attr.read_format;
		int ret;

		/*
		* Return end-of-file for a read on a counter that is in
		@@ -1721,28 +1828,18 @@ perf_read_hw(struct perf_counter counter, char __user buf, size_t count)
		if (counter->state == PERF_COUNTER_STATE_ERROR)
		return 0;

		if (count < perf_counter_read_size(counter))
		return -ENOSPC;

		WARN_ON_ONCE(counter->ctx->parent_ctx);
		mutex_lock(&counter->child_mutex);
		values[0] = perf_counter_read_tree(counter);
		n = 1;
		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		values[n++] = counter->total_time_enabled +
		atomic64_read(&counter->child_total_time_enabled);
		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		values[n++] = counter->total_time_running +
		atomic64_read(&counter->child_total_time_running);
		if (counter->attr.read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(counter);
		if (read_format & PERF_FORMAT_GROUP)
		ret = perf_counter_read_group(counter, read_format, buf);
		else
		ret = perf_counter_read_one(counter, read_format, buf);
		mutex_unlock(&counter->child_mutex);

		if (count < n * sizeof(u64))
		return -EINVAL;
		count = n * sizeof(u64);

		if (copy_to_user(buf, values, count))
		return -EFAULT;

		return count;
		return ret;
		}

		static ssize_t
		@@ -2631,6 +2728,79 @@ static u32 perf_counter_tid(struct perf_counter counter, struct task_struct p)
		return task_pid_nr_ns(p, counter->ns);
		}

		static void perf_output_read_one(struct perf_output_handle *handle,
		struct perf_counter *counter)
		{
		u64 read_format = counter->attr.read_format;
		u64 values[4];
		int n = 0;

		values[n++] = atomic64_read(&counter->count);
		if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		values[n++] = counter->total_time_enabled +
		atomic64_read(&counter->child_total_time_enabled);
		}
		if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		values[n++] = counter->total_time_running +
		atomic64_read(&counter->child_total_time_running);
		}
		if (read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(counter);

		perf_output_copy(handle, values, n * sizeof(u64));
		}

		/*
		* XXX PERF_FORMAT_GROUP vs inherited counters seems difficult.
		*/
		static void perf_output_read_group(struct perf_output_handle *handle,
		struct perf_counter *counter)
		{
		struct perf_counter leader = counter->group_leader, sub;
		u64 read_format = counter->attr.read_format;
		u64 values[5];
		int n = 0;

		values[n++] = 1 + leader->nr_siblings;

		if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		values[n++] = leader->total_time_enabled;

		if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		values[n++] = leader->total_time_running;

		if (leader != counter)
		leader->pmu->read(leader);

		values[n++] = atomic64_read(&leader->count);
		if (read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(leader);

		perf_output_copy(handle, values, n * sizeof(u64));

		list_for_each_entry(sub, &leader->sibling_list, list_entry) {
		n = 0;

		if (sub != counter)
		sub->pmu->read(sub);

		values[n++] = atomic64_read(&sub->count);
		if (read_format & PERF_FORMAT_ID)
		values[n++] = primary_counter_id(sub);

		perf_output_copy(handle, values, n * sizeof(u64));
		}
		}

		static void perf_output_read(struct perf_output_handle *handle,
		struct perf_counter *counter)
		{
		if (counter->attr.read_format & PERF_FORMAT_GROUP)
		perf_output_read_group(handle, counter);
		else
		perf_output_read_one(handle, counter);
		}

		void perf_counter_output(struct perf_counter *counter, int nmi,
		struct perf_sample_data *data)
		{
		@@ -2642,10 +2812,6 @@ void perf_counter_output(struct perf_counter *counter, int nmi,
		struct {
		u32 pid, tid;
		} tid_entry;
		struct {
		u64 id;
		u64 counter;
		} group_entry;
		struct perf_callchain_entry *callchain = NULL;
		int callchain_size = 0;
		u64 time;
		@@ -2700,10 +2866,8 @@ void perf_counter_output(struct perf_counter *counter, int nmi,
		if (sample_type & PERF_SAMPLE_PERIOD)
		header.size += sizeof(u64);

		if (sample_type & PERF_SAMPLE_GROUP) {
		header.size += sizeof(u64) +
		counter->nr_siblings * sizeof(group_entry);
		}
		if (sample_type & PERF_SAMPLE_READ)
		header.size += perf_counter_read_size(counter);

		if (sample_type & PERF_SAMPLE_CALLCHAIN) {
		callchain = perf_callchain(data->regs);
		@@ -2760,26 +2924,8 @@ void perf_counter_output(struct perf_counter *counter, int nmi,
		if (sample_type & PERF_SAMPLE_PERIOD)
		perf_output_put(&handle, data->period);

		/*
		* XXX PERF_SAMPLE_GROUP vs inherited counters seems difficult.
		*/
		if (sample_type & PERF_SAMPLE_GROUP) {
		struct perf_counter leader, sub;
		u64 nr = counter->nr_siblings;

		perf_output_put(&handle, nr);

		leader = counter->group_leader;
		list_for_each_entry(sub, &leader->sibling_list, list_entry) {
		if (sub != counter)
		sub->pmu->read(sub);

		group_entry.id = primary_counter_id(sub);
		group_entry.counter = atomic64_read(&sub->count);

		perf_output_put(&handle, group_entry);
		}
		}
		if (sample_type & PERF_SAMPLE_READ)
		perf_output_read(&handle, counter);

		if (sample_type & PERF_SAMPLE_CALLCHAIN) {
		if (callchain)
		@@ -2818,8 +2964,6 @@ struct perf_read_event {

		u32 pid;
		u32 tid;
		u64 value;
		u64 format[3];
		};

		static void
		@@ -2831,34 +2975,20 @@ perf_counter_read_event(struct perf_counter *counter,
		.header = {
		.type = PERF_EVENT_READ,
		.misc = 0,
		.size = sizeof(event) - sizeof(event.format),
		.size = sizeof(event) + perf_counter_read_size(counter),
		},
		.pid = perf_counter_pid(counter, task),
		.tid = perf_counter_tid(counter, task),
		.value = atomic64_read(&counter->count),
		};
		int ret, i = 0;

		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		event.header.size += sizeof(u64);
		event.format[i++] = counter->total_time_enabled;
		}

		if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		event.header.size += sizeof(u64);
		event.format[i++] = counter->total_time_running;
		}

		if (counter->attr.read_format & PERF_FORMAT_ID) {
		event.header.size += sizeof(u64);
		event.format[i++] = primary_counter_id(counter);
		}
		int ret;

		ret = perf_output_begin(&handle, counter, event.header.size, 0, 0);
		if (ret)
		return;

		perf_output_copy(&handle, &event, event.header.size);
		perf_output_put(&handle, event);
		perf_output_read(&handle, counter);

		perf_output_end(&handle);
		}

		@@ -3921,9 +4051,9 @@ perf_counter_alloc(struct perf_counter_attr *attr,
		atomic64_set(&hwc->period_left, hwc->sample_period);

		/*
		* we currently do not support PERF_SAMPLE_GROUP on inherited counters
		* we currently do not support PERF_FORMAT_GROUP on inherited counters
		*/
		if (attr->inherit && (attr->sample_type & PERF_SAMPLE_GROUP))
		if (attr->inherit && (attr->read_format & PERF_FORMAT_GROUP))
		goto done;

		switch (attr->type) {

Admin message