// 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 <fcntl.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <api/fs/fs.h>
#include <api/io.h>
#include <api/io_dir.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] = {
        NULL,
        "cpu",
        "curr",
        "energy",
        "fan",
        "humidity",
        "in",
        "intrusion",
        "power",
        "pwm",
        "temp",
};
#define LONGEST_HWMON_TYPE_STR "intrusion"

/** Strings that correspond to enum hwmon_item. */
static const char * const hwmon_item_strs[HWMON_ITEM__MAX] = {
        NULL,
        "accuracy",
        "alarm",
        "auto_channels_temp",
        "average",
        "average_highest",
        "average_interval",
        "average_interval_max",
        "average_interval_min",
        "average_lowest",
        "average_max",
        "average_min",
        "beep",
        "cap",
        "cap_hyst",
        "cap_max",
        "cap_min",
        "crit",
        "crit_hyst",
        "div",
        "emergency",
        "emergency_hist",
        "enable",
        "fault",
        "freq",
        "highest",
        "input",
        "label",
        "lcrit",
        "lcrit_hyst",
        "lowest",
        "max",
        "max_hyst",
        "min",
        "min_hyst",
        "mod",
        "offset",
        "pulses",
        "rated_max",
        "rated_min",
        "reset_history",
        "target",
        "type",
        "vid",
};
#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;
        char *hwmon_dir;
};

/**
 * 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;
        const char * const *sb = b;

        return strcmp(sa, *sb);
}

bool parse_hwmon_filename(const char *filename,
                          enum hwmon_type *type,
                          int *number,
                          enum hwmon_item *item,
                          bool *alarm)
{
        char fn_type[24];
        const char * const *elem;
        const char *fn_item = NULL;
        size_t fn_item_len;

        assert(strlen(LONGEST_HWMON_TYPE_STR) < sizeof(fn_type));
        strlcpy(fn_type, filename, sizeof(fn_type));
        for (size_t i = 0; fn_type[i] != '\0'; i++) {
                if (fn_type[i] >= '0' && fn_type[i] <= '9') {
                        fn_type[i] = '\0';
                        *number = strtoul(&filename[i], (char **)&fn_item, 10);
                        if (*fn_item == '_')
                                fn_item++;
                        break;
                }
                if (fn_type[i] == '_') {
                        fn_type[i] = '\0';
                        *number = -1;
                        fn_item = &filename[i + 1];
                        break;
                }
        }
        if (fn_item == NULL || fn_type[0] == '\0' || (item != NULL && fn_item[0] == '\0')) {
                pr_debug3("hwmon_pmu: not a hwmon file '%s'\n", filename);
                return false;
        }
        elem = bsearch(&fn_type, hwmon_type_strs + 1, ARRAY_SIZE(hwmon_type_strs) - 1,
                       sizeof(hwmon_type_strs[0]), hwmon_strcmp);
        if (!elem) {
                pr_debug3("hwmon_pmu: not a hwmon type '%s' in file name '%s'\n",
                         fn_type, filename);
                return false;
        }

        *type = elem - &hwmon_type_strs[0];
        if (!item)
                return true;

        *alarm = false;
        fn_item_len = strlen(fn_item);
        if (fn_item_len > 6 && !strcmp(&fn_item[fn_item_len - 6], "_alarm")) {
                assert(strlen(LONGEST_HWMON_ITEM_STR) < sizeof(fn_type));
                strlcpy(fn_type, fn_item, fn_item_len - 5);
                fn_item = fn_type;
                *alarm = true;
        }
        elem = bsearch(fn_item, hwmon_item_strs + 1, ARRAY_SIZE(hwmon_item_strs) - 1,
                       sizeof(hwmon_item_strs[0]), hwmon_strcmp);
        if (!elem) {
                pr_debug3("hwmon_pmu: not a hwmon item '%s' in file name '%s'\n",
                         fn_item, filename);
                return false;
        }
        *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)
{
        int err = 0;
        struct hashmap_entry *cur, *tmp;
        size_t bkt;
        struct io_dirent64 *ent;
        struct io_dir dir;

        if (pmu->pmu.sysfs_aliases_loaded)
                return 0;

        /* Use openat so that the directory contents are refreshed. */
        io_dir__init(&dir, open(pmu->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY));

        if (dir.dirfd < 0)
                return -ENOENT;

        while ((ent = io_dir__readdir(&dir)) != NULL) {
                enum hwmon_type type;
                int number;
                enum hwmon_item item;
                bool alarm;
                union hwmon_pmu_event_key key = { .type_and_num = 0 };
                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_debug3("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(dir.dirfd, 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);
                }
        }
        if (hashmap__size(&pmu->events) == 0)
                pr_debug2("hwmon_pmu: %s has no events\n", pmu->pmu.name);

        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: %s removing event '%s%d' that has no input file\n",
                                pmu->pmu.name, 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:
        close(dir.dirfd);
        return err;
}

