From nobody Sun Nov 24 01:43:30 2024
Received: from mail-yb1-f201.google.com (mail-yb1-f201.google.com
 [209.85.219.201])
	(using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits))
	(No client certificate requested)
	by smtp.subspace.kernel.org (Postfix) with ESMTPS id B5EC345026
	for <linux-kernel@vger.kernel.org>; Sat,  9 Nov 2024 00:38:13 +0000 (UTC)
Authentication-Results: smtp.subspace.kernel.org;
 arc=none smtp.client-ip=209.85.219.201
ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116;
	t=1731112696; cv=none;
 b=L8plzlOHGSRFySfhnvaqoGPd3woYI8tPlfRImbm41DQvEvStxj9vNxyDFqL8uqfA6qxv8O1FBVTABgAEBeQmec3Jv2SsFYpAHeVyEZGGPv3VoGSryA+FcIGTjoeqR9vJ6IhOdXt83ricHRLpxa8WBqv6QCdjXPtbiFD4mZPZ4tw=
ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org;
	s=arc-20240116; t=1731112696; c=relaxed/simple;
	bh=DF29HfLYk4APYNM6PN4eXxEzIMhUOA5QnWG8bu4TeS8=;
	h=Date:In-Reply-To:Message-Id:Mime-Version:References:Subject:From:
	 To:Content-Type;
 b=Dt7eW5RQbfWldg+HTil+Ic1a64l1IzmSvVJeLzVVleye853t07nTc6S8K8i8H7FEn6AkYNTTgC4RPtD+UX2qOKg68a0ExyMU78r7tovs6WBjMJ1r9XGWyoeOMMqY6vQ473tdB1ODN7CYUxNmEyppRGoSYhmjU6LdIFkWuk7cpRU=
ARC-Authentication-Results: i=1; smtp.subspace.kernel.org;
 dmarc=pass (p=reject dis=none) header.from=google.com;
 spf=pass smtp.mailfrom=flex--irogers.bounces.google.com;
 dkim=pass (2048-bit key) header.d=google.com header.i=@google.com
 header.b=fKNKFPB8; arc=none smtp.client-ip=209.85.219.201
Authentication-Results: smtp.subspace.kernel.org;
 dmarc=pass (p=reject dis=none) header.from=google.com
Authentication-Results: smtp.subspace.kernel.org;
 spf=pass smtp.mailfrom=flex--irogers.bounces.google.com
Authentication-Results: smtp.subspace.kernel.org;
	dkim=pass (2048-bit key) header.d=google.com header.i=@google.com
 header.b="fKNKFPB8"
