tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

perf pmu: Pass PMU rather than aliases and format

Pass the pmu so the aliases and format list can be better abstracted
and later lazily loaded.

Signed-off-by: Ian Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Gaosheng Cui <cuigaosheng1@huawei.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jing Zhang <renyu.zj@linux.alibaba.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Kajol Jain <kjain@linux.ibm.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Rob Herring <robh@kernel.org>
Link: https://lore.kernel.org/r/20230823080828.1460376-9-irogers@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

authored by

Ian Rogers and committed by
Arnaldo Carvalho de Melo 838a8c5f da6a5afd

+68 -71
+19 -28
tools/perf/tests/pmu-events.c
··· 496 496 return 0; 497 497 } 498 498 499 - static struct perf_pmu_alias *find_alias(const char *test_event, struct list_head *aliases) 500 - { 501 - struct perf_pmu_alias *alias; 502 - 503 - list_for_each_entry(alias, aliases, list) 504 - if (!strcmp(test_event, alias->name)) 505 - return alias; 506 - 507 - return NULL; 508 - } 509 - 510 499 /* Verify aliases are as expected */ 511 500 static int __test_core_pmu_event_aliases(char *pmu_name, int *count) 512 501 { 513 502 struct perf_pmu_test_event const **test_event_table; 514 503 struct perf_pmu *pmu; 515 - LIST_HEAD(aliases); 516 504 int res = 0; 517 505 const struct pmu_events_table *table = find_core_events_table("testarch", "testcpu"); 518 - struct perf_pmu_alias *a, *tmp; 519 506 520 507 if (!table) 521 508 return -1; ··· 513 526 if (!pmu) 514 527 return -1; 515 528 516 - pmu->name = pmu_name; 529 + INIT_LIST_HEAD(&pmu->format); 530 + INIT_LIST_HEAD(&pmu->aliases); 531 + INIT_LIST_HEAD(&pmu->caps); 532 + INIT_LIST_HEAD(&pmu->list); 533 + pmu->name = strdup(pmu_name); 517 534 518 - pmu_add_cpu_aliases_table(&aliases, pmu, table); 535 + pmu_add_cpu_aliases_table(pmu, table); 519 536 520 537 for (; *test_event_table; test_event_table++) { 521 538 struct perf_pmu_test_event const *test_event = *test_event_table; 522 539 struct pmu_event const *event = &test_event->event; 523 - struct perf_pmu_alias *alias = find_alias(event->name, &aliases); 540 + struct perf_pmu_alias *alias = perf_pmu__find_alias(pmu, event->name); 524 541 525 542 if (!alias) { 526 543 pr_debug("testing aliases core PMU %s: no alias, alias_table->name=%s\n", ··· 542 551 pr_debug2("testing aliases core PMU %s: matched event %s\n", 543 552 pmu_name, alias->name); 544 553 } 554 + perf_pmu__delete(pmu); 545 555 546 - list_for_each_entry_safe(a, tmp, &aliases, list) { 547 - list_del(&a->list); 548 - perf_pmu_free_alias(a); 549 - } 550 - free(pmu); 551 556 return res; 552 557 } 553 558 ··· 555 568 const char *pmu_name = pmu->name; 556 569 struct perf_pmu_alias *a, *tmp, *alias; 557 570 const struct pmu_events_table *events_table; 558 - LIST_HEAD(aliases); 559 571 int res = 0; 560 572 561 573 events_table = find_core_events_table("testarch", "testcpu"); 562 574 if (!events_table) 563 575 return -1; 564 - pmu_add_cpu_aliases_table(&aliases, pmu, events_table); 565 - pmu_add_sys_aliases(&aliases, pmu); 576 + pmu_add_cpu_aliases_table(pmu, events_table); 577 + pmu_add_sys_aliases(pmu); 566 578 567 579 /* Count how many aliases we generated */ 568 - list_for_each_entry(alias, &aliases, list) 580 + list_for_each_entry(alias, &pmu->aliases, list) 569 581 alias_count++; 570 582 571 583 /* Count how many aliases we expect from the known table */ ··· 578 592 goto out; 579 593 } 580 594 581 - list_for_each_entry(alias, &aliases, list) { 595 + list_for_each_entry(alias, &pmu->aliases, list) { 582 596 bool matched = false; 583 597 584 598 for (table = &test_pmu->aliases[0]; *table; table++) { ··· 611 625 } 612 626 613 627 out: 614 - list_for_each_entry_safe(a, tmp, &aliases, list) { 628 + list_for_each_entry_safe(a, tmp, &pmu->aliases, list) { 615 629 list_del(&a->list); 616 630 perf_pmu_free_alias(a); 617 631 } ··· 718 732 } 719 733 720 734 for (i = 0; i < ARRAY_SIZE(test_pmus); i++) { 721 - int res = __test_uncore_pmu_event_aliases(&test_pmus[i]); 735 + int res; 722 736 737 + INIT_LIST_HEAD(&test_pmus[i].pmu.format); 738 + INIT_LIST_HEAD(&test_pmus[i].pmu.aliases); 739 + INIT_LIST_HEAD(&test_pmus[i].pmu.caps); 740 + 741 + res = __test_uncore_pmu_event_aliases(&test_pmus[i]); 723 742 if (res) 724 743 return res; 725 744 }
+1 -1
tools/perf/tests/pmu.c
··· 171 171 } 172 172 173 173 pmu->name = strdup("perf-pmu-test"); 174 - ret = perf_pmu__format_parse(fd, &pmu->format); 174 + ret = perf_pmu__format_parse(pmu, fd); 175 175 if (ret) 176 176 goto out; 177 177
+44 -37
tools/perf/util/pmu.c
··· 58 58 * Parse & process all the sysfs attributes located under 59 59 * the directory specified in 'dir' parameter. 60 60 */ 61 - int perf_pmu__format_parse(int dirfd, struct list_head *head) 61 + int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd) 62 62 { 63 63 struct dirent *evt_ent; 64 64 DIR *format_dir; ··· 96 96 } 97 97 98 98 perf_pmu_set_in(file, scanner); 99 - ret = perf_pmu_parse(head, name, scanner); 99 + ret = perf_pmu_parse(&pmu->format, name, scanner); 100 100 perf_pmu_lex_destroy(scanner); 101 101 fclose(file); 102 102 } ··· 110 110 * located at: 111 111 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 112 112 */ 113 - static int pmu_format(int dirfd, const char *name, struct list_head *format) 113 + static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name) 114 114 { 115 115 int fd; 116 116 ··· 119 119 return 0; 120 120 121 121 /* it'll close the fd */ 122 - if (perf_pmu__format_parse(fd, format)) 122 + if (perf_pmu__format_parse(pmu, fd)) 123 123 return -1; 124 124 125 125 return 0; ··· 508 508 * Reading the pmu event aliases definition, which should be located at: 509 509 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 510 510 */ 511 - static int pmu_aliases(int dirfd, const char *name, struct list_head *head) 511 + static int pmu_aliases(struct perf_pmu *pmu, int dirfd, const char *name) 512 512 { 513 513 int fd; 514 514 ··· 517 517 return 0; 518 518 519 519 /* it'll close the fd */ 520 - if (pmu_aliases_parse(fd, head)) 520 + if (pmu_aliases_parse(fd, &pmu->aliases)) 521 521 return -1; 522 522 523 523 return 0; ··· 770 770 * From the pmu_events_table, find the events that correspond to the given 771 771 * PMU and add them to the list 'head'. 772 772 */ 773 - void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu, 774 - const struct pmu_events_table *table) 773 + void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table) 775 774 { 776 775 struct pmu_add_cpu_aliases_map_data data = { 777 - .head = head, 776 + .head = &pmu->aliases, 778 777 .default_pmu_name = perf_pmus__default_pmu_name(), 779 778 .pmu = pmu, 780 779 }; ··· 782 783 free(data.default_pmu_name); 783 784 } 784 785 785 - static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu) 786 + static void pmu_add_cpu_aliases(struct perf_pmu *pmu) 786 787 { 787 788 const struct pmu_events_table *table; 788 789 ··· 790 791 if (!table) 791 792 return; 792 793 793 - pmu_add_cpu_aliases_table(head, pmu, table); 794 + pmu_add_cpu_aliases_table(pmu, table); 794 795 } 795 796 796 797 struct pmu_sys_event_iter_data { ··· 820 821 return 0; 821 822 } 822 823 823 - void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu) 824 + void pmu_add_sys_aliases(struct perf_pmu *pmu) 824 825 { 825 826 struct pmu_sys_event_iter_data idata = { 826 - .head = head, 827 + .head = &pmu->aliases, 827 828 .pmu = pmu, 828 829 }; 829 830 ··· 862 863 struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *lookup_name) 863 864 { 864 865 struct perf_pmu *pmu; 865 - LIST_HEAD(format); 866 - LIST_HEAD(aliases); 867 866 __u32 type; 868 867 char *name = pmu_find_real_name(lookup_name); 869 868 char *alias_name; 870 - 871 - /* 872 - * The pmu data we store & need consists of the pmu 873 - * type value and format definitions. Load both right 874 - * now. 875 - */ 876 - if (pmu_format(dirfd, name, &format)) 877 - return NULL; 878 - 879 - /* 880 - * Check the aliases first to avoid unnecessary work. 881 - */ 882 - if (pmu_aliases(dirfd, name, &aliases)) 883 - return NULL; 884 869 885 870 pmu = zalloc(sizeof(*pmu)); 886 871 if (!pmu) 887 872 return NULL; 888 873 874 + INIT_LIST_HEAD(&pmu->format); 875 + INIT_LIST_HEAD(&pmu->aliases); 876 + INIT_LIST_HEAD(&pmu->caps); 877 + /* 878 + * The pmu data we store & need consists of the pmu 879 + * type value and format definitions. Load both right 880 + * now. 881 + */ 882 + if (pmu_format(pmu, dirfd, name)) { 883 + free(pmu); 884 + return NULL; 885 + } 886 + /* 887 + * Check the aliases first to avoid unnecessary work. 888 + */ 889 + if (pmu_aliases(pmu, dirfd, name)) { 890 + free(pmu); 891 + return NULL; 892 + } 889 893 pmu->is_core = is_pmu_core(name); 890 894 pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core); 891 895 pmu->name = strdup(name); ··· 911 909 if (pmu->is_uncore) 912 910 pmu->id = pmu_id(name); 913 911 pmu->max_precise = pmu_max_precise(dirfd, pmu); 914 - pmu_add_cpu_aliases(&aliases, pmu); 915 - pmu_add_sys_aliases(&aliases, pmu); 916 - 917 - INIT_LIST_HEAD(&pmu->format); 918 - INIT_LIST_HEAD(&pmu->aliases); 919 - INIT_LIST_HEAD(&pmu->caps); 920 - list_splice(&format, &pmu->format); 921 - list_splice(&aliases, &pmu->aliases); 912 + pmu_add_cpu_aliases(pmu); 913 + pmu_add_sys_aliases(pmu); 922 914 list_add_tail(&pmu->list, pmus); 923 915 924 916 pmu->default_config = perf_pmu__get_default_config(pmu); ··· 1391 1395 info->scale = 1.0; 1392 1396 1393 1397 return 0; 1398 + } 1399 + 1400 + struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu, const char *event) 1401 + { 1402 + struct perf_pmu_alias *alias; 1403 + 1404 + list_for_each_entry(alias, &pmu->aliases, list) 1405 + if (!strcmp(event, alias->name)) 1406 + return alias; 1407 + 1408 + return NULL; 1394 1409 } 1395 1410 1396 1411 int perf_pmu__new_format(struct list_head *list, char *name,
+4 -5
tools/perf/util/pmu.h
··· 213 213 char *pmu_name; 214 214 }; 215 215 216 - void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu); 216 + void pmu_add_sys_aliases(struct perf_pmu *pmu); 217 217 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 218 218 struct list_head *head_terms, 219 219 struct parse_events_error *error); ··· 225 225 int perf_pmu__format_type(struct perf_pmu *pmu, const char *name); 226 226 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 227 227 struct perf_pmu_info *info); 228 - struct list_head *perf_pmu__alias(struct perf_pmu *pmu, 229 - struct list_head *head_terms); 228 + struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu, const char *event); 230 229 231 230 int perf_pmu__new_format(struct list_head *list, char *name, 232 231 int config, unsigned long *bits); 233 - int perf_pmu__format_parse(int dirfd, struct list_head *head); 232 + int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd); 234 233 bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name); 235 234 236 235 bool is_pmu_core(const char *name); ··· 254 255 int perf_pmu__test(void); 255 256 256 257 struct perf_event_attr *perf_pmu__get_default_config(struct perf_pmu *pmu); 257 - void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu, 258 + void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, 258 259 const struct pmu_events_table *table); 259 260 260 261 char *perf_pmu__getcpuid(struct perf_pmu *pmu);