mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-12-29 17:25:38 +00:00
perf hwmon_pmu: Add a tool PMU exposing events from hwmon in sysfs
Add a tool PMU for hwmon events but don't enable.
The hwmon sysfs ABI is defined in
Documentation/hwmon/sysfs-interface.rst. Create a PMU that reads the
hwmon input and can be used in `perf stat` and metrics much as an
uncore PMU can.
For example, when enabled by a later patch, the following shows
reading the CPU temperature and 2 fan speeds alongside the uncore
frequency:
```
$ perf stat -e temp_cpu,fan1,hwmon_thinkpad/fan2/,tool/num_cpus_online/ -M UNCORE_FREQ -I 1000
1.001153138 52.00 'C temp_cpu
1.001153138 2,588 rpm fan1
1.001153138 2,482 rpm hwmon_thinkpad/fan2/
1.001153138 8 tool/num_cpus_online/
1.001153138 1,077,101,397 UNC_CLOCK.SOCKET # 1.08 UNCORE_FREQ
1.001153138 1,012,773,595 duration_time
...
```
The PMUs are named from /sys/class/hwmon/hwmon<num>/name and have an
alias of hwmon<num>.
Hwmon data is presented in multiple <type><number>_<item> files. The
<type><number> is used to identify the event as is the <type> followed
by the contents of the <type>_label file if it exists. The
<type><number>_input file gives the data read by perf.
When enabled by a later patch, in `perf list` the other hwmon <item>
files are used to give a richer description, for example:
```
hwmon:
temp1
[Temperature in unit acpitz named temp1. Unit: hwmon_acpitz]
in0
[Voltage in unit bat0 named in0. Unit: hwmon_bat0]
temp_core_0 OR temp2
[Temperature in unit coretemp named Core 0. crit=100'C,max=100'C crit_alarm=0'C. Unit:
hwmon_coretemp]
temp_core_1 OR temp3
[Temperature in unit coretemp named Core 1. crit=100'C,max=100'C crit_alarm=0'C. Unit:
hwmon_coretemp]
...
temp_package_id_0 OR temp1
[Temperature in unit coretemp named Package id 0. crit=100'C,max=100'C crit_alarm=0'C.
Unit: hwmon_coretemp]
temp1
[Temperature in unit iwlwifi_1 named temp1. Unit: hwmon_iwlwifi_1]
temp_composite OR temp1
[Temperature in unit nvme named Composite. alarm=0'C,crit=86.85'C,max=75.85'C,
min=-273.15'C. Unit: hwmon_nvme]
temp_sensor_1 OR temp2
[Temperature in unit nvme named Sensor 1. max=65261.8'C,min=-273.15'C. Unit: hwmon_nvme]
temp_sensor_2 OR temp3
[Temperature in unit nvme named Sensor 2. max=65261.8'C,min=-273.15'C. Unit: hwmon_nvme]
fan1
[Fan in unit thinkpad named fan1. Unit: hwmon_thinkpad]
fan2
[Fan in unit thinkpad named fan2. Unit: hwmon_thinkpad]
...
temp_cpu OR temp1
[Temperature in unit thinkpad named CPU. Unit: hwmon_thinkpad]
temp_gpu OR temp2
[Temperature in unit thinkpad named GPU. Unit: hwmon_thinkpad]
curr1
[Current in unit ucsi_source_psy_usbc000_0 named curr1. max=1.5A. Unit:
hwmon_ucsi_source_psy_usbc000_0]
in0
[Voltage in unit ucsi_source_psy_usbc000_0 named in0. max=5V,min=5V. Unit:
hwmon_ucsi_source_psy_usbc000_0]
```
As there may be multiple hwmon devices a range of PMU types are
reserved for their use and to identify the PMU as belonging to the
hwmon types.
Signed-off-by: Ian Rogers <irogers@google.com>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Yoshihiro Furudera <fj5100bi@fujitsu.com>
Cc: Howard Chu <howardchu95@gmail.com>
Cc: Ze Gao <zegao2021@gmail.com>
Cc: Changbin Du <changbin.du@huawei.com>
Cc: Junhao He <hejunhao3@huawei.com>
Cc: Weilin Wang <weilin.wang@intel.com>
Cc: James Clark <james.clark@linaro.org>
Cc: Oliver Upton <oliver.upton@linux.dev>
Cc: Athira Jajeev <atrajeev@linux.vnet.ibm.com>
Link: https://lore.kernel.org/r/20241109003759.473460-5-irogers@google.com
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
This commit is contained in:
Ian Rogers
Namhyung Kim
parent
8c329057de
commit
53cc0b351e
@ -1,12 +1,26 @@
|
||||
// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
|
||||
#include "counts.h"
|
||||
#include "debug.h"
|
||||
#include "evsel.h"
|
||||
#include "hashmap.h"
|
||||
#include "hwmon_pmu.h"
|
||||
#include "pmu.h"
|
||||
#include <internal/xyarray.h>
|
||||
#include <internal/threadmap.h>
|
||||
#include <perf/threadmap.h>
|
||||
#include <sys/types.h>
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <api/fs/fs.h>
|
||||
#include <api/io.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/zalloc.h>
|
||||
|
||||
/** Strings that correspond to enum hwmon_type. */
|
||||
static const char * const hwmon_type_strs[HWMON_TYPE_MAX] = {
|
||||
@ -73,6 +87,79 @@ static const char * const hwmon_item_strs[HWMON_ITEM__MAX] = {
|
||||
};
|
||||
#define LONGEST_HWMON_ITEM_STR "average_interval_max"
|
||||
|
||||
static const char *const hwmon_units[HWMON_TYPE_MAX] = {
|
||||
NULL,
|
||||
"V", /* cpu */
|
||||
"A", /* curr */
|
||||
"J", /* energy */
|
||||
"rpm", /* fan */
|
||||
"%", /* humidity */
|
||||
"V", /* in */
|
||||
"", /* intrusion */
|
||||
"W", /* power */
|
||||
"Hz", /* pwm */
|
||||
"'C", /* temp */
|
||||
};
|
||||
|
||||
struct hwmon_pmu {
|
||||
struct perf_pmu pmu;
|
||||
struct hashmap events;
|
||||
int hwmon_dir_fd;
|
||||
};
|
||||
|
||||
/**
|
||||
* union hwmon_pmu_event_key: Key for hwmon_pmu->events as such each key
|
||||
* represents an event.
|
||||
*
|
||||
* Related hwmon files start <type><number> that this key represents.
|
||||
*/
|
||||
union hwmon_pmu_event_key {
|
||||
long type_and_num;
|
||||
struct {
|
||||
int num :16;
|
||||
enum hwmon_type type :8;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* struct hwmon_pmu_event_value: Value in hwmon_pmu->events.
|
||||
*
|
||||
* Hwmon files are of the form <type><number>_<item> and may have a suffix
|
||||
* _alarm.
|
||||
*/
|
||||
struct hwmon_pmu_event_value {
|
||||
/** @items: which item files are present. */
|
||||
DECLARE_BITMAP(items, HWMON_ITEM__MAX);
|
||||
/** @alarm_items: which item files are present. */
|
||||
DECLARE_BITMAP(alarm_items, HWMON_ITEM__MAX);
|
||||
/** @label: contents of <type><number>_label if present. */
|
||||
char *label;
|
||||
/** @name: name computed from label of the form <type>_<label>. */
|
||||
char *name;
|
||||
};
|
||||
|
||||
bool perf_pmu__is_hwmon(const struct perf_pmu *pmu)
|
||||
{
|
||||
return pmu && pmu->type >= PERF_PMU_TYPE_HWMON_START &&
|
||||
pmu->type <= PERF_PMU_TYPE_HWMON_END;
|
||||
}
|
||||
|
||||
bool evsel__is_hwmon(const struct evsel *evsel)
|
||||
{
|
||||
return perf_pmu__is_hwmon(evsel->pmu);
|
||||
}
|
||||
|
||||
static size_t hwmon_pmu__event_hashmap_hash(long key, void *ctx __maybe_unused)
|
||||
{
|
||||
return ((union hwmon_pmu_event_key)key).type_and_num;
|
||||
}
|
||||
|
||||
static bool hwmon_pmu__event_hashmap_equal(long key1, long key2, void *ctx __maybe_unused)
|
||||
{
|
||||
return ((union hwmon_pmu_event_key)key1).type_and_num ==
|
||||
((union hwmon_pmu_event_key)key2).type_and_num;
|
||||
}
|
||||
|
||||
static int hwmon_strcmp(const void *a, const void *b)
|
||||
{
|
||||
const char *sa = a;
|
||||
@ -143,3 +230,598 @@ bool parse_hwmon_filename(const char *filename,
|
||||
*item = elem - &hwmon_item_strs[0];
|
||||
return true;
|
||||
}
|
||||
|
||||
static void fix_name(char *p)
|
||||
{
|
||||
char *s = strchr(p, '\n');
|
||||
|
||||
if (s)
|
||||
*s = '\0';
|
||||
|
||||
while (*p != '\0') {
|
||||
if (strchr(" :,/\n\t", *p))
|
||||
*p = '_';
|
||||
else
|
||||
*p = tolower(*p);
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
static int hwmon_pmu__read_events(struct hwmon_pmu *pmu)
|
||||
{
|
||||
DIR *dir;
|
||||
struct dirent *ent;
|
||||
int dup_fd, err = 0;
|
||||
struct hashmap_entry *cur, *tmp;
|
||||
size_t bkt;
|
||||
|
||||
if (pmu->pmu.sysfs_aliases_loaded)
|
||||
return 0;
|
||||
|
||||
/* Use a dup-ed fd as closedir will close it. */
|
||||
dup_fd = dup(pmu->hwmon_dir_fd);
|
||||
if (dup_fd == -1)
|
||||
return -ENOMEM;
|
||||
|
||||
dir = fdopendir(dup_fd);
|
||||
if (!dir) {
|
||||
close(dup_fd);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
while ((ent = readdir(dir)) != NULL) {
|
||||
enum hwmon_type type;
|
||||
int number;
|
||||
enum hwmon_item item;
|
||||
bool alarm;
|
||||
union hwmon_pmu_event_key key = {};
|
||||
struct hwmon_pmu_event_value *value;
|
||||
|
||||
if (ent->d_type != DT_REG)
|
||||
continue;
|
||||
|
||||
if (!parse_hwmon_filename(ent->d_name, &type, &number, &item, &alarm)) {
|
||||
pr_debug("Not a hwmon file '%s'\n", ent->d_name);
|
||||
continue;
|
||||
}
|
||||
key.num = number;
|
||||
key.type = type;
|
||||
if (!hashmap__find(&pmu->events, key.type_and_num, &value)) {
|
||||
value = zalloc(sizeof(*value));
|
||||
if (!value) {
|
||||
err = -ENOMEM;
|
||||
goto err_out;
|
||||
}
|
||||
err = hashmap__add(&pmu->events, key.type_and_num, value);
|
||||
if (err) {
|
||||
free(value);
|
||||
err = -ENOMEM;
|
||||
goto err_out;
|
||||
}
|
||||
}
|
||||
__set_bit(item, alarm ? value->alarm_items : value->items);
|
||||
if (item == HWMON_ITEM_LABEL) {
|
||||
char buf[128];
|
||||
int fd = openat(pmu->hwmon_dir_fd, ent->d_name, O_RDONLY);
|
||||
ssize_t read_len;
|
||||
|
||||
if (fd < 0)
|
||||
continue;
|
||||
|
||||
read_len = read(fd, buf, sizeof(buf));
|
||||
|
||||
while (read_len > 0 && buf[read_len - 1] == '\n')
|
||||
read_len--;
|
||||
|
||||
if (read_len > 0)
|
||||
buf[read_len] = '\0';
|
||||
|
||||
if (buf[0] == '\0') {
|
||||
pr_debug("hwmon_pmu: empty label file %s %s\n",
|
||||
pmu->pmu.name, ent->d_name);
|
||||
close(fd);
|
||||
continue;
|
||||
}
|
||||
value->label = strdup(buf);
|
||||
if (!value->label) {
|
||||
pr_debug("hwmon_pmu: memory allocation failure\n");
|
||||
close(fd);
|
||||
continue;
|
||||
}
|
||||
snprintf(buf, sizeof(buf), "%s_%s", hwmon_type_strs[type], value->label);
|
||||
fix_name(buf);
|
||||
value->name = strdup(buf);
|
||||
if (!value->name)
|
||||
pr_debug("hwmon_pmu: memory allocation failure\n");
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
hashmap__for_each_entry_safe((&pmu->events), cur, tmp, bkt) {
|
||||
union hwmon_pmu_event_key key = {
|
||||
.type_and_num = cur->key,
|
||||
};
|
||||
struct hwmon_pmu_event_value *value = cur->pvalue;
|
||||
|
||||
if (!test_bit(HWMON_ITEM_INPUT, value->items)) {
|
||||
pr_debug("hwmon_pmu: removing event '%s%d' that has no input file\n",
|
||||
hwmon_type_strs[key.type], key.num);
|
||||
hashmap__delete(&pmu->events, key.type_and_num, &key, &value);
|
||||
zfree(&value->label);
|
||||
zfree(&value->name);
|
||||
free(value);
|
||||
}
|
||||
}
|
||||
pmu->pmu.sysfs_aliases_loaded = true;
|
||||
|
||||
err_out:
|
||||
closedir(dir);
|
||||
return err;
|
||||
}
|
||||
|
||||
struct perf_pmu *hwmon_pmu__new(struct list_head *pmus, int hwmon_dir, const char *sysfs_name, const char *name)
|
||||
{
|
||||
char buf[32];
|
||||
struct hwmon_pmu *hwm;
|
||||
|
||||
hwm = zalloc(sizeof(*hwm));
|
||||
if (!hwm)
|
||||
return NULL;
|
||||
|
||||
hwm->hwmon_dir_fd = hwmon_dir;
|
||||
hwm->pmu.type = PERF_PMU_TYPE_HWMON_START + strtoul(sysfs_name + 5, NULL, 10);
|
||||
if (hwm->pmu.type > PERF_PMU_TYPE_HWMON_END) {
|
||||
pr_err("Unable to encode hwmon type from %s in valid PMU type\n", sysfs_name);
|
||||
goto err_out;
|
||||
}
|
||||
snprintf(buf, sizeof(buf), "hwmon_%s", name);
|
||||
fix_name(buf + 6);
|
||||
hwm->pmu.name = strdup(buf);
|
||||
if (!hwm->pmu.name)
|
||||
goto err_out;
|
||||
hwm->pmu.alias_name = strdup(sysfs_name);
|
||||
if (!hwm->pmu.alias_name)
|
||||
goto err_out;
|
||||
hwm->pmu.cpus = perf_cpu_map__new("0");
|
||||
if (!hwm->pmu.cpus)
|
||||
goto err_out;
|
||||
INIT_LIST_HEAD(&hwm->pmu.format);
|
||||
INIT_LIST_HEAD(&hwm->pmu.aliases);
|
||||
INIT_LIST_HEAD(&hwm->pmu.caps);
|
||||
hashmap__init(&hwm->events, hwmon_pmu__event_hashmap_hash,
|
||||
hwmon_pmu__event_hashmap_equal, /*ctx=*/NULL);
|
||||
|
||||
list_add_tail(&hwm->pmu.list, pmus);
|
||||
return &hwm->pmu;
|
||||
err_out:
|
||||
free((char *)hwm->pmu.name);
|
||||
free(hwm->pmu.alias_name);
|
||||
free(hwm);
|
||||
close(hwmon_dir);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void hwmon_pmu__exit(struct perf_pmu *pmu)
|
||||
{
|
||||
struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
|
||||
struct hashmap_entry *cur, *tmp;
|
||||
size_t bkt;
|
||||
|
||||
hashmap__for_each_entry_safe((&hwm->events), cur, tmp, bkt) {
|
||||
struct hwmon_pmu_event_value *value = cur->pvalue;
|
||||
|
||||
zfree(&value->label);
|
||||
zfree(&value->name);
|
||||
free(value);
|
||||
}
|
||||
hashmap__clear(&hwm->events);
|
||||
close(hwm->hwmon_dir_fd);
|
||||
}
|
||||
|
||||
static size_t hwmon_pmu__describe_items(struct hwmon_pmu *hwm, char *out_buf, size_t out_buf_len,
|
||||
union hwmon_pmu_event_key key,
|
||||
const unsigned long *items, bool is_alarm)
|
||||
{
|
||||
size_t bit;
|
||||
char buf[64];
|
||||
size_t len = 0;
|
||||
|
||||
for_each_set_bit(bit, items, HWMON_ITEM__MAX) {
|
||||
int fd;
|
||||
|
||||
if (bit == HWMON_ITEM_LABEL || bit == HWMON_ITEM_INPUT)
|
||||
continue;
|
||||
|
||||
snprintf(buf, sizeof(buf), "%s%d_%s%s",
|
||||
hwmon_type_strs[key.type],
|
||||
key.num,
|
||||
hwmon_item_strs[bit],
|
||||
is_alarm ? "_alarm" : "");
|
||||
fd = openat(hwm->hwmon_dir_fd, buf, O_RDONLY);
|
||||
if (fd > 0) {
|
||||
ssize_t read_len = read(fd, buf, sizeof(buf));
|
||||
|
||||
while (read_len > 0 && buf[read_len - 1] == '\n')
|
||||
read_len--;
|
||||
|
||||
if (read_len > 0) {
|
||||
long long val;
|
||||
|
||||
buf[read_len] = '\0';
|
||||
val = strtoll(buf, /*endptr=*/NULL, 10);
|
||||
len += snprintf(out_buf + len, out_buf_len - len, "%s%s%s=%g%s",
|
||||
len == 0 ? " " : ", ",
|
||||
hwmon_item_strs[bit],
|
||||
is_alarm ? "_alarm" : "",
|
||||
(double)val / 1000.0,
|
||||
hwmon_units[key.type]);
|
||||
}
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
int hwmon_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb)
|
||||
{
|
||||
struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
|
||||
struct hashmap_entry *cur;
|
||||
size_t bkt;
|
||||
|
||||
if (hwmon_pmu__read_events(hwm))
|
||||
return false;
|
||||
|
||||
hashmap__for_each_entry((&hwm->events), cur, bkt) {
|
||||
static const char *const hwmon_scale_units[HWMON_TYPE_MAX] = {
|
||||
NULL,
|
||||
"0.001V", /* cpu */
|
||||
"0.001A", /* curr */
|
||||
"0.001J", /* energy */
|
||||
"1rpm", /* fan */
|
||||
"0.001%", /* humidity */
|
||||
"0.001V", /* in */
|
||||
NULL, /* intrusion */
|
||||
"0.001W", /* power */
|
||||
"1Hz", /* pwm */
|
||||
"0.001'C", /* temp */
|
||||
};
|
||||
static const char *const hwmon_desc[HWMON_TYPE_MAX] = {
|
||||
NULL,
|
||||
"CPU core reference voltage", /* cpu */
|
||||
"Current", /* curr */
|
||||
"Cumulative energy use", /* energy */
|
||||
"Fan", /* fan */
|
||||
"Humidity", /* humidity */
|
||||
"Voltage", /* in */
|
||||
"Chassis intrusion detection", /* intrusion */
|
||||
"Power use", /* power */
|
||||
"Pulse width modulation fan control", /* pwm */
|
||||
"Temperature", /* temp */
|
||||
};
|
||||
char alias_buf[64];
|
||||
char desc_buf[256];
|
||||
char encoding_buf[128];
|
||||
union hwmon_pmu_event_key key = {
|
||||
.type_and_num = cur->key,
|
||||
};
|
||||
struct hwmon_pmu_event_value *value = cur->pvalue;
|
||||
struct pmu_event_info info = {
|
||||
.pmu = pmu,
|
||||
.name = value->name,
|
||||
.alias = alias_buf,
|
||||
.scale_unit = hwmon_scale_units[key.type],
|
||||
.desc = desc_buf,
|
||||
.long_desc = NULL,
|
||||
.encoding_desc = encoding_buf,
|
||||
.topic = "hwmon",
|
||||
.pmu_name = pmu->name,
|
||||
.event_type_desc = "Hwmon event",
|
||||
};
|
||||
int ret;
|
||||
size_t len;
|
||||
|
||||
len = snprintf(alias_buf, sizeof(alias_buf), "%s%d",
|
||||
hwmon_type_strs[key.type], key.num);
|
||||
if (!info.name) {
|
||||
info.name = info.alias;
|
||||
info.alias = NULL;
|
||||
}
|
||||
|
||||
len = snprintf(desc_buf, sizeof(desc_buf), "%s in unit %s named %s.",
|
||||
hwmon_desc[key.type],
|
||||
pmu->name + 6,
|
||||
value->label ?: info.name);
|
||||
|
||||
len += hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf) - len,
|
||||
key, value->items, /*is_alarm=*/false);
|
||||
|
||||
len += hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf) - len,
|
||||
key, value->alarm_items, /*is_alarm=*/true);
|
||||
|
||||
snprintf(encoding_buf, sizeof(encoding_buf), "%s/config=0x%lx/",
|
||||
pmu->name, cur->key);
|
||||
|
||||
ret = cb(state, &info);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t hwmon_pmu__num_events(struct perf_pmu *pmu)
|
||||
{
|
||||
struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
|
||||
|
||||
hwmon_pmu__read_events(hwm);
|
||||
return hashmap__size(&hwm->events);
|
||||
}
|
||||
|
||||
bool hwmon_pmu__have_event(struct perf_pmu *pmu, const char *name)
|
||||
{
|
||||
struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
|
||||
enum hwmon_type type;
|
||||
int number;
|
||||
union hwmon_pmu_event_key key = {};
|
||||
struct hashmap_entry *cur;
|
||||
size_t bkt;
|
||||
|
||||
if (!parse_hwmon_filename(name, &type, &number, /*item=*/NULL, /*is_alarm=*/NULL))
|
||||
return false;
|
||||
|
||||
if (hwmon_pmu__read_events(hwm))
|
||||
return false;
|
||||
|
||||
key.type = type;
|
||||
key.num = number;
|
||||
if (hashmap_find(&hwm->events, key.type_and_num, /*value=*/NULL))
|
||||
return true;
|
||||
if (key.num != -1)
|
||||
return false;
|
||||
/* Item is of form <type>_ which means we should match <type>_<label>. */
|
||||
hashmap__for_each_entry((&hwm->events), cur, bkt) {
|
||||
struct hwmon_pmu_event_value *value = cur->pvalue;
|
||||
|
||||
key.type_and_num = cur->key;
|
||||
if (key.type == type && value->name && !strcasecmp(name, value->name))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static int hwmon_pmu__config_term(const struct hwmon_pmu *hwm,
|
||||
struct perf_event_attr *attr,
|
||||
struct parse_events_term *term,
|
||||
struct parse_events_error *err)
|
||||
{
|
||||
if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
|
||||
enum hwmon_type type;
|
||||
int number;
|
||||
|
||||
if (parse_hwmon_filename(term->config, &type, &number,
|
||||
/*item=*/NULL, /*is_alarm=*/NULL)) {
|
||||
if (number == -1) {
|
||||
/*
|
||||
* Item is of form <type>_ which means we should
|
||||
* match <type>_<label>.
|
||||
*/
|
||||
struct hashmap_entry *cur;
|
||||
size_t bkt;
|
||||
|
||||
attr->config = 0;
|
||||
hashmap__for_each_entry((&hwm->events), cur, bkt) {
|
||||
union hwmon_pmu_event_key key = {
|
||||
.type_and_num = cur->key,
|
||||
};
|
||||
struct hwmon_pmu_event_value *value = cur->pvalue;
|
||||
|
||||
if (key.type == type && value->name &&
|
||||
!strcasecmp(term->config, value->name)) {
|
||||
attr->config = key.type_and_num;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (attr->config == 0)
|
||||
return -EINVAL;
|
||||
} else {
|
||||
union hwmon_pmu_event_key key = {
|
||||
.type = type,
|
||||
.num = number,
|
||||
};
|
||||
|
||||
attr->config = key.type_and_num;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
if (err) {
|
||||
char *err_str;
|
||||
|
||||
parse_events_error__handle(err, term->err_val,
|
||||
asprintf(&err_str,
|
||||
"unexpected hwmon event term (%s) %s",
|
||||
parse_events__term_type_str(term->type_term),
|
||||
term->config) < 0
|
||||
? strdup("unexpected hwmon event term")
|
||||
: err_str,
|
||||
NULL);
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int hwmon_pmu__config_terms(const struct perf_pmu *pmu,
|
||||
struct perf_event_attr *attr,
|
||||
struct parse_events_terms *terms,
|
||||
struct parse_events_error *err)
|
||||
{
|
||||
const struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
|
||||
struct parse_events_term *term;
|
||||
|
||||
assert(pmu->sysfs_aliases_loaded);
|
||||
list_for_each_entry(term, &terms->terms, list) {
|
||||
if (hwmon_pmu__config_term(hwm, attr, term, err))
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int hwmon_pmu__check_alias(struct parse_events_terms *terms, struct perf_pmu_info *info,
|
||||
struct parse_events_error *err)
|
||||
{
|
||||
struct parse_events_term *term =
|
||||
list_first_entry(&terms->terms, struct parse_events_term, list);
|
||||
|
||||
if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
|
||||
enum hwmon_type type;
|
||||
int number;
|
||||
|
||||
if (parse_hwmon_filename(term->config, &type, &number,
|
||||
/*item=*/NULL, /*is_alarm=*/NULL)) {
|
||||
info->unit = hwmon_units[type];
|
||||
if (type == HWMON_TYPE_FAN || type == HWMON_TYPE_PWM ||
|
||||
type == HWMON_TYPE_INTRUSION)
|
||||
info->scale = 1;
|
||||
else
|
||||
info->scale = 0.001;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (err) {
|
||||
char *err_str;
|
||||
|
||||
parse_events_error__handle(err, term->err_val,
|
||||
asprintf(&err_str,
|
||||
"unexpected hwmon event term (%s) %s",
|
||||
parse_events__term_type_str(term->type_term),
|
||||
term->config) < 0
|
||||
? strdup("unexpected hwmon event term")
|
||||
: err_str,
|
||||
NULL);
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int perf_pmus__read_hwmon_pmus(struct list_head *pmus)
|
||||
{
|
||||
char *line = NULL;
|
||||
DIR *class_hwmon_dir;
|
||||
struct dirent *class_hwmon_ent;
|
||||
char buf[PATH_MAX];
|
||||
const char *sysfs = sysfs__mountpoint();
|
||||
|
||||
if (!sysfs)
|
||||
return 0;
|
||||
|
||||
scnprintf(buf, sizeof(buf), "%s/class/hwmon/", sysfs);
|
||||
class_hwmon_dir = opendir(buf);
|
||||
if (!class_hwmon_dir)
|
||||
return 0;
|
||||
|
||||
while ((class_hwmon_ent = readdir(class_hwmon_dir)) != NULL) {
|
||||
size_t line_len;
|
||||
int hwmon_dir, name_fd;
|
||||
struct io io;
|
||||
|
||||
if (class_hwmon_ent->d_type != DT_LNK)
|
||||
continue;
|
||||
|
||||
scnprintf(buf, sizeof(buf), "%s/class/hwmon/%s", sysfs, class_hwmon_ent->d_name);
|
||||
hwmon_dir = open(buf, O_DIRECTORY);
|
||||
if (hwmon_dir == -1) {
|
||||
pr_debug("hwmon_pmu: not a directory: '%s/class/hwmon/%s'\n",
|
||||
sysfs, class_hwmon_ent->d_name);
|
||||
continue;
|
||||
}
|
||||
name_fd = openat(hwmon_dir, "name", O_RDONLY);
|
||||
if (name_fd == -1) {
|
||||
pr_debug("hwmon_pmu: failure to open '%s/class/hwmon/%s/name'\n",
|
||||
sysfs, class_hwmon_ent->d_name);
|
||||
close(hwmon_dir);
|
||||
continue;
|
||||
}
|
||||
io__init(&io, name_fd, buf, sizeof(buf));
|
||||
io__getline(&io, &line, &line_len);
|
||||
if (line_len > 0 && line[line_len - 1] == '\n')
|
||||
line[line_len - 1] = '\0';
|
||||
hwmon_pmu__new(pmus, hwmon_dir, class_hwmon_ent->d_name, line);
|
||||
close(name_fd);
|
||||
}
|
||||
free(line);
|
||||
closedir(class_hwmon_dir);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
|
||||
|
||||
int evsel__hwmon_pmu_open(struct evsel *evsel,
|
||||
struct perf_thread_map *threads,
|
||||
int start_cpu_map_idx, int end_cpu_map_idx)
|
||||
{
|
||||
struct hwmon_pmu *hwm = container_of(evsel->pmu, struct hwmon_pmu, pmu);
|
||||
union hwmon_pmu_event_key key = {
|
||||
.type_and_num = evsel->core.attr.config,
|
||||
};
|
||||
int idx = 0, thread = 0, nthreads, err = 0;
|
||||
|
||||
nthreads = perf_thread_map__nr(threads);
|
||||
for (idx = start_cpu_map_idx; idx < end_cpu_map_idx; idx++) {
|
||||
for (thread = 0; thread < nthreads; thread++) {
|
||||
char buf[64];
|
||||
int fd;
|
||||
|
||||
snprintf(buf, sizeof(buf), "%s%d_input",
|
||||
hwmon_type_strs[key.type], key.num);
|
||||
|
||||
fd = openat(hwm->hwmon_dir_fd, buf, O_RDONLY);
|
||||
FD(evsel, idx, thread) = fd;
|
||||
if (fd < 0) {
|
||||
err = -errno;
|
||||
goto out_close;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
out_close:
|
||||
if (err)
|
||||
threads->err_thread = thread;
|
||||
|
||||
do {
|
||||
while (--thread >= 0) {
|
||||
if (FD(evsel, idx, thread) >= 0)
|
||||
close(FD(evsel, idx, thread));
|
||||
FD(evsel, idx, thread) = -1;
|
||||
}
|
||||
thread = nthreads;
|
||||
} while (--idx >= 0);
|
||||
return err;
|
||||
}
|
||||
|
||||
int evsel__hwmon_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread)
|
||||
{
|
||||
char buf[32];
|
||||
int fd;
|
||||
ssize_t len;
|
||||
struct perf_counts_values *count, *old_count = NULL;
|
||||
|
||||
if (evsel->prev_raw_counts)
|
||||
old_count = perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread);
|
||||
|
||||
count = perf_counts(evsel->counts, cpu_map_idx, thread);
|
||||
fd = FD(evsel, cpu_map_idx, thread);
|
||||
len = pread(fd, buf, sizeof(buf), 0);
|
||||
if (len <= 0) {
|
||||
count->lost++;
|
||||
return -EINVAL;
|
||||
}
|
||||
buf[len] = '\0';
|
||||
if (old_count) {
|
||||
count->val = old_count->val + strtoll(buf, NULL, 10);
|
||||
count->run = old_count->run + 1;
|
||||
count->ena = old_count->ena + 1;
|
||||
} else {
|
||||
count->val = strtoll(buf, NULL, 10);
|
||||
count->run++;
|
||||
count->ena++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2,8 +2,12 @@
|
||||
#ifndef __HWMON_PMU_H
|
||||
#define __HWMON_PMU_H
|
||||
|
||||
#include "pmu.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
struct list_head;
|
||||
struct perf_thread_map;
|
||||
|
||||
/**
|
||||
* enum hwmon_type:
|
||||
*
|
||||
@ -87,6 +91,9 @@ enum hwmon_item {
|
||||
HWMON_ITEM__MAX,
|
||||
};
|
||||
|
||||
bool perf_pmu__is_hwmon(const struct perf_pmu *pmu);
|
||||
bool evsel__is_hwmon(const struct evsel *evsel);
|
||||
|
||||
/**
|
||||
* parse_hwmon_filename() - Parse filename into constituent parts.
|
||||
*
|
||||
@ -108,4 +115,37 @@ bool parse_hwmon_filename(const char *filename,
|
||||
enum hwmon_item *item,
|
||||
bool *alarm);
|
||||
|
||||
/**
|
||||
* hwmon_pmu__new() - Allocate and construct a hwmon PMU.
|
||||
*
|
||||
* @pmus: The list of PMUs to be added to.
|
||||
* @hwmon_dir: An O_DIRECTORY file descriptor for a hwmon directory.
|
||||
* @sysfs_name: Name of the hwmon sysfs directory like hwmon0.
|
||||
* @name: The contents of the "name" file in the hwmon directory.
|
||||
*
|
||||
* Exposed for testing. Regular construction should happen via
|
||||
* perf_pmus__read_hwmon_pmus.
|
||||
*/
|
||||
struct perf_pmu *hwmon_pmu__new(struct list_head *pmus, int hwmon_dir,
|
||||
const char *sysfs_name, const char *name);
|
||||
void hwmon_pmu__exit(struct perf_pmu *pmu);
|
||||
|
||||
int hwmon_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb);
|
||||
size_t hwmon_pmu__num_events(struct perf_pmu *pmu);
|
||||
bool hwmon_pmu__have_event(struct perf_pmu *pmu, const char *name);
|
||||
int hwmon_pmu__config_terms(const struct perf_pmu *pmu,
|
||||
struct perf_event_attr *attr,
|
||||
struct parse_events_terms *terms,
|
||||
struct parse_events_error *err);
|
||||
int hwmon_pmu__check_alias(struct parse_events_terms *terms, struct perf_pmu_info *info,
|
||||
struct parse_events_error *err);
|
||||
|
||||
int perf_pmus__read_hwmon_pmus(struct list_head *pmus);
|
||||
|
||||
|
||||
int evsel__hwmon_pmu_open(struct evsel *evsel,
|
||||
struct perf_thread_map *threads,
|
||||
int start_cpu_map_idx, int end_cpu_map_idx);
|
||||
int evsel__hwmon_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread);
|
||||
|
||||
#endif /* __HWMON_PMU_H */
|
||||
|
||||
@ -37,6 +37,8 @@ struct perf_pmu_caps {
|
||||
};
|
||||
|
||||
enum {
|
||||
PERF_PMU_TYPE_HWMON_START = 0xFFFF0000,
|
||||
PERF_PMU_TYPE_HWMON_END = 0xFFFFFFFD,
|
||||
PERF_PMU_TYPE_TOOL = 0xFFFFFFFE,
|
||||
PERF_PMU_TYPE_FAKE = 0xFFFFFFFF,
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user