Received: by mail-yb1-f201.google.com with SMTP id
 3f1490d57ef6-e30c7a38bd7so2931957276.0
        for <linux-kernel@vger.kernel.org>;
 Fri, 08 Nov 2024 16:38:13 -0800 (PST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=google.com; s=20230601; t=1731112693; x=1731717493;
 darn=vger.kernel.org;
        h=to:from:subject:references:mime-version:message-id:in-reply-to:date
         :from:to:cc:subject:date:message-id:reply-to;
        bh=SKmPEjnoDqQNPKBI5I5F9OwiMicG8/7OcYSqdoUQCi4=;
        b=fKNKFPB8EDkKmg2iewVHGKzkkNdWzGZH6hU8fnTn8slyvgXkUmaRs7/QVHP/1jU62t
         KPLXTShv5UoBT6IQw2Qk991QxvdMB3w6FSdk+u1t+LrR6eBt4FoNJCUbexttrVEbYPYS
         e5b8CZLH6flKDgHQYe4+yzpbf/mhyX9uBcjq2Y9sFyCUdeOSC1QI2fauvQjMqINDN/+5
         WMtGF2P9T1/32EVIthhVK8f0kL8LeHkosP0nYOtEyMvC8Gx//lf7Az8ozy+nD5BA4KEC
         MljbnsI9DL/gPWASH298G86sXpszCCoM2YKk407wkGF5bn5tHbDAWSGtx6uyLZ+8lt6Z
         hqCQ==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20230601; t=1731112693; x=1731717493;
        h=to:from:subject:references:mime-version:message-id:in-reply-to:date
         :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to;
        bh=SKmPEjnoDqQNPKBI5I5F9OwiMicG8/7OcYSqdoUQCi4=;
        b=ofuJescJm7RDXNcWP66ZCBlz1+jfGoOvf0zNWmB4jb0BVST0aehepYMz+QSs9hDJmq
         1zyLcqxl/TCQeSDssvvHbg3Gy4N5d1tmprcT7XidC0T1MLuqc3ize6FhT2gt0zTu3Ryw
         eLx3Oua0MbLEdZejSRrYN6JV6HgNbrT2ooJ2D0hGiVfyX5ikXT8dJdnvX40OT/evuqI+
         weLAvVPhM9pAZcIbOrSrbB0DhEcrPS37bUF8ckAPOpQAZ1AF6ra4xSnDSwuw5hzXbbEP
         YBVezHFSL+txeAdrzrkQSm0U96Eln1KJk9yBPSYX57hHrtajZQvRWN5rCTVjd3IhX3n1
         DzGw==
X-Forwarded-Encrypted: i=1;
 AJvYcCXiQJuca0a1uLQAb7ueoJD4IotyjMdHA1+sB/8ETMM1GUfk6BtvIIZBWGr4YMMjolfHcPTpoMWmTcANQE4=@vger.kernel.org
X-Gm-Message-State: AOJu0Ywet2Ze3O1pKEycNC924ocSnZVlGmjXMamyPry5o3/jCIrE0aLC
	x/b7M6R/67GKoVxr/r4VBMJo/RCtcly/ApABM0AdexF8ehiDztYBaWw9DWr9vlLkS0zWwSj7TRq
	MHSCrcg==
X-Google-Smtp-Source: 
 AGHT+IGe6YYvSbH6XvUIdzf+Ra5PiGVW6RreBKcUNdPP8Dc0zQ0s5ZXhqQ6LJjzjtbfcSUav8fTAmyhjdaWF
X-Received: from irogers.svl.corp.google.com
 ([2620:15c:2c5:11:6fd2:1e36:6d8c:7c49])
 (user=irogers job=sendgmr) by 2002:a5b:ad0:0:b0:e2e:2c2e:277b with SMTP id
 3f1490d57ef6-e337e18eb4fmr24771276.3.1731112692958; Fri, 08 Nov 2024 16:38:12
 -0800 (PST)
Date: Fri,  8 Nov 2024 16:37:56 -0800
In-Reply-To: <20241109003759.473460-1-irogers@google.com>
Message-Id: <20241109003759.473460-5-irogers@google.com>
Precedence: bulk
X-Mailing-List: linux-kernel@vger.kernel.org
List-Id: <linux-kernel.vger.kernel.org>
List-Subscribe: <mailto:linux-kernel+subscribe@vger.kernel.org>
List-Unsubscribe: <mailto:linux-kernel+unsubscribe@vger.kernel.org>
Mime-Version: 1.0
References: <20241109003759.473460-1-irogers@google.com>
X-Mailer: git-send-email 2.47.0.277.g8800431eea-goog
Subject: [PATCH v9 4/7] perf hwmon_pmu: Add a tool PMU exposing events from
 hwmon in sysfs
From: Ian Rogers <irogers@google.com>
To: Peter Zijlstra <peterz@infradead.org>, Ingo Molnar <mingo@redhat.com>,
	Arnaldo Carvalho de Melo <acme@kernel.org>,
 Namhyung Kim <namhyung@kernel.org>,
	Mark Rutland <mark.rutland@arm.com>,
	Alexander Shishkin <alexander.shishkin@linux.intel.com>,
 Jiri Olsa <jolsa@kernel.org>,
	Ian Rogers <irogers@google.com>, Adrian Hunter <adrian.hunter@intel.com>,
	Kan Liang <kan.liang@linux.intel.com>, Ravi Bangoria <ravi.bangoria@amd.com>,
	Weilin Wang <weilin.wang@intel.com>,
 Yoshihiro Furudera <fj5100bi@fujitsu.com>,
	James Clark <james.clark@linaro.org>,
 Athira Jajeev <atrajeev@linux.vnet.ibm.com>,
	Howard Chu <howardchu95@gmail.com>, Oliver Upton <oliver.upton@linux.dev>,
	Changbin Du <changbin.du@huawei.com>, Ze Gao <zegao2021@gmail.com>,
	Junhao He <hejunhao3@huawei.com>, linux-kernel@vger.kernel.org,
	linux-perf-users@vger.kernel.org
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset="utf-8"

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=3D100'C,max=3D100'C=
 crit_alarm=3D0'C. Unit:
        hwmon_coretemp]
  temp_core_1 OR temp3
       [Temperature in unit coretemp named Core 1. crit=3D100'C,max=3D100'C=
 crit_alarm=3D0'C. Unit:
        hwmon_coretemp]
