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