struct perf_pmu *hwmon_pmu__new(struct list_head *pmus, const char *hwmon_dir,
                                const char *sysfs_name, const char *name)
{
        char buf[64];
        struct hwmon_pmu *hwm;
        __u32 type = PERF_PMU_TYPE_HWMON_START + strtoul(sysfs_name + 5, NULL, 10);

        if (type > PERF_PMU_TYPE_HWMON_END) {
                pr_err("Unable to encode hwmon type from %s in valid PMU type\n", sysfs_name);
                return NULL;
        }

        snprintf(buf, sizeof(buf), "hwmon_%s", name);
        fix_name(buf + 6);

        hwm = zalloc(sizeof(*hwm));
        if (!hwm)
                return NULL;

        if (perf_pmu__init(&hwm->pmu, type, buf) != 0) {
                perf_pmu__delete(&hwm->pmu);
                return NULL;
        }

        hwm->hwmon_dir = strdup(hwmon_dir);
        if (!hwm->hwmon_dir) {
                perf_pmu__delete(&hwm->pmu);
                return NULL;
        }
        hwm->pmu.alias_name = strdup(sysfs_name);
        if (!hwm->pmu.alias_name) {
                perf_pmu__delete(&hwm->pmu);
                return NULL;
        }
        hwm->pmu.cpus = perf_cpu_map__new_int(0);
        if (!hwm->pmu.cpus) {
                perf_pmu__delete(&hwm->pmu);
                return NULL;
        }
        INIT_LIST_HEAD(&hwm->pmu.format);
        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;
}

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);
        zfree(&hwm->hwmon_dir);
}

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;
        int dir = open(hwm->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY);

        if (dir < 0)
                return 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(dir, 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);
                }
        }
        close(dir);
        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 = { .type_and_num = 0 };
        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_and_num = 0,
                                };

                                key.type = type;
                                key.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)
{
        struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
        struct parse_events_term *term;
        int ret;

        ret = hwmon_pmu__read_events(hwm);
        if (ret)
                return ret;

        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;
        struct io_dirent64 *class_hwmon_ent;
        struct io_dir class_hwmon_dir;
        char buf[PATH_MAX];
        const char *sysfs = sysfs__mountpoint();

        if (!sysfs)
                return 0;

        scnprintf(buf, sizeof(buf), "%s/class/hwmon/", sysfs);
        io_dir__init(&class_hwmon_dir, open(buf, O_CLOEXEC | O_DIRECTORY | O_RDONLY));

        if (class_hwmon_dir.dirfd < 0)
                return 0;

        while ((class_hwmon_ent = io_dir__readdir(&class_hwmon_dir)) != NULL) {
                size_t line_len;
                int hwmon_dir, name_fd;
                struct io io;
                char buf2[128];

                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, buf2, sizeof(buf2));
                if (io__getline(&io, &line, &line_len) > 0 && line[line_len - 1] == '\n')
                        line[line_len - 1] = '\0';
                hwmon_pmu__new(pmus, buf, class_hwmon_ent->d_name, line);
                close(name_fd);
                close(hwmon_dir);
        }
        free(line);
        close(class_hwmon_dir.dirfd);
        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;
        int dir = open(hwm->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY);

        if (dir < 0)
                return -errno;

        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(dir, buf, O_RDONLY);
                        FD(evsel, idx, thread) = fd;
                        if (fd < 0) {
                                err = -errno;
                                goto out_close;
                        }
                }
        }
        close(dir);
        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);
        close(dir);
        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;
}