...
  temp_package_id_0 OR temp1
       [Temperature in unit coretemp named Package id 0. crit=3D100'C,max=
=3D100'C crit_alarm=3D0'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=3D0'C,crit=3D86.85'=
C,max=3D75.85'C,
        min=3D-273.15'C. Unit: hwmon_nvme]
  temp_sensor_1 OR temp2
       [Temperature in unit nvme named Sensor 1. max=3D65261.8'C,min=3D-273=
.15'C. Unit: hwmon_nvme]
  temp_sensor_2 OR temp3
       [Temperature in unit nvme named Sensor 2. max=3D65261.8'C,min=3D-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=3D1.5A. =
Unit:
        hwmon_ucsi_source_psy_usbc000_0]
  in0
       [Voltage in unit ucsi_source_psy_usbc000_0 named in0. max=3D5V,min=
=3D5V. 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>
---
 tools/perf/util/hwmon_pmu.c | 682 ++++++++++++++++++++++++++++++++++++
 tools/perf/util/hwmon_pmu.h |  40 +++
 tools/perf/util/pmu.h       |   2 +
 3 files changed, 724 insertions(+)

diff --git a/tools/perf/util/hwmon_pmu.c b/tools/perf/util/hwmon_pmu.c
index 8791e55097dc..89acc19347c8 100644
--- a/tools/perf/util/hwmon_pmu.c
+++ b/tools/perf/util/hwmon_pmu.c
@@ -1,11 +1,25 @@
 // 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/zalloc.h>
=20
 /** Strings that correspond to enum hwmon_type. */
 static const char * const hwmon_type_strs[HWMON_TYPE_MAX] =3D {
@@ -72,6 +86,79 @@ static const char * const hwmon_item_strs[HWMON_ITEM__MA=
X] =3D {
 };
 #define LONGEST_HWMON_ITEM_STR "average_interval_max"
=20
+static const char *const hwmon_units[HWMON_TYPE_MAX] =3D {
+	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 >=3D PERF_PMU_TYPE_HWMON_START &&
+		pmu->type <=3D 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_un=
used)
+{
+	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 =3D=3D
+	       ((union hwmon_pmu_event_key)key2).type_and_num;
+}
+
 static int hwmon_strcmp(const void *a, const void *b)
 {
 	const char *sa =3D a;
@@ -142,3 +229,598 @@ bool parse_hwmon_filename(const char *filename,
 	*item =3D elem - &hwmon_item_strs[0];
 	return true;
 }
+
+static void fix_name(char *p)
+{
+	char *s =3D strchr(p, '\n');
+
+	if (s)
+		*s =3D '\0';
+
+	while (*p !=3D '\0') {
+		if (strchr(" :,/\n\t", *p))
+			*p =3D '_';
+		else
+			*p =3D tolower(*p);
+		p++;
+	}
+}
+
+static int hwmon_pmu__read_events(struct hwmon_pmu *pmu)
+{
+	DIR *dir;
+	struct dirent *ent;
+	int dup_fd, err =3D 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 =3D dup(pmu->hwmon_dir_fd);
+	if (dup_fd =3D=3D -1)
+		return -ENOMEM;
+
+	dir =3D fdopendir(dup_fd);
+	if (!dir) {
+		close(dup_fd);
+		return -ENOMEM;
+	}
+
+	while ((ent =3D readdir(dir)) !=3D NULL) {
+		enum hwmon_type type;
+		int number;
+		enum hwmon_item item;
+		bool alarm;
+		union hwmon_pmu_event_key key =3D {};
+		struct hwmon_pmu_event_value *value;
+
+		if (ent->d_type !=3D 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 =3D number;
+		key.type =3D type;
+		if (!hashmap__find(&pmu->events, key.type_and_num, &value)) {
+			value =3D zalloc(sizeof(*value));
+			if (!value) {
+				err =3D -ENOMEM;
+				goto err_out;
+			}
+			err =3D hashmap__add(&pmu->events, key.type_and_num, value);
+			if (err) {
+				free(value);
+				err =3D -ENOMEM;
+				goto err_out;
+			}
+		}
+		__set_bit(item, alarm ? value->alarm_items : value->items);
+		if (item =3D=3D HWMON_ITEM_LABEL) {
+			char buf[128];
+			int fd =3D openat(pmu->hwmon_dir_fd, ent->d_name, O_RDONLY);
+			ssize_t read_len;
+
+			if (fd < 0)
+				continue;
+
+			read_len =3D read(fd, buf, sizeof(buf));
+
+			while (read_len > 0 && buf[read_len - 1] =3D=3D '\n')
+				read_len--;
+
+			if (read_len > 0)
+				buf[read_len] =3D '\0';
+
+			if (buf[0] =3D=3D '\0') {
+				pr_debug("hwmon_pmu: empty label file %s %s\n",
+					 pmu->pmu.name, ent->d_name);
+				close(fd);
+				continue;
+			}
+			value->label =3D 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 =3D 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 =3D {
+			.type_and_num =3D cur->key,
+		};
+		struct hwmon_pmu_event_value *value =3D 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 =3D true;
+
+err_out:
+	closedir(dir);
+	return err;
+}
+
+struct perf_pmu *hwmon_pmu__new(struct list_head *pmus, int hwmon_dir, con=
st char *sysfs_name, const char *name)
+{
+	char buf[32];
+	struct hwmon_pmu *hwm;
+
+	hwm =3D zalloc(sizeof(*hwm));
+	if (!hwm)
+		return NULL;
+
+	hwm->hwmon_dir_fd =3D hwmon_dir;
+	hwm->pmu.type =3D PERF_PMU_TYPE_HWMON_START + strtoul(sysfs_name + 5, NUL=
L, 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 =3D strdup(buf);
+	if (!hwm->pmu.name)
+		goto err_out;
+	hwm->pmu.alias_name =3D strdup(sysfs_name);
+	if (!hwm->pmu.alias_name)
+		goto err_out;
+	hwm->pmu.cpus =3D 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=3D*/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 =3D 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 =3D 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_b=
uf, 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 =3D 0;
+
+	for_each_set_bit(bit, items, HWMON_ITEM__MAX) {
+		int fd;
+
+		if (bit =3D=3D HWMON_ITEM_LABEL || bit =3D=3D 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 =3D openat(hwm->hwmon_dir_fd, buf, O_RDONLY);
+		if (fd > 0) {
+			ssize_t read_len =3D read(fd, buf, sizeof(buf));
+
+			while (read_len > 0 && buf[read_len - 1] =3D=3D '\n')
+				read_len--;
+
+			if (read_len > 0) {
+				long long val;
+
+				buf[read_len] =3D '\0';
+				val =3D strtoll(buf, /*endptr=3D*/NULL, 10);
+				len +=3D snprintf(out_buf + len, out_buf_len - len, "%s%s%s=3D%g%s",
+						len =3D=3D 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 =3D 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] =3D {
+			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] =3D {
+			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 =3D {
+			.type_and_num =3D cur->key,
+		};
+		struct hwmon_pmu_event_value *value =3D cur->pvalue;
+		struct pmu_event_info info =3D {
+			.pmu =3D pmu,
+			.name =3D value->name,
+			.alias =3D alias_buf,
+			.scale_unit =3D hwmon_scale_units[key.type],
+			.desc =3D desc_buf,
+			.long_desc =3D NULL,
+			.encoding_desc =3D encoding_buf,
+			.topic =3D "hwmon",
+			.pmu_name =3D pmu->name,
+			.event_type_desc =3D "Hwmon event",
+		};
+		int ret;
+		size_t len;
+
+		len =3D snprintf(alias_buf, sizeof(alias_buf), "%s%d",
+			       hwmon_type_strs[key.type], key.num);
+		if (!info.name) {
+			info.name =3D info.alias;
+			info.alias =3D NULL;
+		}
+
+		len =3D snprintf(desc_buf, sizeof(desc_buf), "%s in unit %s named %s.",
+			hwmon_desc[key.type],
+			pmu->name + 6,
+			value->label ?: info.name);
+
+		len +=3D hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf)=
 - len,
+						key, value->items, /*is_alarm=3D*/false);
+
+		len +=3D hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf)=
 - len,
+						key, value->alarm_items, /*is_alarm=3D*/true);
+
+		snprintf(encoding_buf, sizeof(encoding_buf), "%s/config=3D0x%lx/",
+			 pmu->name, cur->key);
+
+		ret =3D cb(state, &info);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
+size_t hwmon_pmu__num_events(struct perf_pmu *pmu)
+{
+	struct hwmon_pmu *hwm =3D 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 =3D container_of(pmu, struct hwmon_pmu, pmu);
+	enum hwmon_type type;
+	int number;
+	union hwmon_pmu_event_key key =3D {};
+	struct hashmap_entry *cur;
+	size_t bkt;
+
+	if (!parse_hwmon_filename(name, &type, &number, /*item=3D*/NULL, /*is_ala=
rm=3D*/NULL))
+		return false;
+
+	if (hwmon_pmu__read_events(hwm))
+		return false;
+
+	key.type =3D type;
+	key.num =3D number;
+	if (hashmap_find(&hwm->events, key.type_and_num, /*value=3D*/NULL))
+		return true;
+	if (key.num !=3D -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 =3D cur->pvalue;
+
+		key.type_and_num =3D cur->key;
+		if (key.type =3D=3D 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 =3D=3D PARSE_EVENTS__TERM_TYPE_USER) {
+		enum hwmon_type type;
+		int number;
+
+		if (parse_hwmon_filename(term->config, &type, &number,
+					 /*item=3D*/NULL, /*is_alarm=3D*/NULL)) {
+			if (number =3D=3D -1) {
+				/*
+				 * Item is of form <type>_ which means we should
+				 * match <type>_<label>.
+				 */
+				struct hashmap_entry *cur;
+				size_t bkt;
+
+				attr->config =3D 0;
+				hashmap__for_each_entry((&hwm->events), cur, bkt) {
+					union hwmon_pmu_event_key key =3D {
+						.type_and_num =3D cur->key,
+					};
+					struct hwmon_pmu_event_value *value =3D cur->pvalue;
+
+					if (key.type =3D=3D type && value->name &&
+					    !strcasecmp(term->config, value->name)) {
+						attr->config =3D key.type_and_num;
+						break;
+					}
+				}
+				if (attr->config =3D=3D 0)
+					return -EINVAL;
+			} else {
+				union hwmon_pmu_event_key key =3D {
+					.type =3D type,
+					.num =3D number,
+				};
+
+				attr->config =3D 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 =3D 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_p=
mu_info *info,
+			   struct parse_events_error *err)
+{
+	struct parse_events_term *term =3D
+		list_first_entry(&terms->terms, struct parse_events_term, list);
+
+	if (term->type_term =3D=3D PARSE_EVENTS__TERM_TYPE_USER) {
+		enum hwmon_type type;
+		int number;
+
+		if (parse_hwmon_filename(term->config, &type, &number,
+					 /*item=3D*/NULL, /*is_alarm=3D*/NULL)) {
+			info->unit =3D hwmon_units[type];
+			if (type =3D=3D HWMON_TYPE_FAN || type =3D=3D HWMON_TYPE_PWM ||
+			    type =3D=3D HWMON_TYPE_INTRUSION)
+				info->scale =3D 1;
+			else
+				info->scale =3D 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 =3D NULL;
+	DIR *class_hwmon_dir;
+	struct dirent *class_hwmon_ent;
+	char buf[PATH_MAX];
+	const char *sysfs =3D sysfs__mountpoint();
+
+	if (!sysfs)
+		return 0;
+
+	scnprintf(buf, sizeof(buf), "%s/class/hwmon/", sysfs);
+	class_hwmon_dir =3D opendir(buf);
+	if (!class_hwmon_dir)
+		return 0;
+
+	while ((class_hwmon_ent =3D readdir(class_hwmon_dir)) !=3D NULL) {
+		size_t line_len;
+		int hwmon_dir, name_fd;
+		struct io io;
+
+		if (class_hwmon_ent->d_type !=3D DT_LNK)
+			continue;
+
+		scnprintf(buf, sizeof(buf), "%s/class/hwmon/%s", sysfs, class_hwmon_ent-=
>d_name);
+		hwmon_dir =3D open(buf, O_DIRECTORY);
+		if (hwmon_dir =3D=3D -1) {
+			pr_debug("hwmon_pmu: not a directory: '%s/class/hwmon/%s'\n",
+				 sysfs, class_hwmon_ent->d_name);
+			continue;
+		}
+		name_fd =3D openat(hwmon_dir, "name", O_RDONLY);
+		if (name_fd =3D=3D -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] =3D=3D '\n')
+			line[line_len - 1] =3D '\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 =3D container_of(evsel->pmu, struct hwmon_pmu, pmu);
+	union hwmon_pmu_event_key key =3D {
+		.type_and_num =3D evsel->core.attr.config,
+	};
+	int idx =3D 0, thread =3D 0, nthreads, err =3D 0;
+
+	nthreads =3D perf_thread_map__nr(threads);
+	for (idx =3D start_cpu_map_idx; idx < end_cpu_map_idx; idx++) {
+		for (thread =3D 0; thread < nthreads; thread++) {
+			char buf[64];
+			int fd;
+
+			snprintf(buf, sizeof(buf), "%s%d_input",
+				 hwmon_type_strs[key.type], key.num);
+
+			fd =3D openat(hwm->hwmon_dir_fd, buf, O_RDONLY);
+			FD(evsel, idx, thread) =3D fd;
+			if (fd < 0) {
+				err =3D -errno;
+				goto out_close;
+			}
+		}
+	}
+	return 0;
+out_close:
+	if (err)
+		threads->err_thread =3D thread;
+
+	do {
+		while (--thread >=3D 0) {
+			if (FD(evsel, idx, thread) >=3D 0)
+				close(FD(evsel, idx, thread));
+			FD(evsel, idx, thread) =3D -1;
+		}
+		thread =3D nthreads;
+	} while (--idx >=3D 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 =3D NULL;
+
+	if (evsel->prev_raw_counts)
+		old_count =3D perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread);
+
+	count =3D perf_counts(evsel->counts, cpu_map_idx, thread);
+	fd =3D FD(evsel, cpu_map_idx, thread);
+	len =3D pread(fd, buf, sizeof(buf), 0);
+	if (len <=3D 0) {
+		count->lost++;
+		return -EINVAL;
+	}
+	buf[len] =3D '\0';
+	if (old_count) {
+		count->val =3D old_count->val + strtoll(buf, NULL, 10);
+		count->run =3D old_count->run + 1;
+		count->ena =3D old_count->ena + 1;
+	} else {
+		count->val =3D strtoll(buf, NULL, 10);
+		count->run++;
+		count->ena++;
+	}
+	return 0;
+}
diff --git a/tools/perf/util/hwmon_pmu.h b/tools/perf/util/hwmon_pmu.h
index df0ab5ff7534..882566846df4 100644
--- a/tools/perf/util/hwmon_pmu.h
+++ b/tools/perf/util/hwmon_pmu.h
@@ -2,8 +2,12 @@
 #ifndef __HWMON_PMU_H
 #define __HWMON_PMU_H
=20
+#include "pmu.h"
 #include <stdbool.h>
=20
+struct list_head;
+struct perf_thread_map;
+
 /**
  * enum hwmon_type:
  *
@@ -87,6 +91,9 @@ enum hwmon_item {
 	HWMON_ITEM__MAX,
 };
=20
+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);
=20
+/**
+ * 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_p=
mu_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 */
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index b86b3c3685a2..d511bf7cc9d0 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -37,6 +37,8 @@ struct perf_pmu_caps {
 };
=20
 enum {
+	PERF_PMU_TYPE_HWMON_START =3D 0xFFFF0000,
+	PERF_PMU_TYPE_HWMON_END   =3D 0xFFFFFFFD,
 	PERF_PMU_TYPE_TOOL =3D 0xFFFFFFFE,
 	PERF_PMU_TYPE_FAKE =3D 0xFFFFFFFF,
 };
--=20
2.47.0.277.g8800431eea-goog