*/
#define __SANE_USERSPACE_TYPES__
-#include <byteswap.h>
+#include "evsel.h"
+
#include <errno.h>
#include <inttypes.h>
+#include <stdlib.h>
+
+#include <dirent.h>
#include <linux/bitops.h>
-#include <api/fs/fs.h>
-#include <api/fs/tracing_path.h>
-#include <linux/hw_breakpoint.h>
-#include <linux/perf_event.h>
#include <linux/compiler.h>
+#include <linux/ctype.h>
#include <linux/err.h>
+#include <linux/hw_breakpoint.h>
+#include <linux/perf_event.h>
#include <linux/zalloc.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>
-#include <dirent.h>
-#include <stdlib.h>
+
+#include <api/fs/fs.h>
+#include <api/fs/tracing_path.h>
+#include <byteswap.h>
+#include <internal/lib.h>
+#include <internal/threadmap.h>
+#include <internal/xyarray.h>
+#include <perf/cpumap.h>
#include <perf/evsel.h>
+
+#include "../perf-sys.h"
#include "asm/bug.h"
+#include "bpf-filter.h"
#include "bpf_counter.h"
#include "callchain.h"
#include "cgroup.h"
#include "counts.h"
+#include "debug.h"
+#include "drm_pmu.h"
#include "dwarf-regs.h"
+#include "env.h"
#include "event.h"
-#include "evsel.h"
-#include "time-utils.h"
-#include "util/env.h"
-#include "util/evsel_config.h"
-#include "util/evsel_fprintf.h"
#include "evlist.h"
-#include <perf/cpumap.h>
-#include "thread_map.h"
-#include "target.h"
+#include "evsel_config.h"
+#include "evsel_fprintf.h"
+#include "hashmap.h"
+#include "hist.h"
+#include "hwmon_pmu.h"
+#include "intel-tpebs.h"
+#include "memswap.h"
+#include "off_cpu.h"
+#include "parse-branch-options.h"
#include "perf_regs.h"
+#include "pmu.h"
+#include "pmus.h"
#include "record.h"
-#include "debug.h"
-#include "trace-event.h"
+#include "rlimit.h"
#include "session.h"
#include "stat.h"
#include "string2.h"
-#include "memswap.h"
-#include "util.h"
-#include "util/hashmap.h"
-#include "off_cpu.h"
-#include "pmu.h"
-#include "pmus.h"
-#include "drm_pmu.h"
-#include "hwmon_pmu.h"
+#include "target.h"
+#include "thread_map.h"
+#include "time-utils.h"
#include "tool_pmu.h"
#include "tp_pmu.h"
-#include "rlimit.h"
-#include "../perf-sys.h"
-#include "util/parse-branch-options.h"
-#include "util/bpf-filter.h"
-#include "util/hist.h"
-#include <internal/xyarray.h>
-#include <internal/lib.h>
-#include <internal/threadmap.h>
-#include "util/intel-tpebs.h"
-
-#include <linux/ctype.h>
+#include "trace-event.h"
+#include "util.h"
#ifdef HAVE_LIBTRACEEVENT
#include <event-parse.h>
/* Caller has to clear disabled after going through all CPUs. */
int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx)
{
- return perf_evsel__enable_cpu(&evsel->core, cpu_map_idx);
+ int err;
+
+ if (evsel__is_tool(evsel))
+ err = evsel__tool_pmu_enable_cpu(evsel, cpu_map_idx);
+ else
+ err = perf_evsel__enable_cpu(&evsel->core, cpu_map_idx);
+
+ if (!err && evsel__is_group_leader(evsel)) {
+ struct evsel *member;
+
+ for_each_group_member(member, evsel) {
+ if (evsel__is_non_perf_event_open_pmu(evsel) ||
+ evsel__is_non_perf_event_open_pmu(member)) {
+ /*
+ * In a mixed PMU group, userspace PMUs are not
+ * grouped in the kernel (opened with group_fd = -1)
+ * and are skipped by the kernel when enabling the
+ * group leader. We must manually enable them in
+ * userspace.
+ */
+ int mem_err = evsel__enable_cpu(member, cpu_map_idx);
+
+ if (mem_err)
+ return mem_err;
+ }
+ }
+ }
+ return err;
}
int evsel__enable(struct evsel *evsel)
{
- int err = perf_evsel__enable(&evsel->core);
+ int err;
+
+ if (evsel__is_tool(evsel))
+ err = evsel__tool_pmu_enable(evsel);
+ else
+ err = perf_evsel__enable(&evsel->core);
if (!err)
evsel->disabled = false;
+
+ if (!err && evsel__is_group_leader(evsel)) {
+ struct evsel *member;
+
+ for_each_group_member(member, evsel) {
+ if (evsel__is_non_perf_event_open_pmu(evsel) ||
+ evsel__is_non_perf_event_open_pmu(member)) {
+ /*
+ * In a mixed PMU group, userspace PMUs are not
+ * grouped in the kernel (opened with group_fd = -1)
+ * and are skipped by the kernel when enabling the
+ * group leader. We must manually enable them in
+ * userspace.
+ */
+ int mem_err = evsel__enable(member);
+
+ if (mem_err)
+ return mem_err;
+ }
+ member->disabled = false;
+ }
+ }
+
return err;
}
/* Caller has to set disabled after going through all CPUs. */
int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx)
{
- return perf_evsel__disable_cpu(&evsel->core, cpu_map_idx);
+ int err;
+
+ if (evsel__is_tool(evsel))
+ err = evsel__tool_pmu_disable_cpu(evsel, cpu_map_idx);
+ else
+ err = perf_evsel__disable_cpu(&evsel->core, cpu_map_idx);
+
+ if (!err && evsel__is_group_leader(evsel)) {
+ struct evsel *member;
+
+ for_each_group_member(member, evsel) {
+ if (evsel__is_non_perf_event_open_pmu(evsel) ||
+ evsel__is_non_perf_event_open_pmu(member)) {
+ /*
+ * In a mixed PMU group, userspace PMUs are not
+ * grouped in the kernel and are skipped by the
+ * kernel when disabling the group leader. We must
+ * manually disable them in userspace.
+ */
+ int mem_err = evsel__disable_cpu(member, cpu_map_idx);
+
+ if (mem_err)
+ return mem_err;
+ }
+ }
+ }
+ return err;
}
int evsel__disable(struct evsel *evsel)
{
- int err = perf_evsel__disable(&evsel->core);
+ int err;
+
+ if (evsel__is_tool(evsel))
+ err = evsel__tool_pmu_disable(evsel);
+ else
+ err = perf_evsel__disable(&evsel->core);
+
/*
* We mark it disabled here so that tools that disable a event can
* ignore events after they disable it. I.e. the ring buffer may have
if (!err)
evsel->disabled = true;
+ if (!err && evsel__is_group_leader(evsel)) {
+ struct evsel *member;
+
+ for_each_group_member(member, evsel) {
+ if (evsel__is_non_perf_event_open_pmu(evsel) ||
+ evsel__is_non_perf_event_open_pmu(member)) {
+ /*
+ * In a mixed PMU group, userspace PMUs are not
+ * grouped in the kernel and are skipped by the
+ * kernel when disabling the group leader. We must
+ * manually disable them in userspace.
+ */
+ int mem_err = evsel__disable(member);
+
+ if (mem_err)
+ return mem_err;
+ }
+ member->disabled = true;
+ }
+ }
+
return err;
}
evsel__priv_destructor(evsel->priv);
perf_evsel__object.fini(evsel);
if (evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
- evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME)
- xyarray__delete(evsel->start_times);
+ evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME) {
+ xyarray__delete(evsel->process_time.start_times);
+ xyarray__delete(evsel->process_time.accumulated_times);
+ }
}
void evsel__delete(struct evsel *evsel)
#include <fcntl.h>
#include <strings.h>
+#define INVALID_START_TIME ~0ULL
+
static const char *const tool_pmu__event_names[TOOL_PMU__EVENT_MAX] = {
NULL,
"duration_time",
struct perf_cpu_map *cpus,
int nthreads)
{
- if ((evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
- evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME) &&
- !evsel->start_times) {
- evsel->start_times = xyarray__new(perf_cpu_map__nr(cpus),
- nthreads,
- sizeof(__u64));
- if (!evsel->start_times)
- return -ENOMEM;
+ enum tool_pmu_event ev = evsel__tool_event(evsel);
+
+ if (ev == TOOL_PMU__EVENT_SYSTEM_TIME || ev == TOOL_PMU__EVENT_USER_TIME) {
+ if (!evsel->process_time.start_times) {
+ evsel->process_time.start_times =
+ xyarray__new(perf_cpu_map__nr(cpus), nthreads, sizeof(__u64));
+ if (!evsel->process_time.start_times)
+ return -ENOMEM;
+ }
+ if (!evsel->process_time.accumulated_times) {
+ evsel->process_time.accumulated_times =
+ xyarray__new(perf_cpu_map__nr(cpus), nthreads, sizeof(__u64));
+ if (!evsel->process_time.accumulated_times)
+ return -ENOMEM;
+ }
}
return 0;
}
#define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
+static int tool_pmu__read_stat(struct evsel *evsel, int cpu_map_idx, int thread, __u64 *val)
+{
+ enum tool_pmu_event ev = evsel__tool_event(evsel);
+ bool system = ev == TOOL_PMU__EVENT_SYSTEM_TIME;
+ int fd = FD(evsel, cpu_map_idx, thread);
+ int err = 0;
+
+ if (fd < 0) {
+ *val = 0;
+ return 0;
+ }
+
+ lseek(fd, 0, SEEK_SET);
+ if (evsel->pid_stat) {
+ if (cpu_map_idx == 0)
+ err = read_pid_stat_field(fd, system ? 15 : 14, val);
+ else
+ *val = 0;
+ } else {
+ if (thread == 0) {
+ struct perf_cpu cpu = perf_cpu_map__cpu(evsel->core.cpus, cpu_map_idx);
+
+ err = read_stat_field(fd, cpu, system ? 3 : 1, val);
+ } else {
+ *val = 0;
+ }
+ }
+ return err;
+}
+
int evsel__tool_pmu_open(struct evsel *evsel,
struct perf_thread_map *threads,
int start_cpu_map_idx, int end_cpu_map_idx)
if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
if (evsel->core.attr.sample_period) /* no sampling */
return -EINVAL;
- evsel->start_time = rdclock();
+ evsel->duration_time.accumulated_time = 0;
+ if (evsel->core.attr.disabled) {
+ evsel->disabled = true;
+ evsel->duration_time.start_time = INVALID_START_TIME;
+ } else {
+ evsel->disabled = false;
+ evsel->duration_time.start_time = rdclock();
+ }
return 0;
}
pid = perf_thread_map__pid(threads, thread);
if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
- bool system = ev == TOOL_PMU__EVENT_SYSTEM_TIME;
__u64 *start_time = NULL;
+ __u64 *accumulated_time = NULL;
int fd;
if (evsel->core.attr.sample_period) {
err = -errno;
goto out_close;
}
- start_time = xyarray__entry(evsel->start_times, idx, thread);
- if (pid > -1) {
- err = read_pid_stat_field(fd, system ? 15 : 14,
- start_time);
+ start_time = xyarray__entry(evsel->process_time.start_times, idx,
+ thread);
+ accumulated_time = xyarray__entry(
+ evsel->process_time.accumulated_times, idx, thread);
+ *accumulated_time = 0;
+
+ if (evsel->core.attr.disabled) {
+ evsel->disabled = true;
+ *start_time = INVALID_START_TIME;
} else {
- struct perf_cpu cpu;
-
- cpu = perf_cpu_map__cpu(evsel->core.cpus, idx);
- err = read_stat_field(fd, cpu, system ? 3 : 1,
- start_time);
+ evsel->disabled = false;
+ err = tool_pmu__read_stat(evsel, idx, thread, start_time);
+ if (err) {
+ close(fd);
+ FD(evsel, idx, thread) = -1;
+ goto out_close;
+ }
}
- if (err)
- goto out_close;
}
-
}
}
return 0;
count->lost = 0;
}
}
+int evsel__tool_pmu_enable_cpu(struct evsel *evsel, int cpu_map_idx)
+{
+ enum tool_pmu_event ev = evsel__tool_event(evsel);
+ int thread, nthreads;
+
+ if (!evsel->disabled)
+ return 0;
+
+ if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
+ if (cpu_map_idx == 0)
+ evsel->duration_time.start_time = rdclock();
+ return 0;
+ }
+
+ if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
+ nthreads = xyarray__max_y(evsel->process_time.start_times);
+ for (thread = 0; thread < nthreads; thread++) {
+ __u64 *start_time = xyarray__entry(evsel->process_time.start_times,
+ cpu_map_idx, thread);
+ __u64 val;
+ int err;
+
+ err = tool_pmu__read_stat(evsel, cpu_map_idx, thread, &val);
+ if (!err)
+ *start_time = val;
+ else
+ *start_time = INVALID_START_TIME;
+ }
+ }
+ return 0;
+}
+
+int evsel__tool_pmu_enable(struct evsel *evsel)
+{
+ unsigned int idx;
+ int err = 0;
+
+ if (!evsel->disabled)
+ return 0;
+
+ for (idx = 0; idx < perf_cpu_map__nr(evsel->core.cpus); idx++) {
+ err = evsel__tool_pmu_enable_cpu(evsel, idx);
+ if (err)
+ break;
+ }
+ return err;
+}
+
+int evsel__tool_pmu_disable_cpu(struct evsel *evsel, int cpu_map_idx)
+{
+ enum tool_pmu_event ev = evsel__tool_event(evsel);
+ int thread, nthreads;
+
+ if (evsel->disabled)
+ return 0;
+
+ if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
+ if (cpu_map_idx == 0) {
+ __u64 delta = rdclock() - evsel->duration_time.start_time;
+
+ evsel->duration_time.accumulated_time += delta;
+ }
+ return 0;
+ }
+
+ if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
+ nthreads = xyarray__max_y(evsel->process_time.start_times);
+ for (thread = 0; thread < nthreads; thread++) {
+ __u64 *start_time = xyarray__entry(evsel->process_time.start_times,
+ cpu_map_idx, thread);
+ __u64 *accumulated_time = xyarray__entry(
+ evsel->process_time.accumulated_times, cpu_map_idx, thread);
+ __u64 val;
+ int err;
+
+ err = tool_pmu__read_stat(evsel, cpu_map_idx, thread, &val);
+ if (!err) {
+ if (*start_time != INVALID_START_TIME && val >= *start_time)
+ *accumulated_time += (val - *start_time);
+ }
+ *start_time = INVALID_START_TIME;
+ }
+ }
+ return 0;
+}
+
+int evsel__tool_pmu_disable(struct evsel *evsel)
+{
+ unsigned int idx;
+ int err = 0;
+
+ if (evsel->disabled)
+ return 0;
+
+ for (idx = 0; idx < perf_cpu_map__nr(evsel->core.cpus); idx++) {
+ err = evsel__tool_pmu_disable_cpu(evsel, idx);
+ if (err)
+ break;
+ }
+ return err;
+}
int evsel__tool_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread)
{
- __u64 *start_time, cur_time, delta_start;
+ __u64 delta_start = 0;
int err = 0;
struct perf_counts_values *count, *old_count = NULL;
bool adjust = false;
return 0;
}
case TOOL_PMU__EVENT_DURATION_TIME:
- /*
- * Pretend duration_time is only on the first CPU and thread, or
- * else aggregation will scale duration_time by the number of
- * CPUs/threads.
- */
- start_time = &evsel->start_time;
- if (cpu_map_idx == 0 && thread == 0)
- cur_time = rdclock();
- else
- cur_time = *start_time;
+ if (cpu_map_idx == 0 && thread == 0) {
+ delta_start = evsel->duration_time.accumulated_time;
+ if (!evsel->disabled &&
+ evsel->duration_time.start_time != INVALID_START_TIME)
+ delta_start += (rdclock() - evsel->duration_time.start_time);
+ } else {
+ delta_start = 0;
+ }
break;
case TOOL_PMU__EVENT_USER_TIME:
case TOOL_PMU__EVENT_SYSTEM_TIME: {
- bool system = evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME;
- int fd = FD(evsel, cpu_map_idx, thread);
-
- start_time = xyarray__entry(evsel->start_times, cpu_map_idx, thread);
- lseek(fd, SEEK_SET, 0);
- if (evsel->pid_stat) {
- /* The event exists solely on 1 CPU. */
- if (cpu_map_idx == 0)
- err = read_pid_stat_field(fd, system ? 15 : 14, &cur_time);
- else
- cur_time = 0;
- } else {
- /* The event is for all threads. */
- if (thread == 0) {
- struct perf_cpu cpu = perf_cpu_map__cpu(evsel->core.cpus,
- cpu_map_idx);
+ __u64 accumulated = *(__u64 *)xyarray__entry(evsel->process_time.accumulated_times,
+ cpu_map_idx, thread);
- err = read_stat_field(fd, cpu, system ? 3 : 1, &cur_time);
- } else {
- cur_time = 0;
+ if (evsel->disabled) {
+ delta_start = accumulated;
+ } else {
+ __u64 *start_time = xyarray__entry(evsel->process_time.start_times,
+ cpu_map_idx, thread);
+ __u64 cur_time;
+
+ err = tool_pmu__read_stat(evsel, cpu_map_idx, thread, &cur_time);
+ if (!err) {
+ if (*start_time != INVALID_START_TIME && cur_time >= *start_time)
+ delta_start = accumulated + (cur_time - *start_time);
+ else
+ delta_start = accumulated;
}
}
adjust = true;
if (err)
return err;
- delta_start = cur_time - *start_time;
if (adjust) {
__u64 ticks_per_sec = sysconf(_SC_CLK_TCK);
projects / thirdparty / kernel / stable.git / commitdiff
