hwmon_pmu.c

  1// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
  2#include "counts.h"
  3#include "debug.h"
  4#include "evsel.h"
  5#include "hashmap.h"
  6#include "hwmon_pmu.h"
  7#include "pmu.h"
  8#include <internal/xyarray.h>
  9#include <internal/threadmap.h>
 10#include <perf/threadmap.h>
 11#include <sys/types.h>
 12#include <assert.h>
 13#include <ctype.h>
 14#include <fcntl.h>
 15#include <stddef.h>
 16#include <stdlib.h>
 17#include <string.h>
 18#include <api/fs/fs.h>
 19#include <api/io.h>
 20#include <api/io_dir.h>
 21#include <linux/kernel.h>
 22#include <linux/string.h>
 23#include <linux/zalloc.h>
 24
 25/** Strings that correspond to enum hwmon_type. */
 26static const char * const hwmon_type_strs[HWMON_TYPE_MAX] = {
 27	NULL,
 28	"cpu",
 29	"curr",
 30	"energy",
 31	"fan",
 32	"humidity",
 33	"in",
 34	"intrusion",
 35	"power",
 36	"pwm",
 37	"temp",
 38};
 39#define LONGEST_HWMON_TYPE_STR "intrusion"
 40
 41/** Strings that correspond to enum hwmon_item. */
 42static const char * const hwmon_item_strs[HWMON_ITEM__MAX] = {
 43	NULL,
 44	"accuracy",
 45	"alarm",
 46	"auto_channels_temp",
 47	"average",
 48	"average_highest",
 49	"average_interval",
 50	"average_interval_max",
 51	"average_interval_min",
 52	"average_lowest",
 53	"average_max",
 54	"average_min",
 55	"beep",
 56	"cap",
 57	"cap_hyst",
 58	"cap_max",
 59	"cap_min",
 60	"crit",
 61	"crit_hyst",
 62	"div",
 63	"emergency",
 64	"emergency_hist",
 65	"enable",
 66	"fault",
 67	"freq",
 68	"highest",
 69	"input",
 70	"label",
 71	"lcrit",
 72	"lcrit_hyst",
 73	"lowest",
 74	"max",
 75	"max_hyst",
 76	"min",
 77	"min_hyst",
 78	"mod",
 79	"offset",
 80	"pulses",
 81	"rated_max",
 82	"rated_min",
 83	"reset_history",
 84	"target",
 85	"type",
 86	"vid",
 87};
 88#define LONGEST_HWMON_ITEM_STR "average_interval_max"
 89
 90static const char *const hwmon_units[HWMON_TYPE_MAX] = {
 91	NULL,
 92	"V",   /* cpu */
 93	"A",   /* curr */
 94	"J",   /* energy */
 95	"rpm", /* fan */
 96	"%",   /* humidity */
 97	"V",   /* in */
 98	"",    /* intrusion */
 99	"W",   /* power */
100	"Hz",  /* pwm */
101	"'C",  /* temp */
102};
103
104struct hwmon_pmu {
105	struct perf_pmu pmu;
106	struct hashmap events;
107	char *hwmon_dir;
108};
109
110/**
111 * struct hwmon_pmu_event_value: Value in hwmon_pmu->events.
112 *
113 * Hwmon files are of the form <type><number>_<item> and may have a suffix
114 * _alarm.
115 */
116struct hwmon_pmu_event_value {
117	/** @items: which item files are present. */
118	DECLARE_BITMAP(items, HWMON_ITEM__MAX);
119	/** @alarm_items: which item files are present. */
120	DECLARE_BITMAP(alarm_items, HWMON_ITEM__MAX);
121	/** @label: contents of <type><number>_label if present. */
122	char *label;
123	/** @name: name computed from label of the form <type>_<label>. */
124	char *name;
125};
126
127bool perf_pmu__is_hwmon(const struct perf_pmu *pmu)
128{
129	return pmu && pmu->type >= PERF_PMU_TYPE_HWMON_START &&
130		pmu->type <= PERF_PMU_TYPE_HWMON_END;
131}
132
133bool evsel__is_hwmon(const struct evsel *evsel)
134{
135	return perf_pmu__is_hwmon(evsel->pmu);
136}
137
138static size_t hwmon_pmu__event_hashmap_hash(long key, void *ctx __maybe_unused)
139{
140	return ((union hwmon_pmu_event_key)key).type_and_num;
141}
142
143static bool hwmon_pmu__event_hashmap_equal(long key1, long key2, void *ctx __maybe_unused)
144{
145	return ((union hwmon_pmu_event_key)key1).type_and_num ==
146	       ((union hwmon_pmu_event_key)key2).type_and_num;
147}
148
149static int hwmon_strcmp(const void *a, const void *b)
150{
151	const char *sa = a;
152	const char * const *sb = b;
153
154	return strcmp(sa, *sb);
155}
156
157bool parse_hwmon_filename(const char *filename,
158			  enum hwmon_type *type,
159			  int *number,
160			  enum hwmon_item *item,
161			  bool *alarm)
162{
163	char fn_type[24];
164	const char **elem;
165	const char *fn_item = NULL;
166	size_t fn_item_len;
167
168	assert(strlen(LONGEST_HWMON_TYPE_STR) < sizeof(fn_type));
169	strlcpy(fn_type, filename, sizeof(fn_type));
170	for (size_t i = 0; fn_type[i] != '\0'; i++) {
171		if (fn_type[i] >= '0' && fn_type[i] <= '9') {
172			fn_type[i] = '\0';
173			*number = strtoul(&filename[i], (char **)&fn_item, 10);
174			if (*fn_item == '_')
175				fn_item++;
176			break;
177		}
178		if (fn_type[i] == '_') {
179			fn_type[i] = '\0';
180			*number = -1;
181			fn_item = &filename[i + 1];
182			break;
183		}
184	}
185	if (fn_item == NULL || fn_type[0] == '\0' || (item != NULL && fn_item[0] == '\0')) {
186		pr_debug3("hwmon_pmu: not a hwmon file '%s'\n", filename);
187		return false;
188	}
189	elem = bsearch(&fn_type, hwmon_type_strs + 1, ARRAY_SIZE(hwmon_type_strs) - 1,
190		       sizeof(hwmon_type_strs[0]), hwmon_strcmp);
191	if (!elem) {
192		pr_debug3("hwmon_pmu: not a hwmon type '%s' in file name '%s'\n",
193			 fn_type, filename);
194		return false;
195	}
196
197	*type = elem - &hwmon_type_strs[0];
198	if (!item)
199		return true;
200
201	*alarm = false;
202	fn_item_len = strlen(fn_item);
203	if (fn_item_len > 6 && !strcmp(&fn_item[fn_item_len - 6], "_alarm")) {
204		assert(strlen(LONGEST_HWMON_ITEM_STR) < sizeof(fn_type));
205		strlcpy(fn_type, fn_item, fn_item_len - 5);
206		fn_item = fn_type;
207		*alarm = true;
208	}
209	elem = bsearch(fn_item, hwmon_item_strs + 1, ARRAY_SIZE(hwmon_item_strs) - 1,
210		       sizeof(hwmon_item_strs[0]), hwmon_strcmp);
211	if (!elem) {
212		pr_debug3("hwmon_pmu: not a hwmon item '%s' in file name '%s'\n",
213			 fn_item, filename);
214		return false;
215	}
216	*item = elem - &hwmon_item_strs[0];
217	return true;
218}
219
220static void fix_name(char *p)
221{
222	char *s = strchr(p, '\n');
223
224	if (s)
225		*s = '\0';
226
227	while (*p != '\0') {
228		if (strchr(" :,/\n\t", *p))
229			*p = '_';
230		else
231			*p = tolower(*p);
232		p++;
233	}
234}
235
236static int hwmon_pmu__read_events(struct hwmon_pmu *pmu)
237{
238	int err = 0;
239	struct hashmap_entry *cur, *tmp;
240	size_t bkt;
241	struct io_dirent64 *ent;
242	struct io_dir dir;
243
244	if (pmu->pmu.sysfs_aliases_loaded)
245		return 0;
246
247	/* Use openat so that the directory contents are refreshed. */
248	io_dir__init(&dir, open(pmu->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY));
249
250	if (dir.dirfd < 0)
251		return -ENOENT;
252
253	while ((ent = io_dir__readdir(&dir)) != NULL) {
254		enum hwmon_type type;
255		int number;
256		enum hwmon_item item;
257		bool alarm;
258		union hwmon_pmu_event_key key = { .type_and_num = 0 };
259		struct hwmon_pmu_event_value *value;
260
261		if (ent->d_type != DT_REG)
262			continue;
263
264		if (!parse_hwmon_filename(ent->d_name, &type, &number, &item, &alarm)) {
265			pr_debug3("Not a hwmon file '%s'\n", ent->d_name);
266			continue;
267		}
268		key.num = number;
269		key.type = type;
270		if (!hashmap__find(&pmu->events, key.type_and_num, &value)) {
271			value = zalloc(sizeof(*value));
272			if (!value) {
273				err = -ENOMEM;
274				goto err_out;
275			}
276			err = hashmap__add(&pmu->events, key.type_and_num, value);
277			if (err) {
278				free(value);
279				err = -ENOMEM;
280				goto err_out;
281			}
282		}
283		__set_bit(item, alarm ? value->alarm_items : value->items);
284		if (item == HWMON_ITEM_LABEL) {
285			char buf[128];
286			int fd = openat(dir.dirfd, ent->d_name, O_RDONLY);
287			ssize_t read_len;
288
289			if (fd < 0)
290				continue;
291
292			read_len = read(fd, buf, sizeof(buf));
293
294			while (read_len > 0 && buf[read_len - 1] == '\n')
295				read_len--;
296
297			if (read_len > 0)
298				buf[read_len] = '\0';
299
300			if (buf[0] == '\0') {
301				pr_debug("hwmon_pmu: empty label file %s %s\n",
302					 pmu->pmu.name, ent->d_name);
303				close(fd);
304				continue;
305			}
306			value->label = strdup(buf);
307			if (!value->label) {
308				pr_debug("hwmon_pmu: memory allocation failure\n");
309				close(fd);
310				continue;
311			}
312			snprintf(buf, sizeof(buf), "%s_%s", hwmon_type_strs[type], value->label);
313			fix_name(buf);
314			value->name = strdup(buf);
315			if (!value->name)
316				pr_debug("hwmon_pmu: memory allocation failure\n");
317			close(fd);
318		}
319	}
320	if (hashmap__size(&pmu->events) == 0)
321		pr_debug2("hwmon_pmu: %s has no events\n", pmu->pmu.name);
322
323	hashmap__for_each_entry_safe((&pmu->events), cur, tmp, bkt) {
324		union hwmon_pmu_event_key key = {
325			.type_and_num = cur->key,
326		};
327		struct hwmon_pmu_event_value *value = cur->pvalue;
328
329		if (!test_bit(HWMON_ITEM_INPUT, value->items)) {
330			pr_debug("hwmon_pmu: %s removing event '%s%d' that has no input file\n",
331				pmu->pmu.name, hwmon_type_strs[key.type], key.num);
332			hashmap__delete(&pmu->events, key.type_and_num, &key, &value);
333			zfree(&value->label);
334			zfree(&value->name);
335			free(value);
336		}
337	}
338	pmu->pmu.sysfs_aliases_loaded = true;
339
340err_out:
341	close(dir.dirfd);
342	return err;
343}
344
345struct perf_pmu *hwmon_pmu__new(struct list_head *pmus, const char *hwmon_dir,
346				const char *sysfs_name, const char *name)
347{
348	char buf[64];
349	struct hwmon_pmu *hwm;
350	__u32 type = PERF_PMU_TYPE_HWMON_START + strtoul(sysfs_name + 5, NULL, 10);
351
352	if (type > PERF_PMU_TYPE_HWMON_END) {
353		pr_err("Unable to encode hwmon type from %s in valid PMU type\n", sysfs_name);
354		return NULL;
355	}
356
357	snprintf(buf, sizeof(buf), "hwmon_%s", name);
358	fix_name(buf + 6);
359
360	hwm = zalloc(sizeof(*hwm));
361	if (!hwm)
362		return NULL;
363
364	if (perf_pmu__init(&hwm->pmu, type, buf) != 0) {
365		perf_pmu__delete(&hwm->pmu);
366		return NULL;
367	}
368
369	hwm->hwmon_dir = strdup(hwmon_dir);
370	if (!hwm->hwmon_dir) {
371		perf_pmu__delete(&hwm->pmu);
372		return NULL;
373	}
374	hwm->pmu.alias_name = strdup(sysfs_name);
375	if (!hwm->pmu.alias_name) {
376		perf_pmu__delete(&hwm->pmu);
377		return NULL;
378	}
379	hwm->pmu.cpus = perf_cpu_map__new_int(0);
380	if (!hwm->pmu.cpus) {
381		perf_pmu__delete(&hwm->pmu);
382		return NULL;
383	}
384	INIT_LIST_HEAD(&hwm->pmu.format);
385	INIT_LIST_HEAD(&hwm->pmu.caps);
386	hashmap__init(&hwm->events, hwmon_pmu__event_hashmap_hash,
387		      hwmon_pmu__event_hashmap_equal, /*ctx=*/NULL);
388
389	list_add_tail(&hwm->pmu.list, pmus);
390	return &hwm->pmu;
391}
392
393void hwmon_pmu__exit(struct perf_pmu *pmu)
394{
395	struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
396	struct hashmap_entry *cur, *tmp;
397	size_t bkt;
398
399	hashmap__for_each_entry_safe((&hwm->events), cur, tmp, bkt) {
400		struct hwmon_pmu_event_value *value = cur->pvalue;
401
402		zfree(&value->label);
403		zfree(&value->name);
404		free(value);
405	}
406	hashmap__clear(&hwm->events);
407	zfree(&hwm->hwmon_dir);
408}
409
410static size_t hwmon_pmu__describe_items(struct hwmon_pmu *hwm, char *out_buf, size_t out_buf_len,
411					union hwmon_pmu_event_key key,
412					const unsigned long *items, bool is_alarm)
413{
414	size_t bit;
415	char buf[64];
416	size_t len = 0;
417	int dir = open(hwm->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY);
418
419	if (dir < 0)
420		return 0;
421
422	for_each_set_bit(bit, items, HWMON_ITEM__MAX) {
423		int fd;
424
425		if (bit == HWMON_ITEM_LABEL || bit == HWMON_ITEM_INPUT)
426			continue;
427
428		snprintf(buf, sizeof(buf), "%s%d_%s%s",
429			hwmon_type_strs[key.type],
430			key.num,
431			hwmon_item_strs[bit],
432			is_alarm ? "_alarm" : "");
433		fd = openat(dir, buf, O_RDONLY);
434		if (fd > 0) {
435			ssize_t read_len = read(fd, buf, sizeof(buf));
436
437			while (read_len > 0 && buf[read_len - 1] == '\n')
438				read_len--;
439
440			if (read_len > 0) {
441				long long val;
442
443				buf[read_len] = '\0';
444				val = strtoll(buf, /*endptr=*/NULL, 10);
445				len += snprintf(out_buf + len, out_buf_len - len, "%s%s%s=%g%s",
446						len == 0 ? " " : ", ",
447						hwmon_item_strs[bit],
448						is_alarm ? "_alarm" : "",
449						(double)val / 1000.0,
450						hwmon_units[key.type]);
451			}
452			close(fd);
453		}
454	}
455	close(dir);
456	return len;
457}
458
459int hwmon_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb)
460{
461	struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
462	struct hashmap_entry *cur;
463	size_t bkt;
464
465	if (hwmon_pmu__read_events(hwm))
466		return false;
467
468	hashmap__for_each_entry((&hwm->events), cur, bkt) {
469		static const char *const hwmon_scale_units[HWMON_TYPE_MAX] = {
470			NULL,
471			"0.001V", /* cpu */
472			"0.001A", /* curr */
473			"0.001J", /* energy */
474			"1rpm",   /* fan */
475			"0.001%", /* humidity */
476			"0.001V", /* in */
477			NULL,     /* intrusion */
478			"0.001W", /* power */
479			"1Hz",    /* pwm */
480			"0.001'C", /* temp */
481		};
482		static const char *const hwmon_desc[HWMON_TYPE_MAX] = {
483			NULL,
484			"CPU core reference voltage",   /* cpu */
485			"Current",                      /* curr */
486			"Cumulative energy use",        /* energy */
487			"Fan",                          /* fan */
488			"Humidity",                     /* humidity */
489			"Voltage",                      /* in */
490			"Chassis intrusion detection",  /* intrusion */
491			"Power use",                    /* power */
492			"Pulse width modulation fan control", /* pwm */
493			"Temperature",                  /* temp */
494		};
495		char alias_buf[64];
496		char desc_buf[256];
497		char encoding_buf[128];
498		union hwmon_pmu_event_key key = {
499			.type_and_num = cur->key,
500		};
501		struct hwmon_pmu_event_value *value = cur->pvalue;
502		struct pmu_event_info info = {
503			.pmu = pmu,
504			.name = value->name,
505			.alias = alias_buf,
506			.scale_unit = hwmon_scale_units[key.type],
507			.desc = desc_buf,
508			.long_desc = NULL,
509			.encoding_desc = encoding_buf,
510			.topic = "hwmon",
511			.pmu_name = pmu->name,
512			.event_type_desc = "Hwmon event",
513		};
514		int ret;
515		size_t len;
516
517		len = snprintf(alias_buf, sizeof(alias_buf), "%s%d",
518			       hwmon_type_strs[key.type], key.num);
519		if (!info.name) {
520			info.name = info.alias;
521			info.alias = NULL;
522		}
523
524		len = snprintf(desc_buf, sizeof(desc_buf), "%s in unit %s named %s.",
525			hwmon_desc[key.type],
526			pmu->name + 6,
527			value->label ?: info.name);
528
529		len += hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf) - len,
530						key, value->items, /*is_alarm=*/false);
531
532		len += hwmon_pmu__describe_items(hwm, desc_buf + len, sizeof(desc_buf) - len,
533						key, value->alarm_items, /*is_alarm=*/true);
534
535		snprintf(encoding_buf, sizeof(encoding_buf), "%s/config=0x%lx/",
536			 pmu->name, cur->key);
537
538		ret = cb(state, &info);
539		if (ret)
540			return ret;
541	}
542	return 0;
543}
544
545size_t hwmon_pmu__num_events(struct perf_pmu *pmu)
546{
547	struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
548
549	hwmon_pmu__read_events(hwm);
550	return hashmap__size(&hwm->events);
551}
552
553bool hwmon_pmu__have_event(struct perf_pmu *pmu, const char *name)
554{
555	struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
556	enum hwmon_type type;
557	int number;
558	union hwmon_pmu_event_key key = { .type_and_num = 0 };
559	struct hashmap_entry *cur;
560	size_t bkt;
561
562	if (!parse_hwmon_filename(name, &type, &number, /*item=*/NULL, /*is_alarm=*/NULL))
563		return false;
564
565	if (hwmon_pmu__read_events(hwm))
566		return false;
567
568	key.type = type;
569	key.num = number;
570	if (hashmap_find(&hwm->events, key.type_and_num, /*value=*/NULL))
571		return true;
572	if (key.num != -1)
573		return false;
574	/* Item is of form <type>_ which means we should match <type>_<label>. */
575	hashmap__for_each_entry((&hwm->events), cur, bkt) {
576		struct hwmon_pmu_event_value *value = cur->pvalue;
577
578		key.type_and_num = cur->key;
579		if (key.type == type && value->name && !strcasecmp(name, value->name))
580			return true;
581	}
582	return false;
583}
584
585static int hwmon_pmu__config_term(const struct hwmon_pmu *hwm,
586				  struct perf_event_attr *attr,
587				  struct parse_events_term *term,
588				  struct parse_events_error *err)
589{
590	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
591		enum hwmon_type type;
592		int number;
593
594		if (parse_hwmon_filename(term->config, &type, &number,
595					 /*item=*/NULL, /*is_alarm=*/NULL)) {
596			if (number == -1) {
597				/*
598				 * Item is of form <type>_ which means we should
599				 * match <type>_<label>.
600				 */
601				struct hashmap_entry *cur;
602				size_t bkt;
603
604				attr->config = 0;
605				hashmap__for_each_entry((&hwm->events), cur, bkt) {
606					union hwmon_pmu_event_key key = {
607						.type_and_num = cur->key,
608					};
609					struct hwmon_pmu_event_value *value = cur->pvalue;
610
611					if (key.type == type && value->name &&
612					    !strcasecmp(term->config, value->name)) {
613						attr->config = key.type_and_num;
614						break;
615					}
616				}
617				if (attr->config == 0)
618					return -EINVAL;
619			} else {
620				union hwmon_pmu_event_key key = {
621					.type_and_num = 0,
622				};
623
624				key.type = type;
625				key.num = number;
626				attr->config = key.type_and_num;
627			}
628			return 0;
629		}
630	}
631	if (err) {
632		char *err_str;
633
634		parse_events_error__handle(err, term->err_val,
635					asprintf(&err_str,
636						"unexpected hwmon event term (%s) %s",
637						parse_events__term_type_str(term->type_term),
638						term->config) < 0
639					? strdup("unexpected hwmon event term")
640					: err_str,
641					NULL);
642	}
643	return -EINVAL;
644}
645
646int hwmon_pmu__config_terms(const struct perf_pmu *pmu,
647			    struct perf_event_attr *attr,
648			    struct parse_events_terms *terms,
649			    struct parse_events_error *err)
650{
651	struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);
652	struct parse_events_term *term;
653	int ret;
654
655	ret = hwmon_pmu__read_events(hwm);
656	if (ret)
657		return ret;
658
659	list_for_each_entry(term, &terms->terms, list) {
660		if (hwmon_pmu__config_term(hwm, attr, term, err))
661			return -EINVAL;
662	}
663
664	return 0;
665
666}
667
668int hwmon_pmu__check_alias(struct parse_events_terms *terms, struct perf_pmu_info *info,
669			   struct parse_events_error *err)
670{
671	struct parse_events_term *term =
672		list_first_entry(&terms->terms, struct parse_events_term, list);
673
674	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
675		enum hwmon_type type;
676		int number;
677
678		if (parse_hwmon_filename(term->config, &type, &number,
679					 /*item=*/NULL, /*is_alarm=*/NULL)) {
680			info->unit = hwmon_units[type];
681			if (type == HWMON_TYPE_FAN || type == HWMON_TYPE_PWM ||
682			    type == HWMON_TYPE_INTRUSION)
683				info->scale = 1;
684			else
685				info->scale = 0.001;
686		}
687		return 0;
688	}
689	if (err) {
690		char *err_str;
691
692		parse_events_error__handle(err, term->err_val,
693					asprintf(&err_str,
694						"unexpected hwmon event term (%s) %s",
695						parse_events__term_type_str(term->type_term),
696						term->config) < 0
697					? strdup("unexpected hwmon event term")
698					: err_str,
699					NULL);
700	}
701	return -EINVAL;
702}
703
704int perf_pmus__read_hwmon_pmus(struct list_head *pmus)
705{
706	char *line = NULL;
707	struct io_dirent64 *class_hwmon_ent;
708	struct io_dir class_hwmon_dir;
709	char buf[PATH_MAX];
710	const char *sysfs = sysfs__mountpoint();
711
712	if (!sysfs)
713		return 0;
714
715	scnprintf(buf, sizeof(buf), "%s/class/hwmon/", sysfs);
716	io_dir__init(&class_hwmon_dir, open(buf, O_CLOEXEC | O_DIRECTORY | O_RDONLY));
717
718	if (class_hwmon_dir.dirfd < 0)
719		return 0;
720
721	while ((class_hwmon_ent = io_dir__readdir(&class_hwmon_dir)) != NULL) {
722		size_t line_len;
723		int hwmon_dir, name_fd;
724		struct io io;
725		char buf2[128];
726
727		if (class_hwmon_ent->d_type != DT_LNK)
728			continue;
729
730		scnprintf(buf, sizeof(buf), "%s/class/hwmon/%s", sysfs, class_hwmon_ent->d_name);
731		hwmon_dir = open(buf, O_DIRECTORY);
732		if (hwmon_dir == -1) {
733			pr_debug("hwmon_pmu: not a directory: '%s/class/hwmon/%s'\n",
734				 sysfs, class_hwmon_ent->d_name);
735			continue;
736		}
737		name_fd = openat(hwmon_dir, "name", O_RDONLY);
738		if (name_fd == -1) {
739			pr_debug("hwmon_pmu: failure to open '%s/class/hwmon/%s/name'\n",
740				  sysfs, class_hwmon_ent->d_name);
741			close(hwmon_dir);
742			continue;
743		}
744		io__init(&io, name_fd, buf2, sizeof(buf2));
745		if (io__getline(&io, &line, &line_len) > 0 && line[line_len - 1] == '\n')
746			line[line_len - 1] = '\0';
747		hwmon_pmu__new(pmus, buf, class_hwmon_ent->d_name, line);
748		close(name_fd);
749		close(hwmon_dir);
750	}
751	free(line);
752	close(class_hwmon_dir.dirfd);
753	return 0;
754}
755
756#define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
757
758int evsel__hwmon_pmu_open(struct evsel *evsel,
759			  struct perf_thread_map *threads,
760			  int start_cpu_map_idx, int end_cpu_map_idx)
761{
762	struct hwmon_pmu *hwm = container_of(evsel->pmu, struct hwmon_pmu, pmu);
763	union hwmon_pmu_event_key key = {
764		.type_and_num = evsel->core.attr.config,
765	};
766	int idx = 0, thread = 0, nthreads, err = 0;
767	int dir = open(hwm->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY);
768
769	if (dir < 0)
770		return -errno;
771
772	nthreads = perf_thread_map__nr(threads);
773	for (idx = start_cpu_map_idx; idx < end_cpu_map_idx; idx++) {
774		for (thread = 0; thread < nthreads; thread++) {
775			char buf[64];
776			int fd;
777
778			snprintf(buf, sizeof(buf), "%s%d_input",
779				 hwmon_type_strs[key.type], key.num);
780
781			fd = openat(dir, buf, O_RDONLY);
782			FD(evsel, idx, thread) = fd;
783			if (fd < 0) {
784				err = -errno;
785				goto out_close;
786			}
787		}
788	}
789	close(dir);
790	return 0;
791out_close:
792	if (err)
793		threads->err_thread = thread;
794
795	do {
796		while (--thread >= 0) {
797			if (FD(evsel, idx, thread) >= 0)
798				close(FD(evsel, idx, thread));
799			FD(evsel, idx, thread) = -1;
800		}
801		thread = nthreads;
802	} while (--idx >= 0);
803	close(dir);
804	return err;
805}
806
807int evsel__hwmon_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread)
808{
809	char buf[32];
810	int fd;
811	ssize_t len;
812	struct perf_counts_values *count, *old_count = NULL;
813
814	if (evsel->prev_raw_counts)
815		old_count = perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread);
816
817	count = perf_counts(evsel->counts, cpu_map_idx, thread);
818	fd = FD(evsel, cpu_map_idx, thread);
819	len = pread(fd, buf, sizeof(buf), 0);
820	if (len <= 0) {
821		count->lost++;
822		return -EINVAL;
823	}
824	buf[len] = '\0';
825	if (old_count) {
826		count->val = old_count->val + strtoll(buf, NULL, 10);
827		count->run = old_count->run + 1;
828		count->ena = old_count->ena + 1;
829	} else {
830		count->val = strtoll(buf, NULL, 10);
831		count->run++;
832		count->ena++;
833	}
834	return 0;
835}