2011-01-30 12:46:46 +00:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
*/
|
|
|
|
|
2011-01-03 18:39:04 +00:00
|
|
|
#include "evsel.h"
|
2011-01-12 19:03:24 +00:00
|
|
|
#include "evlist.h"
|
2011-01-03 18:39:04 +00:00
|
|
|
#include "util.h"
|
2011-01-04 01:09:46 +00:00
|
|
|
#include "cpumap.h"
|
2011-01-18 17:15:24 +00:00
|
|
|
#include "thread_map.h"
|
2011-01-03 18:39:04 +00:00
|
|
|
|
2011-01-03 19:45:52 +00:00
|
|
|
#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
|
|
|
|
|
2011-01-18 23:41:45 +00:00
|
|
|
void perf_evsel__init(struct perf_evsel *evsel,
|
|
|
|
struct perf_event_attr *attr, int idx)
|
|
|
|
{
|
|
|
|
evsel->idx = idx;
|
|
|
|
evsel->attr = *attr;
|
|
|
|
INIT_LIST_HEAD(&evsel->node);
|
|
|
|
}
|
|
|
|
|
2011-01-07 03:11:09 +00:00
|
|
|
struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
|
2011-01-03 18:39:04 +00:00
|
|
|
{
|
|
|
|
struct perf_evsel *evsel = zalloc(sizeof(*evsel));
|
|
|
|
|
2011-01-18 23:41:45 +00:00
|
|
|
if (evsel != NULL)
|
|
|
|
perf_evsel__init(evsel, attr, idx);
|
2011-01-03 18:39:04 +00:00
|
|
|
|
|
|
|
return evsel;
|
|
|
|
}
|
|
|
|
|
|
|
|
int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
|
|
|
|
{
|
|
|
|
evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
|
|
|
|
return evsel->fd != NULL ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-01-13 00:39:13 +00:00
|
|
|
int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
|
|
|
|
{
|
|
|
|
evsel->id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
|
|
|
|
return evsel->id != NULL ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-01-03 19:45:52 +00:00
|
|
|
int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
|
|
|
|
{
|
|
|
|
evsel->counts = zalloc((sizeof(*evsel->counts) +
|
|
|
|
(ncpus * sizeof(struct perf_counts_values))));
|
|
|
|
return evsel->counts != NULL ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-01-03 18:39:04 +00:00
|
|
|
void perf_evsel__free_fd(struct perf_evsel *evsel)
|
|
|
|
{
|
|
|
|
xyarray__delete(evsel->fd);
|
|
|
|
evsel->fd = NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-13 00:39:13 +00:00
|
|
|
void perf_evsel__free_id(struct perf_evsel *evsel)
|
|
|
|
{
|
|
|
|
xyarray__delete(evsel->id);
|
|
|
|
evsel->id = NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-03 19:45:52 +00:00
|
|
|
void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
|
|
|
|
{
|
|
|
|
int cpu, thread;
|
|
|
|
|
|
|
|
for (cpu = 0; cpu < ncpus; cpu++)
|
|
|
|
for (thread = 0; thread < nthreads; ++thread) {
|
|
|
|
close(FD(evsel, cpu, thread));
|
|
|
|
FD(evsel, cpu, thread) = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-18 23:41:45 +00:00
|
|
|
void perf_evsel__exit(struct perf_evsel *evsel)
|
2011-01-03 18:39:04 +00:00
|
|
|
{
|
|
|
|
assert(list_empty(&evsel->node));
|
|
|
|
xyarray__delete(evsel->fd);
|
2011-01-13 00:39:13 +00:00
|
|
|
xyarray__delete(evsel->id);
|
2011-01-18 23:41:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void perf_evsel__delete(struct perf_evsel *evsel)
|
|
|
|
{
|
|
|
|
perf_evsel__exit(evsel);
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
close_cgroup(evsel->cgrp);
|
2011-02-16 13:10:01 +00:00
|
|
|
free(evsel->name);
|
2011-01-03 18:39:04 +00:00
|
|
|
free(evsel);
|
|
|
|
}
|
2011-01-03 19:45:52 +00:00
|
|
|
|
|
|
|
int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
|
|
|
|
int cpu, int thread, bool scale)
|
|
|
|
{
|
|
|
|
struct perf_counts_values count;
|
|
|
|
size_t nv = scale ? 3 : 1;
|
|
|
|
|
|
|
|
if (FD(evsel, cpu, thread) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-01-04 02:13:17 +00:00
|
|
|
if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-01-03 19:45:52 +00:00
|
|
|
if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
if (scale) {
|
|
|
|
if (count.run == 0)
|
|
|
|
count.val = 0;
|
|
|
|
else if (count.run < count.ena)
|
|
|
|
count.val = (u64)((double)count.val * count.ena / count.run + 0.5);
|
|
|
|
} else
|
|
|
|
count.ena = count.run = 0;
|
|
|
|
|
|
|
|
evsel->counts->cpu[cpu] = count;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __perf_evsel__read(struct perf_evsel *evsel,
|
|
|
|
int ncpus, int nthreads, bool scale)
|
|
|
|
{
|
|
|
|
size_t nv = scale ? 3 : 1;
|
|
|
|
int cpu, thread;
|
|
|
|
struct perf_counts_values *aggr = &evsel->counts->aggr, count;
|
|
|
|
|
2011-02-03 19:26:06 +00:00
|
|
|
aggr->val = aggr->ena = aggr->run = 0;
|
2011-01-03 19:45:52 +00:00
|
|
|
|
|
|
|
for (cpu = 0; cpu < ncpus; cpu++) {
|
|
|
|
for (thread = 0; thread < nthreads; thread++) {
|
|
|
|
if (FD(evsel, cpu, thread) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (readn(FD(evsel, cpu, thread),
|
|
|
|
&count, nv * sizeof(u64)) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
aggr->val += count.val;
|
|
|
|
if (scale) {
|
|
|
|
aggr->ena += count.ena;
|
|
|
|
aggr->run += count.run;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
evsel->counts->scaled = 0;
|
|
|
|
if (scale) {
|
|
|
|
if (aggr->run == 0) {
|
|
|
|
evsel->counts->scaled = -1;
|
|
|
|
aggr->val = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aggr->run < aggr->ena) {
|
|
|
|
evsel->counts->scaled = 1;
|
|
|
|
aggr->val = (u64)((double)aggr->val * aggr->ena / aggr->run + 0.5);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
aggr->ena = aggr->run = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-03 19:48:12 +00:00
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
|
2011-01-12 02:08:18 +00:00
|
|
|
struct thread_map *threads, bool group, bool inherit)
|
2011-01-03 19:48:12 +00:00
|
|
|
{
|
2011-01-04 13:55:27 +00:00
|
|
|
int cpu, thread;
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
unsigned long flags = 0;
|
|
|
|
int pid = -1;
|
2011-01-03 19:48:12 +00:00
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
if (evsel->fd == NULL &&
|
|
|
|
perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
|
2011-01-04 02:13:17 +00:00
|
|
|
return -1;
|
|
|
|
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
if (evsel->cgrp) {
|
|
|
|
flags = PERF_FLAG_PID_CGROUP;
|
|
|
|
pid = evsel->cgrp->fd;
|
|
|
|
}
|
|
|
|
|
2011-01-04 01:09:46 +00:00
|
|
|
for (cpu = 0; cpu < cpus->nr; cpu++) {
|
2011-01-12 01:42:19 +00:00
|
|
|
int group_fd = -1;
|
2011-02-21 19:05:50 +00:00
|
|
|
/*
|
|
|
|
* Don't allow mmap() of inherited per-task counters. This
|
|
|
|
* would create a performance issue due to all children writing
|
|
|
|
* to the same buffer.
|
|
|
|
*
|
|
|
|
* FIXME:
|
|
|
|
* Proper fix is not to pass 'inherit' to perf_evsel__open*,
|
|
|
|
* but a 'flags' parameter, with 'group' folded there as well,
|
|
|
|
* then introduce a PERF_O_{MMAP,GROUP,INHERIT} enum, and if
|
|
|
|
* O_MMAP is set, emit a warning if cpu < 0 and O_INHERIT is
|
|
|
|
* set. Lets go for the minimal fix first tho.
|
|
|
|
*/
|
|
|
|
evsel->attr.inherit = (cpus->map[cpu] >= 0) && inherit;
|
2011-01-12 02:08:18 +00:00
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
for (thread = 0; thread < threads->nr; thread++) {
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
|
|
|
|
if (!evsel->cgrp)
|
|
|
|
pid = threads->map[thread];
|
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
pid,
|
2011-01-12 01:42:19 +00:00
|
|
|
cpus->map[cpu],
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 09:20:01 +00:00
|
|
|
group_fd, flags);
|
2011-01-04 13:55:27 +00:00
|
|
|
if (FD(evsel, cpu, thread) < 0)
|
|
|
|
goto out_close;
|
2011-01-12 01:42:19 +00:00
|
|
|
|
|
|
|
if (group && group_fd == -1)
|
|
|
|
group_fd = FD(evsel, cpu, thread);
|
2011-01-04 13:55:27 +00:00
|
|
|
}
|
2011-01-03 19:48:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_close:
|
2011-01-04 13:55:27 +00:00
|
|
|
do {
|
|
|
|
while (--thread >= 0) {
|
|
|
|
close(FD(evsel, cpu, thread));
|
|
|
|
FD(evsel, cpu, thread) = -1;
|
|
|
|
}
|
|
|
|
thread = threads->nr;
|
|
|
|
} while (--cpu >= 0);
|
2011-01-03 19:48:12 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
static struct {
|
|
|
|
struct cpu_map map;
|
|
|
|
int cpus[1];
|
|
|
|
} empty_cpu_map = {
|
|
|
|
.map.nr = 1,
|
|
|
|
.cpus = { -1, },
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
struct thread_map map;
|
|
|
|
int threads[1];
|
|
|
|
} empty_thread_map = {
|
|
|
|
.map.nr = 1,
|
|
|
|
.threads = { -1, },
|
|
|
|
};
|
|
|
|
|
2011-01-12 01:42:19 +00:00
|
|
|
int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
|
2011-01-12 02:08:18 +00:00
|
|
|
struct thread_map *threads, bool group, bool inherit)
|
2011-01-03 19:48:12 +00:00
|
|
|
{
|
2011-01-04 13:55:27 +00:00
|
|
|
if (cpus == NULL) {
|
|
|
|
/* Work around old compiler warnings about strict aliasing */
|
|
|
|
cpus = &empty_cpu_map.map;
|
2011-01-03 19:48:12 +00:00
|
|
|
}
|
|
|
|
|
2011-01-04 13:55:27 +00:00
|
|
|
if (threads == NULL)
|
|
|
|
threads = &empty_thread_map.map;
|
2011-01-03 19:48:12 +00:00
|
|
|
|
2011-01-12 02:08:18 +00:00
|
|
|
return __perf_evsel__open(evsel, cpus, threads, group, inherit);
|
2011-01-03 19:48:12 +00:00
|
|
|
}
|
|
|
|
|
2011-01-12 01:42:19 +00:00
|
|
|
int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
|
2011-01-12 02:08:18 +00:00
|
|
|
struct cpu_map *cpus, bool group, bool inherit)
|
2011-01-03 19:48:12 +00:00
|
|
|
{
|
2011-01-12 02:08:18 +00:00
|
|
|
return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group, inherit);
|
2011-01-04 13:55:27 +00:00
|
|
|
}
|
2011-01-03 19:48:12 +00:00
|
|
|
|
2011-01-12 01:42:19 +00:00
|
|
|
int perf_evsel__open_per_thread(struct perf_evsel *evsel,
|
2011-01-12 02:08:18 +00:00
|
|
|
struct thread_map *threads, bool group, bool inherit)
|
2011-01-04 13:55:27 +00:00
|
|
|
{
|
2011-01-12 02:08:18 +00:00
|
|
|
return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group, inherit);
|
2011-01-03 19:48:12 +00:00
|
|
|
}
|
2011-01-12 19:03:24 +00:00
|
|
|
|
2011-01-29 16:01:45 +00:00
|
|
|
static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
|
|
|
|
struct perf_sample *sample)
|
2011-01-21 15:46:41 +00:00
|
|
|
{
|
|
|
|
const u64 *array = event->sample.array;
|
|
|
|
|
|
|
|
array += ((event->header.size -
|
|
|
|
sizeof(event->header)) / sizeof(u64)) - 1;
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_CPU) {
|
|
|
|
u32 *p = (u32 *)array;
|
|
|
|
sample->cpu = *p;
|
|
|
|
array--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_STREAM_ID) {
|
|
|
|
sample->stream_id = *array;
|
|
|
|
array--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_ID) {
|
|
|
|
sample->id = *array;
|
|
|
|
array--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_TIME) {
|
|
|
|
sample->time = *array;
|
|
|
|
array--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_TID) {
|
|
|
|
u32 *p = (u32 *)array;
|
|
|
|
sample->pid = p[0];
|
|
|
|
sample->tid = p[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-29 16:01:45 +00:00
|
|
|
int perf_event__parse_sample(const union perf_event *event, u64 type,
|
|
|
|
bool sample_id_all, struct perf_sample *data)
|
2011-01-21 15:46:41 +00:00
|
|
|
{
|
|
|
|
const u64 *array;
|
|
|
|
|
|
|
|
data->cpu = data->pid = data->tid = -1;
|
|
|
|
data->stream_id = data->id = data->time = -1ULL;
|
|
|
|
|
|
|
|
if (event->header.type != PERF_RECORD_SAMPLE) {
|
|
|
|
if (!sample_id_all)
|
|
|
|
return 0;
|
2011-01-29 16:01:45 +00:00
|
|
|
return perf_event__parse_id_sample(event, type, data);
|
2011-01-21 15:46:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
array = event->sample.array;
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_IP) {
|
|
|
|
data->ip = event->ip.ip;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_TID) {
|
|
|
|
u32 *p = (u32 *)array;
|
|
|
|
data->pid = p[0];
|
|
|
|
data->tid = p[1];
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_TIME) {
|
|
|
|
data->time = *array;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_ADDR) {
|
|
|
|
data->addr = *array;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->id = -1ULL;
|
|
|
|
if (type & PERF_SAMPLE_ID) {
|
|
|
|
data->id = *array;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_STREAM_ID) {
|
|
|
|
data->stream_id = *array;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_CPU) {
|
|
|
|
u32 *p = (u32 *)array;
|
|
|
|
data->cpu = *p;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_PERIOD) {
|
|
|
|
data->period = *array;
|
|
|
|
array++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_READ) {
|
|
|
|
fprintf(stderr, "PERF_SAMPLE_READ is unsuported for now\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_CALLCHAIN) {
|
|
|
|
data->callchain = (struct ip_callchain *)array;
|
|
|
|
array += 1 + data->callchain->nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type & PERF_SAMPLE_RAW) {
|
|
|
|
u32 *p = (u32 *)array;
|
|
|
|
data->raw_size = *p;
|
|
|
|
p++;
|
|
|
|
data->raw_data = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|