forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
328 lines
7.1 KiB
328 lines
7.1 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright 2010 ARM Ltd. |
|
* Copyright 2012 Advanced Micro Devices, Inc., Robert Richter |
|
* |
|
* Perf-events backend for OProfile. |
|
*/ |
|
#include <linux/perf_event.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/oprofile.h> |
|
#include <linux/slab.h> |
|
|
|
/* |
|
* Per performance monitor configuration as set via oprofilefs. |
|
*/ |
|
struct op_counter_config { |
|
unsigned long count; |
|
unsigned long enabled; |
|
unsigned long event; |
|
unsigned long unit_mask; |
|
unsigned long kernel; |
|
unsigned long user; |
|
struct perf_event_attr attr; |
|
}; |
|
|
|
static int oprofile_perf_enabled; |
|
static DEFINE_MUTEX(oprofile_perf_mutex); |
|
|
|
static struct op_counter_config *counter_config; |
|
static DEFINE_PER_CPU(struct perf_event **, perf_events); |
|
static int num_counters; |
|
|
|
/* |
|
* Overflow callback for oprofile. |
|
*/ |
|
static void op_overflow_handler(struct perf_event *event, |
|
struct perf_sample_data *data, struct pt_regs *regs) |
|
{ |
|
int id; |
|
u32 cpu = smp_processor_id(); |
|
|
|
for (id = 0; id < num_counters; ++id) |
|
if (per_cpu(perf_events, cpu)[id] == event) |
|
break; |
|
|
|
if (id != num_counters) |
|
oprofile_add_sample(regs, id); |
|
else |
|
pr_warn("oprofile: ignoring spurious overflow on cpu %u\n", |
|
cpu); |
|
} |
|
|
|
/* |
|
* Called by oprofile_perf_setup to create perf attributes to mirror the oprofile |
|
* settings in counter_config. Attributes are created as `pinned' events and |
|
* so are permanently scheduled on the PMU. |
|
*/ |
|
static void op_perf_setup(void) |
|
{ |
|
int i; |
|
u32 size = sizeof(struct perf_event_attr); |
|
struct perf_event_attr *attr; |
|
|
|
for (i = 0; i < num_counters; ++i) { |
|
attr = &counter_config[i].attr; |
|
memset(attr, 0, size); |
|
attr->type = PERF_TYPE_RAW; |
|
attr->size = size; |
|
attr->config = counter_config[i].event; |
|
attr->sample_period = counter_config[i].count; |
|
attr->pinned = 1; |
|
} |
|
} |
|
|
|
static int op_create_counter(int cpu, int event) |
|
{ |
|
struct perf_event *pevent; |
|
|
|
if (!counter_config[event].enabled || per_cpu(perf_events, cpu)[event]) |
|
return 0; |
|
|
|
pevent = perf_event_create_kernel_counter(&counter_config[event].attr, |
|
cpu, NULL, |
|
op_overflow_handler, NULL); |
|
|
|
if (IS_ERR(pevent)) |
|
return PTR_ERR(pevent); |
|
|
|
if (pevent->state != PERF_EVENT_STATE_ACTIVE) { |
|
perf_event_release_kernel(pevent); |
|
pr_warn("oprofile: failed to enable event %d on CPU %d\n", |
|
event, cpu); |
|
return -EBUSY; |
|
} |
|
|
|
per_cpu(perf_events, cpu)[event] = pevent; |
|
|
|
return 0; |
|
} |
|
|
|
static void op_destroy_counter(int cpu, int event) |
|
{ |
|
struct perf_event *pevent = per_cpu(perf_events, cpu)[event]; |
|
|
|
if (pevent) { |
|
perf_event_release_kernel(pevent); |
|
per_cpu(perf_events, cpu)[event] = NULL; |
|
} |
|
} |
|
|
|
/* |
|
* Called by oprofile_perf_start to create active perf events based on the |
|
* perviously configured attributes. |
|
*/ |
|
static int op_perf_start(void) |
|
{ |
|
int cpu, event, ret = 0; |
|
|
|
for_each_online_cpu(cpu) { |
|
for (event = 0; event < num_counters; ++event) { |
|
ret = op_create_counter(cpu, event); |
|
if (ret) |
|
return ret; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
/* |
|
* Called by oprofile_perf_stop at the end of a profiling run. |
|
*/ |
|
static void op_perf_stop(void) |
|
{ |
|
int cpu, event; |
|
|
|
for_each_online_cpu(cpu) |
|
for (event = 0; event < num_counters; ++event) |
|
op_destroy_counter(cpu, event); |
|
} |
|
|
|
static int oprofile_perf_create_files(struct dentry *root) |
|
{ |
|
unsigned int i; |
|
|
|
for (i = 0; i < num_counters; i++) { |
|
struct dentry *dir; |
|
char buf[4]; |
|
|
|
snprintf(buf, sizeof buf, "%d", i); |
|
dir = oprofilefs_mkdir(root, buf); |
|
oprofilefs_create_ulong(dir, "enabled", &counter_config[i].enabled); |
|
oprofilefs_create_ulong(dir, "event", &counter_config[i].event); |
|
oprofilefs_create_ulong(dir, "count", &counter_config[i].count); |
|
oprofilefs_create_ulong(dir, "unit_mask", &counter_config[i].unit_mask); |
|
oprofilefs_create_ulong(dir, "kernel", &counter_config[i].kernel); |
|
oprofilefs_create_ulong(dir, "user", &counter_config[i].user); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int oprofile_perf_setup(void) |
|
{ |
|
raw_spin_lock(&oprofilefs_lock); |
|
op_perf_setup(); |
|
raw_spin_unlock(&oprofilefs_lock); |
|
return 0; |
|
} |
|
|
|
static int oprofile_perf_start(void) |
|
{ |
|
int ret = -EBUSY; |
|
|
|
mutex_lock(&oprofile_perf_mutex); |
|
if (!oprofile_perf_enabled) { |
|
ret = 0; |
|
op_perf_start(); |
|
oprofile_perf_enabled = 1; |
|
} |
|
mutex_unlock(&oprofile_perf_mutex); |
|
return ret; |
|
} |
|
|
|
static void oprofile_perf_stop(void) |
|
{ |
|
mutex_lock(&oprofile_perf_mutex); |
|
if (oprofile_perf_enabled) |
|
op_perf_stop(); |
|
oprofile_perf_enabled = 0; |
|
mutex_unlock(&oprofile_perf_mutex); |
|
} |
|
|
|
#ifdef CONFIG_PM |
|
|
|
static int oprofile_perf_suspend(struct platform_device *dev, pm_message_t state) |
|
{ |
|
mutex_lock(&oprofile_perf_mutex); |
|
if (oprofile_perf_enabled) |
|
op_perf_stop(); |
|
mutex_unlock(&oprofile_perf_mutex); |
|
return 0; |
|
} |
|
|
|
static int oprofile_perf_resume(struct platform_device *dev) |
|
{ |
|
mutex_lock(&oprofile_perf_mutex); |
|
if (oprofile_perf_enabled && op_perf_start()) |
|
oprofile_perf_enabled = 0; |
|
mutex_unlock(&oprofile_perf_mutex); |
|
return 0; |
|
} |
|
|
|
static struct platform_driver oprofile_driver = { |
|
.driver = { |
|
.name = "oprofile-perf", |
|
}, |
|
.resume = oprofile_perf_resume, |
|
.suspend = oprofile_perf_suspend, |
|
}; |
|
|
|
static struct platform_device *oprofile_pdev; |
|
|
|
static int __init init_driverfs(void) |
|
{ |
|
int ret; |
|
|
|
ret = platform_driver_register(&oprofile_driver); |
|
if (ret) |
|
return ret; |
|
|
|
oprofile_pdev = platform_device_register_simple( |
|
oprofile_driver.driver.name, 0, NULL, 0); |
|
if (IS_ERR(oprofile_pdev)) { |
|
ret = PTR_ERR(oprofile_pdev); |
|
platform_driver_unregister(&oprofile_driver); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static void exit_driverfs(void) |
|
{ |
|
platform_device_unregister(oprofile_pdev); |
|
platform_driver_unregister(&oprofile_driver); |
|
} |
|
|
|
#else |
|
|
|
static inline int init_driverfs(void) { return 0; } |
|
static inline void exit_driverfs(void) { } |
|
|
|
#endif /* CONFIG_PM */ |
|
|
|
void oprofile_perf_exit(void) |
|
{ |
|
int cpu, id; |
|
struct perf_event *event; |
|
|
|
for_each_possible_cpu(cpu) { |
|
for (id = 0; id < num_counters; ++id) { |
|
event = per_cpu(perf_events, cpu)[id]; |
|
if (event) |
|
perf_event_release_kernel(event); |
|
} |
|
|
|
kfree(per_cpu(perf_events, cpu)); |
|
} |
|
|
|
kfree(counter_config); |
|
exit_driverfs(); |
|
} |
|
|
|
int __init oprofile_perf_init(struct oprofile_operations *ops) |
|
{ |
|
int cpu, ret = 0; |
|
|
|
ret = init_driverfs(); |
|
if (ret) |
|
return ret; |
|
|
|
num_counters = perf_num_counters(); |
|
if (num_counters <= 0) { |
|
pr_info("oprofile: no performance counters\n"); |
|
ret = -ENODEV; |
|
goto out; |
|
} |
|
|
|
counter_config = kcalloc(num_counters, |
|
sizeof(struct op_counter_config), GFP_KERNEL); |
|
|
|
if (!counter_config) { |
|
pr_info("oprofile: failed to allocate %d " |
|
"counters\n", num_counters); |
|
ret = -ENOMEM; |
|
num_counters = 0; |
|
goto out; |
|
} |
|
|
|
for_each_possible_cpu(cpu) { |
|
per_cpu(perf_events, cpu) = kcalloc(num_counters, |
|
sizeof(struct perf_event *), GFP_KERNEL); |
|
if (!per_cpu(perf_events, cpu)) { |
|
pr_info("oprofile: failed to allocate %d perf events " |
|
"for cpu %d\n", num_counters, cpu); |
|
ret = -ENOMEM; |
|
goto out; |
|
} |
|
} |
|
|
|
ops->create_files = oprofile_perf_create_files; |
|
ops->setup = oprofile_perf_setup; |
|
ops->start = oprofile_perf_start; |
|
ops->stop = oprofile_perf_stop; |
|
ops->shutdown = oprofile_perf_stop; |
|
ops->cpu_type = op_name_from_perf_id(); |
|
|
|
if (!ops->cpu_type) |
|
ret = -ENODEV; |
|
else |
|
pr_info("oprofile: using %s\n", ops->cpu_type); |
|
|
|
out: |
|
if (ret) |
|
oprofile_perf_exit(); |
|
|
|
return ret; |
|
}
|
|
|