1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2cd82a32eSJiri Olsa #include <linux/list.h> 3c5de47f2SSukadev Bhattiprolu #include <linux/compiler.h> 432858480SArnaldo Carvalho de Melo #include <linux/string.h> 57f7c536fSArnaldo Carvalho de Melo #include <linux/zalloc.h> 6c47a5599SJin Yao #include <linux/ctype.h> 7fa0d9846SArnaldo Carvalho de Melo #include <subcmd/pager.h> 8cd82a32eSJiri Olsa #include <sys/types.h> 9a43783aeSArnaldo Carvalho de Melo #include <errno.h> 10c23c2a0fSArnaldo Carvalho de Melo #include <fcntl.h> 117a8ef4c4SArnaldo Carvalho de Melo #include <sys/stat.h> 12cd82a32eSJiri Olsa #include <unistd.h> 13cd82a32eSJiri Olsa #include <stdio.h> 14dc0a6202SAdrian Hunter #include <stdbool.h> 157d4bdab5SAdrian Hunter #include <stdarg.h> 16cd82a32eSJiri Olsa #include <dirent.h> 17cd0cfad7SBorislav Petkov #include <api/fs/fs.h> 18410136f5SStephane Eranian #include <locale.h> 19fbc2844eSWilliam Cohen #include <regex.h> 209c3516d1SJiri Olsa #include <perf/cpumap.h> 21c47a5599SJin Yao #include <fnmatch.h> 225e51b0bbSArnaldo Carvalho de Melo #include "debug.h" 23e12ee9f7SAdrian Hunter #include "evsel.h" 24cd82a32eSJiri Olsa #include "pmu.h" 25cd82a32eSJiri Olsa #include "parse-events.h" 26933f82ffSSukadev Bhattiprolu #include "header.h" 27a067558eSArnaldo Carvalho de Melo #include "string2.h" 28fa0d9846SArnaldo Carvalho de Melo #include "strbuf.h" 29d9664582SAndi Kleen #include "fncache.h" 3044462430SJin Yao #include "pmu-hybrid.h" 31cd82a32eSJiri Olsa 32e46fc8d9SArnaldo Carvalho de Melo struct perf_pmu perf_pmu__fake; 33e46fc8d9SArnaldo Carvalho de Melo 34ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 35ab1bf653SArnaldo Carvalho de Melo char *name; 36ab1bf653SArnaldo Carvalho de Melo int value; 37ab1bf653SArnaldo Carvalho de Melo DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 38ab1bf653SArnaldo Carvalho de Melo struct list_head list; 39ab1bf653SArnaldo Carvalho de Melo }; 40ab1bf653SArnaldo Carvalho de Melo 41cd82a32eSJiri Olsa int perf_pmu_parse(struct list_head *list, char *name); 42cd82a32eSJiri Olsa extern FILE *perf_pmu_in; 43cd82a32eSJiri Olsa 44cd82a32eSJiri Olsa static LIST_HEAD(pmus); 45c5a26ea4SJin Yao static bool hybrid_scanned; 46cd82a32eSJiri Olsa 47cd82a32eSJiri Olsa /* 48cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 49cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 50cd82a32eSJiri Olsa */ 51cff7f956SJiri Olsa int perf_pmu__format_parse(char *dir, struct list_head *head) 52cd82a32eSJiri Olsa { 53cd82a32eSJiri Olsa struct dirent *evt_ent; 54cd82a32eSJiri Olsa DIR *format_dir; 55cd82a32eSJiri Olsa int ret = 0; 56cd82a32eSJiri Olsa 57cd82a32eSJiri Olsa format_dir = opendir(dir); 58cd82a32eSJiri Olsa if (!format_dir) 59cd82a32eSJiri Olsa return -EINVAL; 60cd82a32eSJiri Olsa 61cd82a32eSJiri Olsa while (!ret && (evt_ent = readdir(format_dir))) { 62cd82a32eSJiri Olsa char path[PATH_MAX]; 63cd82a32eSJiri Olsa char *name = evt_ent->d_name; 64cd82a32eSJiri Olsa FILE *file; 65cd82a32eSJiri Olsa 66cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 67cd82a32eSJiri Olsa continue; 68cd82a32eSJiri Olsa 69cd82a32eSJiri Olsa snprintf(path, PATH_MAX, "%s/%s", dir, name); 70cd82a32eSJiri Olsa 71cd82a32eSJiri Olsa ret = -EINVAL; 72cd82a32eSJiri Olsa file = fopen(path, "r"); 73cd82a32eSJiri Olsa if (!file) 74cd82a32eSJiri Olsa break; 75cd82a32eSJiri Olsa 76cd82a32eSJiri Olsa perf_pmu_in = file; 77cd82a32eSJiri Olsa ret = perf_pmu_parse(head, name); 78cd82a32eSJiri Olsa fclose(file); 79cd82a32eSJiri Olsa } 80cd82a32eSJiri Olsa 81cd82a32eSJiri Olsa closedir(format_dir); 82cd82a32eSJiri Olsa return ret; 83cd82a32eSJiri Olsa } 84cd82a32eSJiri Olsa 85cd82a32eSJiri Olsa /* 86cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 87cd82a32eSJiri Olsa * located at: 88cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 89cd82a32eSJiri Olsa */ 90b6b96fb4SAdrian Hunter static int pmu_format(const char *name, struct list_head *format) 91cd82a32eSJiri Olsa { 92cd82a32eSJiri Olsa char path[PATH_MAX]; 93cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 94cd82a32eSJiri Olsa 95cd82a32eSJiri Olsa if (!sysfs) 96cd82a32eSJiri Olsa return -1; 97cd82a32eSJiri Olsa 98cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 9950a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 100cd82a32eSJiri Olsa 101d9664582SAndi Kleen if (!file_available(path)) 102d9664582SAndi Kleen return 0; 103cd82a32eSJiri Olsa 104cff7f956SJiri Olsa if (perf_pmu__format_parse(path, format)) 105cd82a32eSJiri Olsa return -1; 106cd82a32eSJiri Olsa 107cd82a32eSJiri Olsa return 0; 108cd82a32eSJiri Olsa } 109cd82a32eSJiri Olsa 110a55ab7c4SJin Yao int perf_pmu__convert_scale(const char *scale, char **end, double *sval) 111d02fc6bcSAndi Kleen { 112d02fc6bcSAndi Kleen char *lc; 113d02fc6bcSAndi Kleen int ret = 0; 114d02fc6bcSAndi Kleen 115d02fc6bcSAndi Kleen /* 116d02fc6bcSAndi Kleen * save current locale 117d02fc6bcSAndi Kleen */ 118d02fc6bcSAndi Kleen lc = setlocale(LC_NUMERIC, NULL); 119d02fc6bcSAndi Kleen 120d02fc6bcSAndi Kleen /* 121d02fc6bcSAndi Kleen * The lc string may be allocated in static storage, 122d02fc6bcSAndi Kleen * so get a dynamic copy to make it survive setlocale 123d02fc6bcSAndi Kleen * call below. 124d02fc6bcSAndi Kleen */ 125d02fc6bcSAndi Kleen lc = strdup(lc); 126d02fc6bcSAndi Kleen if (!lc) { 127d02fc6bcSAndi Kleen ret = -ENOMEM; 128d02fc6bcSAndi Kleen goto out; 129d02fc6bcSAndi Kleen } 130d02fc6bcSAndi Kleen 131d02fc6bcSAndi Kleen /* 132d02fc6bcSAndi Kleen * force to C locale to ensure kernel 133d02fc6bcSAndi Kleen * scale string is converted correctly. 134d02fc6bcSAndi Kleen * kernel uses default C locale. 135d02fc6bcSAndi Kleen */ 136d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, "C"); 137d02fc6bcSAndi Kleen 138d02fc6bcSAndi Kleen *sval = strtod(scale, end); 139d02fc6bcSAndi Kleen 140d02fc6bcSAndi Kleen out: 141d02fc6bcSAndi Kleen /* restore locale */ 142d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, lc); 143d02fc6bcSAndi Kleen free(lc); 144d02fc6bcSAndi Kleen return ret; 145d02fc6bcSAndi Kleen } 146d02fc6bcSAndi Kleen 147410136f5SStephane Eranian static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 148410136f5SStephane Eranian { 149410136f5SStephane Eranian struct stat st; 150410136f5SStephane Eranian ssize_t sret; 151410136f5SStephane Eranian char scale[128]; 152410136f5SStephane Eranian int fd, ret = -1; 153410136f5SStephane Eranian char path[PATH_MAX]; 154410136f5SStephane Eranian 15511a64a05SBen Hutchings scnprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 156410136f5SStephane Eranian 157410136f5SStephane Eranian fd = open(path, O_RDONLY); 158410136f5SStephane Eranian if (fd == -1) 159410136f5SStephane Eranian return -1; 160410136f5SStephane Eranian 161410136f5SStephane Eranian if (fstat(fd, &st) < 0) 162410136f5SStephane Eranian goto error; 163410136f5SStephane Eranian 164410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 165410136f5SStephane Eranian if (sret < 0) 166410136f5SStephane Eranian goto error; 167410136f5SStephane Eranian 1689ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 1699ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 1709ecae065SMadhavan Srinivasan else 171410136f5SStephane Eranian scale[sret] = '\0'; 1729ecae065SMadhavan Srinivasan 173a55ab7c4SJin Yao ret = perf_pmu__convert_scale(scale, NULL, &alias->scale); 174410136f5SStephane Eranian error: 175410136f5SStephane Eranian close(fd); 176410136f5SStephane Eranian return ret; 177410136f5SStephane Eranian } 178410136f5SStephane Eranian 179410136f5SStephane Eranian static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 180410136f5SStephane Eranian { 181410136f5SStephane Eranian char path[PATH_MAX]; 182410136f5SStephane Eranian ssize_t sret; 183410136f5SStephane Eranian int fd; 184410136f5SStephane Eranian 18511a64a05SBen Hutchings scnprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 186410136f5SStephane Eranian 187410136f5SStephane Eranian fd = open(path, O_RDONLY); 188410136f5SStephane Eranian if (fd == -1) 189410136f5SStephane Eranian return -1; 190410136f5SStephane Eranian 191410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 192410136f5SStephane Eranian if (sret < 0) 193410136f5SStephane Eranian goto error; 194410136f5SStephane Eranian 195410136f5SStephane Eranian close(fd); 196410136f5SStephane Eranian 1979ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 1989ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 1999ecae065SMadhavan Srinivasan else 200410136f5SStephane Eranian alias->unit[sret] = '\0'; 201410136f5SStephane Eranian 202410136f5SStephane Eranian return 0; 203410136f5SStephane Eranian error: 204410136f5SStephane Eranian close(fd); 205410136f5SStephane Eranian alias->unit[0] = '\0'; 206410136f5SStephane Eranian return -1; 207410136f5SStephane Eranian } 208410136f5SStephane Eranian 209044330c1SMatt Fleming static int 210044330c1SMatt Fleming perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 211044330c1SMatt Fleming { 212044330c1SMatt Fleming char path[PATH_MAX]; 213044330c1SMatt Fleming int fd; 214044330c1SMatt Fleming 21511a64a05SBen Hutchings scnprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 216044330c1SMatt Fleming 217044330c1SMatt Fleming fd = open(path, O_RDONLY); 218044330c1SMatt Fleming if (fd == -1) 219044330c1SMatt Fleming return -1; 220044330c1SMatt Fleming 221044330c1SMatt Fleming close(fd); 222044330c1SMatt Fleming 223044330c1SMatt Fleming alias->per_pkg = true; 224044330c1SMatt Fleming return 0; 225044330c1SMatt Fleming } 226044330c1SMatt Fleming 2271d9e446bSJiri Olsa static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 2281d9e446bSJiri Olsa char *dir, char *name) 2291d9e446bSJiri Olsa { 2301d9e446bSJiri Olsa char path[PATH_MAX]; 2311d9e446bSJiri Olsa int fd; 2321d9e446bSJiri Olsa 23311a64a05SBen Hutchings scnprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 2341d9e446bSJiri Olsa 2351d9e446bSJiri Olsa fd = open(path, O_RDONLY); 2361d9e446bSJiri Olsa if (fd == -1) 2371d9e446bSJiri Olsa return -1; 2381d9e446bSJiri Olsa 2391d9e446bSJiri Olsa alias->snapshot = true; 2401d9e446bSJiri Olsa close(fd); 2411d9e446bSJiri Olsa return 0; 2421d9e446bSJiri Olsa } 2431d9e446bSJiri Olsa 2446dde6429SThomas Richter static void perf_pmu_assign_str(char *name, const char *field, char **old_str, 2456dde6429SThomas Richter char **new_str) 2466dde6429SThomas Richter { 2476dde6429SThomas Richter if (!*old_str) 2486dde6429SThomas Richter goto set_new; 2496dde6429SThomas Richter 2506dde6429SThomas Richter if (*new_str) { /* Have new string, check with old */ 2516dde6429SThomas Richter if (strcasecmp(*old_str, *new_str)) 2526dde6429SThomas Richter pr_debug("alias %s differs in field '%s'\n", 2536dde6429SThomas Richter name, field); 2546dde6429SThomas Richter zfree(old_str); 2556dde6429SThomas Richter } else /* Nothing new --> keep old string */ 2566dde6429SThomas Richter return; 2576dde6429SThomas Richter set_new: 2586dde6429SThomas Richter *old_str = *new_str; 2596dde6429SThomas Richter *new_str = NULL; 2606dde6429SThomas Richter } 2616dde6429SThomas Richter 2626dde6429SThomas Richter static void perf_pmu_update_alias(struct perf_pmu_alias *old, 2636dde6429SThomas Richter struct perf_pmu_alias *newalias) 2646dde6429SThomas Richter { 2656dde6429SThomas Richter perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc); 2666dde6429SThomas Richter perf_pmu_assign_str(old->name, "long_desc", &old->long_desc, 2676dde6429SThomas Richter &newalias->long_desc); 2686dde6429SThomas Richter perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic); 2696dde6429SThomas Richter perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr, 2706dde6429SThomas Richter &newalias->metric_expr); 2716dde6429SThomas Richter perf_pmu_assign_str(old->name, "metric_name", &old->metric_name, 2726dde6429SThomas Richter &newalias->metric_name); 2736dde6429SThomas Richter perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str); 2746dde6429SThomas Richter old->scale = newalias->scale; 2756dde6429SThomas Richter old->per_pkg = newalias->per_pkg; 2766dde6429SThomas Richter old->snapshot = newalias->snapshot; 2776dde6429SThomas Richter memcpy(old->unit, newalias->unit, sizeof(old->unit)); 2786dde6429SThomas Richter } 2796dde6429SThomas Richter 2806dde6429SThomas Richter /* Delete an alias entry. */ 28122fe5a25SNamhyung Kim void perf_pmu_free_alias(struct perf_pmu_alias *newalias) 2826dde6429SThomas Richter { 2836dde6429SThomas Richter zfree(&newalias->name); 2846dde6429SThomas Richter zfree(&newalias->desc); 2856dde6429SThomas Richter zfree(&newalias->long_desc); 2866dde6429SThomas Richter zfree(&newalias->topic); 2876dde6429SThomas Richter zfree(&newalias->str); 2886dde6429SThomas Richter zfree(&newalias->metric_expr); 2896dde6429SThomas Richter zfree(&newalias->metric_name); 29032705de7SJin Yao zfree(&newalias->pmu_name); 2916dde6429SThomas Richter parse_events_terms__purge(&newalias->terms); 2926dde6429SThomas Richter free(newalias); 2936dde6429SThomas Richter } 2946dde6429SThomas Richter 2956dde6429SThomas Richter /* Merge an alias, search in alias list. If this name is already 2966dde6429SThomas Richter * present merge both of them to combine all information. 2976dde6429SThomas Richter */ 2986dde6429SThomas Richter static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias, 2996dde6429SThomas Richter struct list_head *alist) 3006dde6429SThomas Richter { 3016dde6429SThomas Richter struct perf_pmu_alias *a; 3026dde6429SThomas Richter 3036dde6429SThomas Richter list_for_each_entry(a, alist, list) { 3046dde6429SThomas Richter if (!strcasecmp(newalias->name, a->name)) { 30532705de7SJin Yao if (newalias->pmu_name && a->pmu_name && 30632705de7SJin Yao !strcasecmp(newalias->pmu_name, a->pmu_name)) { 30732705de7SJin Yao continue; 30832705de7SJin Yao } 3096dde6429SThomas Richter perf_pmu_update_alias(a, newalias); 3106dde6429SThomas Richter perf_pmu_free_alias(newalias); 3116dde6429SThomas Richter return true; 3126dde6429SThomas Richter } 3136dde6429SThomas Richter } 3146dde6429SThomas Richter return false; 3156dde6429SThomas Richter } 3166dde6429SThomas Richter 31770c646e0SSukadev Bhattiprolu static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 31847f572aaSIan Rogers char *desc, char *val, const struct pmu_event *pe) 319a6146d50SZheng Yan { 3200c24d6fbSThomas Richter struct parse_events_term *term; 3215c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 322a6146d50SZheng Yan int ret; 323fedb2b51SAndi Kleen int num; 3240c24d6fbSThomas Richter char newval[256]; 325eab35953SJin Yao char *long_desc = NULL, *topic = NULL, *unit = NULL, *perpkg = NULL, 32632705de7SJin Yao *metric_expr = NULL, *metric_name = NULL, *deprecated = NULL, 32732705de7SJin Yao *pmu_name = NULL; 328eab35953SJin Yao 329eab35953SJin Yao if (pe) { 330eab35953SJin Yao long_desc = (char *)pe->long_desc; 331eab35953SJin Yao topic = (char *)pe->topic; 332eab35953SJin Yao unit = (char *)pe->unit; 333eab35953SJin Yao perpkg = (char *)pe->perpkg; 334eab35953SJin Yao metric_expr = (char *)pe->metric_expr; 335eab35953SJin Yao metric_name = (char *)pe->metric_name; 336eab35953SJin Yao deprecated = (char *)pe->deprecated; 33732705de7SJin Yao pmu_name = (char *)pe->pmu; 338eab35953SJin Yao } 339a6146d50SZheng Yan 340a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 341a6146d50SZheng Yan if (!alias) 342a6146d50SZheng Yan return -ENOMEM; 343a6146d50SZheng Yan 344a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 345410136f5SStephane Eranian alias->scale = 1.0; 346410136f5SStephane Eranian alias->unit[0] = '\0'; 347044330c1SMatt Fleming alias->per_pkg = false; 34884530920SStephane Eranian alias->snapshot = false; 349a7f6c8c8SJin Yao alias->deprecated = false; 350410136f5SStephane Eranian 35170c646e0SSukadev Bhattiprolu ret = parse_events_terms(&alias->terms, val); 352a6146d50SZheng Yan if (ret) { 35370c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 354a6146d50SZheng Yan free(alias); 355a6146d50SZheng Yan return ret; 356a6146d50SZheng Yan } 357a6146d50SZheng Yan 3580c24d6fbSThomas Richter /* Scan event and remove leading zeroes, spaces, newlines, some 3590c24d6fbSThomas Richter * platforms have terms specified as 3600c24d6fbSThomas Richter * event=0x0091 (read from files ../<PMU>/events/<FILE> 3610c24d6fbSThomas Richter * and terms specified as event=0x91 (read from JSON files). 3620c24d6fbSThomas Richter * 3630c24d6fbSThomas Richter * Rebuild string to make alias->str member comparable. 3640c24d6fbSThomas Richter */ 3650c24d6fbSThomas Richter memset(newval, 0, sizeof(newval)); 3660c24d6fbSThomas Richter ret = 0; 3670c24d6fbSThomas Richter list_for_each_entry(term, &alias->terms, list) { 3680c24d6fbSThomas Richter if (ret) 3690c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 3700c24d6fbSThomas Richter ","); 3710c24d6fbSThomas Richter if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 3720c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 3730c24d6fbSThomas Richter "%s=%#x", term->config, term->val.num); 3740c24d6fbSThomas Richter else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 3750c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 3760c24d6fbSThomas Richter "%s=%s", term->config, term->val.str); 3770c24d6fbSThomas Richter } 3780c24d6fbSThomas Richter 379a6146d50SZheng Yan alias->name = strdup(name); 38070c646e0SSukadev Bhattiprolu if (dir) { 381410136f5SStephane Eranian /* 382410136f5SStephane Eranian * load unit name and scale if available 383410136f5SStephane Eranian */ 384410136f5SStephane Eranian perf_pmu__parse_unit(alias, dir, name); 385410136f5SStephane Eranian perf_pmu__parse_scale(alias, dir, name); 386044330c1SMatt Fleming perf_pmu__parse_per_pkg(alias, dir, name); 3871d9e446bSJiri Olsa perf_pmu__parse_snapshot(alias, dir, name); 38870c646e0SSukadev Bhattiprolu } 389410136f5SStephane Eranian 39000636c3bSAndi Kleen alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL; 39196284814SAndi Kleen alias->metric_name = metric_name ? strdup(metric_name): NULL; 39208e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 393c8d6828aSSukadev Bhattiprolu alias->long_desc = long_desc ? strdup(long_desc) : 394c8d6828aSSukadev Bhattiprolu desc ? strdup(desc) : NULL; 395dd5f1036SAndi Kleen alias->topic = topic ? strdup(topic) : NULL; 396fedb2b51SAndi Kleen if (unit) { 397a55ab7c4SJin Yao if (perf_pmu__convert_scale(unit, &unit, &alias->scale) < 0) 398fedb2b51SAndi Kleen return -1; 399fedb2b51SAndi Kleen snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 400fedb2b51SAndi Kleen } 401fedb2b51SAndi Kleen alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1; 4020c24d6fbSThomas Richter alias->str = strdup(newval); 40332705de7SJin Yao alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; 404f2361024SAndi Kleen 405a7f6c8c8SJin Yao if (deprecated) 406a7f6c8c8SJin Yao alias->deprecated = true; 407a7f6c8c8SJin Yao 4086dde6429SThomas Richter if (!perf_pmu_merge_alias(alias, list)) 409a6146d50SZheng Yan list_add_tail(&alias->list, list); 410410136f5SStephane Eranian 411a6146d50SZheng Yan return 0; 412a6146d50SZheng Yan } 413a6146d50SZheng Yan 41470c646e0SSukadev Bhattiprolu static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 41570c646e0SSukadev Bhattiprolu { 41670c646e0SSukadev Bhattiprolu char buf[256]; 41770c646e0SSukadev Bhattiprolu int ret; 41870c646e0SSukadev Bhattiprolu 41970c646e0SSukadev Bhattiprolu ret = fread(buf, 1, sizeof(buf), file); 42070c646e0SSukadev Bhattiprolu if (ret == 0) 42170c646e0SSukadev Bhattiprolu return -EINVAL; 42270c646e0SSukadev Bhattiprolu 42370c646e0SSukadev Bhattiprolu buf[ret] = 0; 42470c646e0SSukadev Bhattiprolu 425ea23ac73SThomas Richter /* Remove trailing newline from sysfs file */ 42613c230abSArnaldo Carvalho de Melo strim(buf); 427ea23ac73SThomas Richter 428eab35953SJin Yao return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL); 42970c646e0SSukadev Bhattiprolu } 43070c646e0SSukadev Bhattiprolu 43146441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 43246441bdcSMatt Fleming { 43346441bdcSMatt Fleming size_t len; 43446441bdcSMatt Fleming 43546441bdcSMatt Fleming len = strlen(name); 43646441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 43746441bdcSMatt Fleming return true; 43846441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 43946441bdcSMatt Fleming return true; 440044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 441044330c1SMatt Fleming return true; 4421d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 4431d9e446bSJiri Olsa return true; 44446441bdcSMatt Fleming 44546441bdcSMatt Fleming return false; 44646441bdcSMatt Fleming } 44746441bdcSMatt Fleming 448a6146d50SZheng Yan /* 449a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 450a6146d50SZheng Yan * specified in 'dir' parameter. 451a6146d50SZheng Yan */ 452a6146d50SZheng Yan static int pmu_aliases_parse(char *dir, struct list_head *head) 453a6146d50SZheng Yan { 454a6146d50SZheng Yan struct dirent *evt_ent; 455a6146d50SZheng Yan DIR *event_dir; 456a6146d50SZheng Yan 457a6146d50SZheng Yan event_dir = opendir(dir); 458a6146d50SZheng Yan if (!event_dir) 459a6146d50SZheng Yan return -EINVAL; 460a6146d50SZheng Yan 461940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 462a6146d50SZheng Yan char path[PATH_MAX]; 463a6146d50SZheng Yan char *name = evt_ent->d_name; 464a6146d50SZheng Yan FILE *file; 465a6146d50SZheng Yan 466a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 467a6146d50SZheng Yan continue; 468a6146d50SZheng Yan 469410136f5SStephane Eranian /* 47046441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 471410136f5SStephane Eranian */ 47246441bdcSMatt Fleming if (pmu_alias_info_file(name)) 473410136f5SStephane Eranian continue; 474410136f5SStephane Eranian 47577f18153SJiri Olsa scnprintf(path, PATH_MAX, "%s/%s", dir, name); 476a6146d50SZheng Yan 477a6146d50SZheng Yan file = fopen(path, "r"); 478940db6dcSAndi Kleen if (!file) { 479940db6dcSAndi Kleen pr_debug("Cannot open %s\n", path); 480940db6dcSAndi Kleen continue; 481940db6dcSAndi Kleen } 482410136f5SStephane Eranian 483940db6dcSAndi Kleen if (perf_pmu__new_alias(head, dir, name, file) < 0) 484940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 485a6146d50SZheng Yan fclose(file); 486a6146d50SZheng Yan } 487a6146d50SZheng Yan 488a6146d50SZheng Yan closedir(event_dir); 489940db6dcSAndi Kleen return 0; 490a6146d50SZheng Yan } 491a6146d50SZheng Yan 492a6146d50SZheng Yan /* 493a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 494a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 495a6146d50SZheng Yan */ 496b6b96fb4SAdrian Hunter static int pmu_aliases(const char *name, struct list_head *head) 497a6146d50SZheng Yan { 498a6146d50SZheng Yan char path[PATH_MAX]; 499cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 500a6146d50SZheng Yan 501a6146d50SZheng Yan if (!sysfs) 502a6146d50SZheng Yan return -1; 503a6146d50SZheng Yan 504a6146d50SZheng Yan snprintf(path, PATH_MAX, 505a6146d50SZheng Yan "%s/bus/event_source/devices/%s/events", sysfs, name); 506a6146d50SZheng Yan 507d9664582SAndi Kleen if (!file_available(path)) 508d9664582SAndi Kleen return 0; 509a6146d50SZheng Yan 510a6146d50SZheng Yan if (pmu_aliases_parse(path, head)) 511a6146d50SZheng Yan return -1; 512a6146d50SZheng Yan 513a6146d50SZheng Yan return 0; 514a6146d50SZheng Yan } 515a6146d50SZheng Yan 5165c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 517a6146d50SZheng Yan struct list_head *terms) 518a6146d50SZheng Yan { 5197c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 520a6146d50SZheng Yan LIST_HEAD(list); 521a6146d50SZheng Yan int ret; 522a6146d50SZheng Yan 523a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 5247c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 525a6146d50SZheng Yan if (ret) { 526682dc24cSArnaldo Carvalho de Melo parse_events_terms__purge(&list); 527a6146d50SZheng Yan return ret; 528a6146d50SZheng Yan } 529c2f1ceadSAndi Kleen /* 530c2f1ceadSAndi Kleen * Weak terms don't override command line options, 531c2f1ceadSAndi Kleen * which we don't want for implicit terms in aliases. 532c2f1ceadSAndi Kleen */ 533c2f1ceadSAndi Kleen cloned->weak = true; 5347c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 535a6146d50SZheng Yan } 536a6146d50SZheng Yan list_splice(&list, terms); 537a6146d50SZheng Yan return 0; 538a6146d50SZheng Yan } 539a6146d50SZheng Yan 540cd82a32eSJiri Olsa /* 541cd82a32eSJiri Olsa * Reading/parsing the default pmu type value, which should be 542cd82a32eSJiri Olsa * located at: 543cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 544cd82a32eSJiri Olsa */ 545b6b96fb4SAdrian Hunter static int pmu_type(const char *name, __u32 *type) 546cd82a32eSJiri Olsa { 547cd82a32eSJiri Olsa char path[PATH_MAX]; 548cd82a32eSJiri Olsa FILE *file; 549cd82a32eSJiri Olsa int ret = 0; 550cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 551cd82a32eSJiri Olsa 552cd82a32eSJiri Olsa if (!sysfs) 553cd82a32eSJiri Olsa return -1; 554cd82a32eSJiri Olsa 555cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 55650a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 557cd82a32eSJiri Olsa 558d9664582SAndi Kleen if (access(path, R_OK) < 0) 559cd82a32eSJiri Olsa return -1; 560cd82a32eSJiri Olsa 561cd82a32eSJiri Olsa file = fopen(path, "r"); 562cd82a32eSJiri Olsa if (!file) 563cd82a32eSJiri Olsa return -EINVAL; 564cd82a32eSJiri Olsa 565cd82a32eSJiri Olsa if (1 != fscanf(file, "%u", type)) 566cd82a32eSJiri Olsa ret = -1; 567cd82a32eSJiri Olsa 568cd82a32eSJiri Olsa fclose(file); 569cd82a32eSJiri Olsa return ret; 570cd82a32eSJiri Olsa } 571cd82a32eSJiri Olsa 57250a9667cSRobert Richter /* Add all pmus in sysfs to pmu list: */ 57350a9667cSRobert Richter static void pmu_read_sysfs(void) 57450a9667cSRobert Richter { 57550a9667cSRobert Richter char path[PATH_MAX]; 57650a9667cSRobert Richter DIR *dir; 57750a9667cSRobert Richter struct dirent *dent; 578cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 57950a9667cSRobert Richter 58050a9667cSRobert Richter if (!sysfs) 58150a9667cSRobert Richter return; 58250a9667cSRobert Richter 58350a9667cSRobert Richter snprintf(path, PATH_MAX, 58450a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 58550a9667cSRobert Richter 58650a9667cSRobert Richter dir = opendir(path); 58750a9667cSRobert Richter if (!dir) 58850a9667cSRobert Richter return; 58950a9667cSRobert Richter 59050a9667cSRobert Richter while ((dent = readdir(dir))) { 59150a9667cSRobert Richter if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 59250a9667cSRobert Richter continue; 59350a9667cSRobert Richter /* add to static LIST_HEAD(pmus): */ 59450a9667cSRobert Richter perf_pmu__find(dent->d_name); 59550a9667cSRobert Richter } 59650a9667cSRobert Richter 59750a9667cSRobert Richter closedir(dir); 59850a9667cSRobert Richter } 59950a9667cSRobert Richter 600f854839bSJiri Olsa static struct perf_cpu_map *__pmu_cpumask(const char *path) 60166ec1191SMark Rutland { 60266ec1191SMark Rutland FILE *file; 603f854839bSJiri Olsa struct perf_cpu_map *cpus; 60466ec1191SMark Rutland 60566ec1191SMark Rutland file = fopen(path, "r"); 60666ec1191SMark Rutland if (!file) 60766ec1191SMark Rutland return NULL; 60866ec1191SMark Rutland 6099c3516d1SJiri Olsa cpus = perf_cpu_map__read(file); 61066ec1191SMark Rutland fclose(file); 61166ec1191SMark Rutland return cpus; 61266ec1191SMark Rutland } 61366ec1191SMark Rutland 61466ec1191SMark Rutland /* 61566ec1191SMark Rutland * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 61666ec1191SMark Rutland * may have a "cpus" file. 61766ec1191SMark Rutland */ 61851d54847SJohn Garry #define SYS_TEMPLATE_ID "./bus/event_source/devices/%s/identifier" 61966ec1191SMark Rutland #define CPUS_TEMPLATE_UNCORE "%s/bus/event_source/devices/%s/cpumask" 62066ec1191SMark Rutland 621f854839bSJiri Olsa static struct perf_cpu_map *pmu_cpumask(const char *name) 6227ae92e74SYan, Zheng { 6237ae92e74SYan, Zheng char path[PATH_MAX]; 624f854839bSJiri Olsa struct perf_cpu_map *cpus; 625cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 6267e3fcffeSMark Rutland const char *templates[] = { 62766ec1191SMark Rutland CPUS_TEMPLATE_UNCORE, 62866ec1191SMark Rutland CPUS_TEMPLATE_CPU, 6297e3fcffeSMark Rutland NULL 6307e3fcffeSMark Rutland }; 6317e3fcffeSMark Rutland const char **template; 6327ae92e74SYan, Zheng 6337ae92e74SYan, Zheng if (!sysfs) 6347ae92e74SYan, Zheng return NULL; 6357ae92e74SYan, Zheng 6367e3fcffeSMark Rutland for (template = templates; *template; template++) { 6377e3fcffeSMark Rutland snprintf(path, PATH_MAX, *template, sysfs, name); 63866ec1191SMark Rutland cpus = __pmu_cpumask(path); 63966ec1191SMark Rutland if (cpus) 64066ec1191SMark Rutland return cpus; 6417e3fcffeSMark Rutland } 6427ae92e74SYan, Zheng 6437ae92e74SYan, Zheng return NULL; 64466ec1191SMark Rutland } 6457ae92e74SYan, Zheng 64666ec1191SMark Rutland static bool pmu_is_uncore(const char *name) 64766ec1191SMark Rutland { 64866ec1191SMark Rutland char path[PATH_MAX]; 649d9664582SAndi Kleen const char *sysfs; 6507ae92e74SYan, Zheng 65144462430SJin Yao if (perf_pmu__hybrid_mounted(name)) 65244462430SJin Yao return false; 65344462430SJin Yao 654d9664582SAndi Kleen sysfs = sysfs__mountpoint(); 65566ec1191SMark Rutland snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name); 656d9664582SAndi Kleen return file_available(path); 6577ae92e74SYan, Zheng } 6587ae92e74SYan, Zheng 65951d54847SJohn Garry static char *pmu_id(const char *name) 66051d54847SJohn Garry { 66151d54847SJohn Garry char path[PATH_MAX], *str; 66251d54847SJohn Garry size_t len; 66351d54847SJohn Garry 66451d54847SJohn Garry snprintf(path, PATH_MAX, SYS_TEMPLATE_ID, name); 66551d54847SJohn Garry 66651d54847SJohn Garry if (sysfs__read_str(path, &str, &len) < 0) 66751d54847SJohn Garry return NULL; 66851d54847SJohn Garry 66951d54847SJohn Garry str[len - 1] = 0; /* remove line feed */ 67051d54847SJohn Garry 67151d54847SJohn Garry return str; 67251d54847SJohn Garry } 67351d54847SJohn Garry 674933f82ffSSukadev Bhattiprolu /* 67514b22ae0SGanapatrao Kulkarni * PMU CORE devices have different name other than cpu in sysfs on some 676292c34c1SKan Liang * platforms. 677292c34c1SKan Liang * Looking for possible sysfs files to identify the arm core device. 67814b22ae0SGanapatrao Kulkarni */ 679292c34c1SKan Liang static int is_arm_pmu_core(const char *name) 68014b22ae0SGanapatrao Kulkarni { 68114b22ae0SGanapatrao Kulkarni char path[PATH_MAX]; 68214b22ae0SGanapatrao Kulkarni const char *sysfs = sysfs__mountpoint(); 68314b22ae0SGanapatrao Kulkarni 68414b22ae0SGanapatrao Kulkarni if (!sysfs) 68514b22ae0SGanapatrao Kulkarni return 0; 68614b22ae0SGanapatrao Kulkarni 68714b22ae0SGanapatrao Kulkarni /* Look for cpu sysfs (specific to arm) */ 68814b22ae0SGanapatrao Kulkarni scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus", 68914b22ae0SGanapatrao Kulkarni sysfs, name); 690d9664582SAndi Kleen return file_available(path); 69114b22ae0SGanapatrao Kulkarni } 69214b22ae0SGanapatrao Kulkarni 69329be2fe0SIan Rogers char *perf_pmu__getcpuid(struct perf_pmu *pmu) 694d77ade9fSAndi Kleen { 695d77ade9fSAndi Kleen char *cpuid; 696d77ade9fSAndi Kleen static bool printed; 697d77ade9fSAndi Kleen 698d77ade9fSAndi Kleen cpuid = getenv("PERF_CPUID"); 699d77ade9fSAndi Kleen if (cpuid) 700d77ade9fSAndi Kleen cpuid = strdup(cpuid); 701d77ade9fSAndi Kleen if (!cpuid) 70254e32dc0SGanapatrao Kulkarni cpuid = get_cpuid_str(pmu); 703d77ade9fSAndi Kleen if (!cpuid) 704d77ade9fSAndi Kleen return NULL; 705d77ade9fSAndi Kleen 706d77ade9fSAndi Kleen if (!printed) { 707d77ade9fSAndi Kleen pr_debug("Using CPUID %s\n", cpuid); 708d77ade9fSAndi Kleen printed = true; 709d77ade9fSAndi Kleen } 710d77ade9fSAndi Kleen return cpuid; 711d77ade9fSAndi Kleen } 712d77ade9fSAndi Kleen 7131ba3752aSIan Rogers __weak const struct pmu_events_table *pmu_events_table__find(void) 714e126bef5SJohn Garry { 715eeac7730SIan Rogers return perf_pmu__find_table(NULL); 716e126bef5SJohn Garry } 717e126bef5SJohn Garry 718c07d5c92SJohn Garry /* 719c07d5c92SJohn Garry * Suffix must be in form tok_{digits}, or tok{digits}, or same as pmu_name 720c07d5c92SJohn Garry * to be valid. 721c07d5c92SJohn Garry */ 722c07d5c92SJohn Garry static bool perf_pmu__valid_suffix(const char *pmu_name, char *tok) 723c47a5599SJin Yao { 724c07d5c92SJohn Garry const char *p; 725c47a5599SJin Yao 726c47a5599SJin Yao if (strncmp(pmu_name, tok, strlen(tok))) 727c47a5599SJin Yao return false; 728c47a5599SJin Yao 729c47a5599SJin Yao p = pmu_name + strlen(tok); 730c47a5599SJin Yao if (*p == 0) 731c47a5599SJin Yao return true; 732c47a5599SJin Yao 733c07d5c92SJohn Garry if (*p == '_') 734c47a5599SJin Yao ++p; 735c07d5c92SJohn Garry 736c07d5c92SJohn Garry /* Ensure we end in a number */ 737c07d5c92SJohn Garry while (1) { 738c07d5c92SJohn Garry if (!isdigit(*p)) 739c47a5599SJin Yao return false; 740c07d5c92SJohn Garry if (*(++p) == 0) 741c07d5c92SJohn Garry break; 742c07d5c92SJohn Garry } 743c47a5599SJin Yao 744c47a5599SJin Yao return true; 745c47a5599SJin Yao } 746c47a5599SJin Yao 7475b9a5000SJohn Garry bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 748730670b1SJohn Garry { 749730670b1SJohn Garry char *tmp = NULL, *tok, *str; 750730670b1SJohn Garry bool res; 751730670b1SJohn Garry 752730670b1SJohn Garry str = strdup(pmu_name); 753730670b1SJohn Garry if (!str) 754730670b1SJohn Garry return false; 755730670b1SJohn Garry 756730670b1SJohn Garry /* 757730670b1SJohn Garry * uncore alias may be from different PMU with common prefix 758730670b1SJohn Garry */ 759730670b1SJohn Garry tok = strtok_r(str, ",", &tmp); 760730670b1SJohn Garry if (strncmp(pmu_name, tok, strlen(tok))) { 761730670b1SJohn Garry res = false; 762730670b1SJohn Garry goto out; 763730670b1SJohn Garry } 764730670b1SJohn Garry 765730670b1SJohn Garry /* 766730670b1SJohn Garry * Match more complex aliases where the alias name is a comma-delimited 767730670b1SJohn Garry * list of tokens, orderly contained in the matching PMU name. 768730670b1SJohn Garry * 769730670b1SJohn Garry * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 770730670b1SJohn Garry * match "socket" in "socketX_pmunameY" and then "pmuname" in 771730670b1SJohn Garry * "pmunameY". 772730670b1SJohn Garry */ 773c07d5c92SJohn Garry while (1) { 774c07d5c92SJohn Garry char *next_tok = strtok_r(NULL, ",", &tmp); 775c07d5c92SJohn Garry 776730670b1SJohn Garry name = strstr(name, tok); 777c07d5c92SJohn Garry if (!name || 778c07d5c92SJohn Garry (!next_tok && !perf_pmu__valid_suffix(name, tok))) { 779730670b1SJohn Garry res = false; 780730670b1SJohn Garry goto out; 781730670b1SJohn Garry } 782c07d5c92SJohn Garry if (!next_tok) 783c07d5c92SJohn Garry break; 784c07d5c92SJohn Garry tok = next_tok; 785c07d5c92SJohn Garry name += strlen(tok); 786730670b1SJohn Garry } 787730670b1SJohn Garry 788730670b1SJohn Garry res = true; 789730670b1SJohn Garry out: 790730670b1SJohn Garry free(str); 791730670b1SJohn Garry return res; 792730670b1SJohn Garry } 793730670b1SJohn Garry 794660842e4SIan Rogers struct pmu_add_cpu_aliases_map_data { 795660842e4SIan Rogers struct list_head *head; 796660842e4SIan Rogers const char *name; 797660842e4SIan Rogers const char *cpu_name; 798660842e4SIan Rogers struct perf_pmu *pmu; 799660842e4SIan Rogers }; 800660842e4SIan Rogers 801660842e4SIan Rogers static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, 8021ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 803660842e4SIan Rogers void *vdata) 804660842e4SIan Rogers { 805660842e4SIan Rogers struct pmu_add_cpu_aliases_map_data *data = vdata; 806660842e4SIan Rogers const char *pname = pe->pmu ? pe->pmu : data->cpu_name; 807660842e4SIan Rogers 808660842e4SIan Rogers if (!pe->name) 809660842e4SIan Rogers return 0; 810660842e4SIan Rogers 811660842e4SIan Rogers if (data->pmu->is_uncore && pmu_uncore_alias_match(pname, data->name)) 812660842e4SIan Rogers goto new_alias; 813660842e4SIan Rogers 814660842e4SIan Rogers if (strcmp(pname, data->name)) 815660842e4SIan Rogers return 0; 816660842e4SIan Rogers 817660842e4SIan Rogers new_alias: 818660842e4SIan Rogers /* need type casts to override 'const' */ 819660842e4SIan Rogers __perf_pmu__new_alias(data->head, NULL, (char *)pe->name, (char *)pe->desc, 820660842e4SIan Rogers (char *)pe->event, pe); 821660842e4SIan Rogers return 0; 822660842e4SIan Rogers } 823660842e4SIan Rogers 824933f82ffSSukadev Bhattiprolu /* 825933f82ffSSukadev Bhattiprolu * From the pmu_events_map, find the table of PMU events that corresponds 826933f82ffSSukadev Bhattiprolu * to the current running CPU. Then, add all PMU events from that table 827933f82ffSSukadev Bhattiprolu * as aliases. 828933f82ffSSukadev Bhattiprolu */ 829eeac7730SIan Rogers void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu, 8301ba3752aSIan Rogers const struct pmu_events_table *table) 831933f82ffSSukadev Bhattiprolu { 832660842e4SIan Rogers struct pmu_add_cpu_aliases_map_data data = { 833660842e4SIan Rogers .head = head, 834660842e4SIan Rogers .name = pmu->name, 835660842e4SIan Rogers .cpu_name = is_arm_pmu_core(pmu->name) ? pmu->name : "cpu", 836660842e4SIan Rogers .pmu = pmu, 837660842e4SIan Rogers }; 838fedb2b51SAndi Kleen 839660842e4SIan Rogers pmu_events_table_for_each_event(table, pmu_add_cpu_aliases_map_callback, &data); 840933f82ffSSukadev Bhattiprolu } 841933f82ffSSukadev Bhattiprolu 842e45ad701SJohn Garry static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu) 843e45ad701SJohn Garry { 8441ba3752aSIan Rogers const struct pmu_events_table *table; 845e45ad701SJohn Garry 846eeac7730SIan Rogers table = perf_pmu__find_table(pmu); 847eeac7730SIan Rogers if (!table) 848e45ad701SJohn Garry return; 849e45ad701SJohn Garry 850eeac7730SIan Rogers pmu_add_cpu_aliases_table(head, pmu, table); 851e45ad701SJohn Garry } 852e45ad701SJohn Garry 8534513c719SJohn Garry struct pmu_sys_event_iter_data { 8544513c719SJohn Garry struct list_head *head; 8554513c719SJohn Garry struct perf_pmu *pmu; 8564513c719SJohn Garry }; 8574513c719SJohn Garry 85829be2fe0SIan Rogers static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, 8591ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 86029be2fe0SIan Rogers void *data) 8614513c719SJohn Garry { 8624513c719SJohn Garry struct pmu_sys_event_iter_data *idata = data; 8634513c719SJohn Garry struct perf_pmu *pmu = idata->pmu; 8644513c719SJohn Garry 8654513c719SJohn Garry if (!pe->name) { 8664513c719SJohn Garry if (pe->metric_group || pe->metric_name) 8674513c719SJohn Garry return 0; 8684513c719SJohn Garry return -EINVAL; 8694513c719SJohn Garry } 8704513c719SJohn Garry 8714513c719SJohn Garry if (!pe->compat || !pe->pmu) 8724513c719SJohn Garry return 0; 8734513c719SJohn Garry 8744513c719SJohn Garry if (!strcmp(pmu->id, pe->compat) && 8754513c719SJohn Garry pmu_uncore_alias_match(pe->pmu, pmu->name)) { 8764513c719SJohn Garry __perf_pmu__new_alias(idata->head, NULL, 8774513c719SJohn Garry (char *)pe->name, 8784513c719SJohn Garry (char *)pe->desc, 8794513c719SJohn Garry (char *)pe->event, 880eab35953SJin Yao pe); 8814513c719SJohn Garry } 8824513c719SJohn Garry 8834513c719SJohn Garry return 0; 8844513c719SJohn Garry } 8854513c719SJohn Garry 886e199f47fSJohn Garry void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu) 8874513c719SJohn Garry { 8884513c719SJohn Garry struct pmu_sys_event_iter_data idata = { 8894513c719SJohn Garry .head = head, 8904513c719SJohn Garry .pmu = pmu, 8914513c719SJohn Garry }; 8924513c719SJohn Garry 8934513c719SJohn Garry if (!pmu->id) 8944513c719SJohn Garry return; 8954513c719SJohn Garry 8964513c719SJohn Garry pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata); 8974513c719SJohn Garry } 8984513c719SJohn Garry 899c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 900dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 901dc0a6202SAdrian Hunter { 902dc0a6202SAdrian Hunter return NULL; 903dc0a6202SAdrian Hunter } 904dc0a6202SAdrian Hunter 90513d60ba0SKan Liang char * __weak 90613d60ba0SKan Liang pmu_find_real_name(const char *name) 90713d60ba0SKan Liang { 90813d60ba0SKan Liang return (char *)name; 90913d60ba0SKan Liang } 91013d60ba0SKan Liang 91113d60ba0SKan Liang char * __weak 91213d60ba0SKan Liang pmu_find_alias_name(const char *name __maybe_unused) 91313d60ba0SKan Liang { 91413d60ba0SKan Liang return NULL; 91513d60ba0SKan Liang } 91613d60ba0SKan Liang 91790a86bdeSJiri Olsa static int pmu_max_precise(const char *name) 91890a86bdeSJiri Olsa { 91990a86bdeSJiri Olsa char path[PATH_MAX]; 92090a86bdeSJiri Olsa int max_precise = -1; 92190a86bdeSJiri Olsa 92290a86bdeSJiri Olsa scnprintf(path, PATH_MAX, 92390a86bdeSJiri Olsa "bus/event_source/devices/%s/caps/max_precise", 92490a86bdeSJiri Olsa name); 92590a86bdeSJiri Olsa 92690a86bdeSJiri Olsa sysfs__read_int(path, &max_precise); 92790a86bdeSJiri Olsa return max_precise; 92890a86bdeSJiri Olsa } 92990a86bdeSJiri Olsa 93013d60ba0SKan Liang static struct perf_pmu *pmu_lookup(const char *lookup_name) 931cd82a32eSJiri Olsa { 932cd82a32eSJiri Olsa struct perf_pmu *pmu; 933cd82a32eSJiri Olsa LIST_HEAD(format); 934a6146d50SZheng Yan LIST_HEAD(aliases); 935cd82a32eSJiri Olsa __u32 type; 93613d60ba0SKan Liang char *name = pmu_find_real_name(lookup_name); 93749afa7f6SJin Yao bool is_hybrid = perf_pmu__hybrid_mounted(name); 93813d60ba0SKan Liang char *alias_name; 93949afa7f6SJin Yao 94049afa7f6SJin Yao /* 94149afa7f6SJin Yao * Check pmu name for hybrid and the pmu may be invalid in sysfs 94249afa7f6SJin Yao */ 94349afa7f6SJin Yao if (!strncmp(name, "cpu_", 4) && !is_hybrid) 94449afa7f6SJin Yao return NULL; 945cd82a32eSJiri Olsa 946cd82a32eSJiri Olsa /* 947cd82a32eSJiri Olsa * The pmu data we store & need consists of the pmu 948cd82a32eSJiri Olsa * type value and format definitions. Load both right 949cd82a32eSJiri Olsa * now. 950cd82a32eSJiri Olsa */ 951cd82a32eSJiri Olsa if (pmu_format(name, &format)) 952cd82a32eSJiri Olsa return NULL; 953cd82a32eSJiri Olsa 95415b22ed3SAndi Kleen /* 95515b22ed3SAndi Kleen * Check the type first to avoid unnecessary work. 95615b22ed3SAndi Kleen */ 95715b22ed3SAndi Kleen if (pmu_type(name, &type)) 95815b22ed3SAndi Kleen return NULL; 95915b22ed3SAndi Kleen 9603fded963SJiri Olsa if (pmu_aliases(name, &aliases)) 9613fded963SJiri Olsa return NULL; 9623fded963SJiri Olsa 963cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 964cd82a32eSJiri Olsa if (!pmu) 965cd82a32eSJiri Olsa return NULL; 966cd82a32eSJiri Olsa 9677ae92e74SYan, Zheng pmu->cpus = pmu_cpumask(name); 96854e32dc0SGanapatrao Kulkarni pmu->name = strdup(name); 96913d60ba0SKan Liang if (!pmu->name) 97013d60ba0SKan Liang goto err; 97113d60ba0SKan Liang 97213d60ba0SKan Liang alias_name = pmu_find_alias_name(name); 97313d60ba0SKan Liang if (alias_name) { 97413d60ba0SKan Liang pmu->alias_name = strdup(alias_name); 97513d60ba0SKan Liang if (!pmu->alias_name) 97613d60ba0SKan Liang goto err; 97713d60ba0SKan Liang } 97813d60ba0SKan Liang 97954e32dc0SGanapatrao Kulkarni pmu->type = type; 98066ec1191SMark Rutland pmu->is_uncore = pmu_is_uncore(name); 98151d54847SJohn Garry if (pmu->is_uncore) 98251d54847SJohn Garry pmu->id = pmu_id(name); 98349afa7f6SJin Yao pmu->is_hybrid = is_hybrid; 98490a86bdeSJiri Olsa pmu->max_precise = pmu_max_precise(name); 98554e32dc0SGanapatrao Kulkarni pmu_add_cpu_aliases(&aliases, pmu); 9864513c719SJohn Garry pmu_add_sys_aliases(&aliases, pmu); 98766ec1191SMark Rutland 988cd82a32eSJiri Olsa INIT_LIST_HEAD(&pmu->format); 989a6146d50SZheng Yan INIT_LIST_HEAD(&pmu->aliases); 9909fbc61f8SKan Liang INIT_LIST_HEAD(&pmu->caps); 991cd82a32eSJiri Olsa list_splice(&format, &pmu->format); 992a6146d50SZheng Yan list_splice(&aliases, &pmu->aliases); 9939bc8f9feSRobert Richter list_add_tail(&pmu->list, &pmus); 994dc0a6202SAdrian Hunter 99544462430SJin Yao if (pmu->is_hybrid) 99644462430SJin Yao list_add_tail(&pmu->hybrid_list, &perf_pmu__hybrid_pmus); 99744462430SJin Yao 998dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 999dc0a6202SAdrian Hunter 1000cd82a32eSJiri Olsa return pmu; 100113d60ba0SKan Liang err: 100213d60ba0SKan Liang if (pmu->name) 100313d60ba0SKan Liang free(pmu->name); 100413d60ba0SKan Liang free(pmu); 100513d60ba0SKan Liang return NULL; 1006cd82a32eSJiri Olsa } 1007cd82a32eSJiri Olsa 1008e552b7beSRob Herring void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1009e552b7beSRob Herring { 1010e552b7beSRob Herring struct perf_pmu_format *format; 1011e552b7beSRob Herring 1012e552b7beSRob Herring /* fake pmu doesn't have format list */ 1013e552b7beSRob Herring if (pmu == &perf_pmu__fake) 1014e552b7beSRob Herring return; 1015e552b7beSRob Herring 1016e552b7beSRob Herring list_for_each_entry(format, &pmu->format, list) 1017e552b7beSRob Herring if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { 1018e552b7beSRob Herring pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" 1019e552b7beSRob Herring "which is not supported by this version of perf!\n", 1020e552b7beSRob Herring pmu->name, format->name, format->value); 1021e552b7beSRob Herring return; 1022e552b7beSRob Herring } 1023e552b7beSRob Herring } 1024e552b7beSRob Herring 1025b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_find(const char *name) 1026cd82a32eSJiri Olsa { 1027cd82a32eSJiri Olsa struct perf_pmu *pmu; 1028cd82a32eSJiri Olsa 102913d60ba0SKan Liang list_for_each_entry(pmu, &pmus, list) { 103013d60ba0SKan Liang if (!strcmp(pmu->name, name) || 103113d60ba0SKan Liang (pmu->alias_name && !strcmp(pmu->alias_name, name))) 1032cd82a32eSJiri Olsa return pmu; 103313d60ba0SKan Liang } 1034cd82a32eSJiri Olsa 1035cd82a32eSJiri Olsa return NULL; 1036cd82a32eSJiri Olsa } 1037cd82a32eSJiri Olsa 10383a50dc76SStephane Eranian struct perf_pmu *perf_pmu__find_by_type(unsigned int type) 10393a50dc76SStephane Eranian { 10403a50dc76SStephane Eranian struct perf_pmu *pmu; 10413a50dc76SStephane Eranian 10423a50dc76SStephane Eranian list_for_each_entry(pmu, &pmus, list) 10433a50dc76SStephane Eranian if (pmu->type == type) 10443a50dc76SStephane Eranian return pmu; 10453a50dc76SStephane Eranian 10463a50dc76SStephane Eranian return NULL; 10473a50dc76SStephane Eranian } 10483a50dc76SStephane Eranian 104950a9667cSRobert Richter struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 105050a9667cSRobert Richter { 105150a9667cSRobert Richter /* 105250a9667cSRobert Richter * pmu iterator: If pmu is NULL, we start at the begin, 105350a9667cSRobert Richter * otherwise return the next pmu. Returns NULL on end. 105450a9667cSRobert Richter */ 105550a9667cSRobert Richter if (!pmu) { 105650a9667cSRobert Richter pmu_read_sysfs(); 105750a9667cSRobert Richter pmu = list_prepare_entry(pmu, &pmus, list); 105850a9667cSRobert Richter } 105950a9667cSRobert Richter list_for_each_entry_continue(pmu, &pmus, list) 106050a9667cSRobert Richter return pmu; 106150a9667cSRobert Richter return NULL; 106250a9667cSRobert Richter } 106350a9667cSRobert Richter 1064e76026bdSArnaldo Carvalho de Melo struct perf_pmu *evsel__find_pmu(struct evsel *evsel) 1065e12ee9f7SAdrian Hunter { 1066e12ee9f7SAdrian Hunter struct perf_pmu *pmu = NULL; 1067e12ee9f7SAdrian Hunter 1068*f7400262SNamhyung Kim if (evsel->pmu) 1069*f7400262SNamhyung Kim return evsel->pmu; 1070*f7400262SNamhyung Kim 1071e12ee9f7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1072e12ee9f7SAdrian Hunter if (pmu->type == evsel->core.attr.type) 1073e12ee9f7SAdrian Hunter break; 1074e12ee9f7SAdrian Hunter } 1075e12ee9f7SAdrian Hunter 1076*f7400262SNamhyung Kim evsel->pmu = pmu; 1077e12ee9f7SAdrian Hunter return pmu; 1078e12ee9f7SAdrian Hunter } 1079e12ee9f7SAdrian Hunter 108039453ed5SArnaldo Carvalho de Melo bool evsel__is_aux_event(struct evsel *evsel) 1081e12ee9f7SAdrian Hunter { 1082e76026bdSArnaldo Carvalho de Melo struct perf_pmu *pmu = evsel__find_pmu(evsel); 1083e12ee9f7SAdrian Hunter 1084e12ee9f7SAdrian Hunter return pmu && pmu->auxtrace; 1085e12ee9f7SAdrian Hunter } 1086e12ee9f7SAdrian Hunter 1087b6b96fb4SAdrian Hunter struct perf_pmu *perf_pmu__find(const char *name) 1088cd82a32eSJiri Olsa { 1089cd82a32eSJiri Olsa struct perf_pmu *pmu; 1090cd82a32eSJiri Olsa 1091cd82a32eSJiri Olsa /* 1092cd82a32eSJiri Olsa * Once PMU is loaded it stays in the list, 1093cd82a32eSJiri Olsa * so we keep us from multiple reading/parsing 1094cd82a32eSJiri Olsa * the pmu format definitions. 1095cd82a32eSJiri Olsa */ 1096cd82a32eSJiri Olsa pmu = pmu_find(name); 1097cd82a32eSJiri Olsa if (pmu) 1098cd82a32eSJiri Olsa return pmu; 1099cd82a32eSJiri Olsa 1100cd82a32eSJiri Olsa return pmu_lookup(name); 1101cd82a32eSJiri Olsa } 1102cd82a32eSJiri Olsa 11035c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 110409ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 1105cd82a32eSJiri Olsa { 11065c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1107cd82a32eSJiri Olsa 1108cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 1109cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 1110cd82a32eSJiri Olsa return format; 1111cd82a32eSJiri Olsa 1112cd82a32eSJiri Olsa return NULL; 1113cd82a32eSJiri Olsa } 1114cd82a32eSJiri Olsa 111509ff6071SAdrian Hunter __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 111609ff6071SAdrian Hunter { 111709ff6071SAdrian Hunter struct perf_pmu_format *format = pmu_find_format(formats, name); 111809ff6071SAdrian Hunter __u64 bits = 0; 111909ff6071SAdrian Hunter int fbit; 112009ff6071SAdrian Hunter 112109ff6071SAdrian Hunter if (!format) 112209ff6071SAdrian Hunter return 0; 112309ff6071SAdrian Hunter 112409ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 112509ff6071SAdrian Hunter bits |= 1ULL << fbit; 112609ff6071SAdrian Hunter 112709ff6071SAdrian Hunter return bits; 112809ff6071SAdrian Hunter } 112909ff6071SAdrian Hunter 1130a1ac7de6SAdrian Hunter int perf_pmu__format_type(struct list_head *formats, const char *name) 1131a1ac7de6SAdrian Hunter { 1132a1ac7de6SAdrian Hunter struct perf_pmu_format *format = pmu_find_format(formats, name); 1133a1ac7de6SAdrian Hunter 1134a1ac7de6SAdrian Hunter if (!format) 1135a1ac7de6SAdrian Hunter return -1; 1136a1ac7de6SAdrian Hunter 1137a1ac7de6SAdrian Hunter return format->value; 1138a1ac7de6SAdrian Hunter } 1139a1ac7de6SAdrian Hunter 1140cd82a32eSJiri Olsa /* 1141dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 11424d39c89fSIngo Molnar * and unformatted value (value parameter). 1143cd82a32eSJiri Olsa */ 1144dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1145dc0a6202SAdrian Hunter bool zero) 1146cd82a32eSJiri Olsa { 1147cd82a32eSJiri Olsa unsigned long fbit, vbit; 1148cd82a32eSJiri Olsa 1149cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1150cd82a32eSJiri Olsa 1151cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 1152cd82a32eSJiri Olsa continue; 1153cd82a32eSJiri Olsa 1154dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 1155dc0a6202SAdrian Hunter *v |= (1llu << fbit); 1156dc0a6202SAdrian Hunter else if (zero) 1157dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 1158cd82a32eSJiri Olsa } 1159cd82a32eSJiri Olsa } 1160cd82a32eSJiri Olsa 11610efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 11620efe6b67SAdrian Hunter { 11631b9caa10SJiri Olsa int w; 11640efe6b67SAdrian Hunter 11651b9caa10SJiri Olsa w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 11661b9caa10SJiri Olsa if (!w) 11671b9caa10SJiri Olsa return 0; 11681b9caa10SJiri Olsa if (w < 64) 11691b9caa10SJiri Olsa return (1ULL << w) - 1; 11701b9caa10SJiri Olsa return -1; 11710efe6b67SAdrian Hunter } 11720efe6b67SAdrian Hunter 1173cd82a32eSJiri Olsa /* 1174688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 1175688d4dfcSCody P Schafer * in the remaining terms. 1176688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 1177688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 1178688d4dfcSCody P Schafer * in a config string) later on in the term list. 1179688d4dfcSCody P Schafer */ 1180688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 1181688d4dfcSCody P Schafer struct list_head *head_terms, 1182688d4dfcSCody P Schafer __u64 *value) 1183688d4dfcSCody P Schafer { 1184688d4dfcSCody P Schafer struct parse_events_term *t; 1185688d4dfcSCody P Schafer 1186688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 11872a3d252dSIan Rogers if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 11882a3d252dSIan Rogers t->config && !strcmp(t->config, term->config)) { 1189688d4dfcSCody P Schafer t->used = true; 1190688d4dfcSCody P Schafer *value = t->val.num; 1191688d4dfcSCody P Schafer return 0; 1192688d4dfcSCody P Schafer } 1193688d4dfcSCody P Schafer } 1194688d4dfcSCody P Schafer 1195bb963e16SNamhyung Kim if (verbose > 0) 1196688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 1197688d4dfcSCody P Schafer 1198688d4dfcSCody P Schafer return -1; 1199688d4dfcSCody P Schafer } 1200688d4dfcSCody P Schafer 1201ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 1202e64b020bSJiri Olsa { 1203e64b020bSJiri Olsa struct perf_pmu_format *format; 120411db4e29SMasami Hiramatsu char *str = NULL; 120511db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1206f1417ceaSXin Gao unsigned int i = 0; 1207e64b020bSJiri Olsa 1208ffeb883eSHe Kuang if (!formats) 1209e64b020bSJiri Olsa return NULL; 1210e64b020bSJiri Olsa 1211e64b020bSJiri Olsa /* sysfs exported terms */ 1212ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 121311db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 121411db4e29SMasami Hiramatsu goto error; 1215e64b020bSJiri Olsa 1216ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 121711db4e29SMasami Hiramatsu error: 1218ffeb883eSHe Kuang strbuf_release(&buf); 1219e64b020bSJiri Olsa 1220e64b020bSJiri Olsa return str; 1221e64b020bSJiri Olsa } 1222e64b020bSJiri Olsa 1223688d4dfcSCody P Schafer /* 1224cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 122588aca8d9SCody P Schafer * user input data - term parameter. 1226cd82a32eSJiri Olsa */ 12274ac22b48SIan Rogers static int pmu_config_term(const char *pmu_name, 12284ac22b48SIan Rogers struct list_head *formats, 1229cd82a32eSJiri Olsa struct perf_event_attr *attr, 1230dc0a6202SAdrian Hunter struct parse_events_term *term, 1231688d4dfcSCody P Schafer struct list_head *head_terms, 1232e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1233cd82a32eSJiri Olsa { 12345c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1235cd82a32eSJiri Olsa __u64 *vp; 12360efe6b67SAdrian Hunter __u64 val, max_val; 1237cd82a32eSJiri Olsa 1238cd82a32eSJiri Olsa /* 1239688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 1240688d4dfcSCody P Schafer * skip it in normal eval. 1241688d4dfcSCody P Schafer */ 1242688d4dfcSCody P Schafer if (term->used) 1243688d4dfcSCody P Schafer return 0; 1244688d4dfcSCody P Schafer 1245688d4dfcSCody P Schafer /* 1246cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 1247cd82a32eSJiri Olsa * to be done for them. 1248cd82a32eSJiri Olsa */ 1249cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 1250cd82a32eSJiri Olsa return 0; 1251cd82a32eSJiri Olsa 1252cd82a32eSJiri Olsa format = pmu_find_format(formats, term->config); 1253688d4dfcSCody P Schafer if (!format) { 1254ffeb883eSHe Kuang char *pmu_term = pmu_formats_string(formats); 12554ac22b48SIan Rogers char *unknown_term; 12564ac22b48SIan Rogers char *help_msg; 1257ffeb883eSHe Kuang 12584ac22b48SIan Rogers if (asprintf(&unknown_term, 12594ac22b48SIan Rogers "unknown term '%s' for pmu '%s'", 12604ac22b48SIan Rogers term->config, pmu_name) < 0) 12614ac22b48SIan Rogers unknown_term = NULL; 12624ac22b48SIan Rogers help_msg = parse_events_formats_error_string(pmu_term); 12634ac22b48SIan Rogers if (err) { 12646c191289SIan Rogers parse_events_error__handle(err, term->err_term, 12654ac22b48SIan Rogers unknown_term, 12664ac22b48SIan Rogers help_msg); 12674ac22b48SIan Rogers } else { 12684ac22b48SIan Rogers pr_debug("%s (%s)\n", unknown_term, help_msg); 12694ac22b48SIan Rogers free(unknown_term); 1270e64b020bSJiri Olsa } 12714ac22b48SIan Rogers free(pmu_term); 1272cd82a32eSJiri Olsa return -EINVAL; 1273688d4dfcSCody P Schafer } 1274cd82a32eSJiri Olsa 1275cd82a32eSJiri Olsa switch (format->value) { 1276cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 1277cd82a32eSJiri Olsa vp = &attr->config; 1278cd82a32eSJiri Olsa break; 1279cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 1280cd82a32eSJiri Olsa vp = &attr->config1; 1281cd82a32eSJiri Olsa break; 1282cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 1283cd82a32eSJiri Olsa vp = &attr->config2; 1284cd82a32eSJiri Olsa break; 1285cd82a32eSJiri Olsa default: 1286cd82a32eSJiri Olsa return -EINVAL; 1287cd82a32eSJiri Olsa } 1288cd82a32eSJiri Olsa 128916fa7e82SJiri Olsa /* 1290688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 1291688d4dfcSCody P Schafer * using event parameters. 129216fa7e82SJiri Olsa */ 129399e7138eSJiri Olsa if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 129499e7138eSJiri Olsa if (term->no_value && 129599e7138eSJiri Olsa bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 129699e7138eSJiri Olsa if (err) { 12976c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1298448d732cSIan Rogers strdup("no value assigned for term"), 1299448d732cSIan Rogers NULL); 130099e7138eSJiri Olsa } 130199e7138eSJiri Olsa return -EINVAL; 130299e7138eSJiri Olsa } 130399e7138eSJiri Olsa 1304688d4dfcSCody P Schafer val = term->val.num; 130599e7138eSJiri Olsa } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1306688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 1307bb963e16SNamhyung Kim if (verbose > 0) { 1308688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 1309688d4dfcSCody P Schafer term->config, term->val.str); 1310e64b020bSJiri Olsa } 1311e64b020bSJiri Olsa if (err) { 13126c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1313448d732cSIan Rogers strdup("expected numeric value"), 1314448d732cSIan Rogers NULL); 1315e64b020bSJiri Olsa } 1316688d4dfcSCody P Schafer return -EINVAL; 1317688d4dfcSCody P Schafer } 1318688d4dfcSCody P Schafer 1319688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 1320688d4dfcSCody P Schafer return -EINVAL; 1321688d4dfcSCody P Schafer } else 1322688d4dfcSCody P Schafer return -EINVAL; 1323688d4dfcSCody P Schafer 13240efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 13250efe6b67SAdrian Hunter if (val > max_val) { 13260efe6b67SAdrian Hunter if (err) { 1327448d732cSIan Rogers char *err_str; 1328448d732cSIan Rogers 13296c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1330448d732cSIan Rogers asprintf(&err_str, 13310efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 1332448d732cSIan Rogers (unsigned long long)max_val) < 0 1333448d732cSIan Rogers ? strdup("value too big for format") 1334448d732cSIan Rogers : err_str, 1335448d732cSIan Rogers NULL); 13360efe6b67SAdrian Hunter return -EINVAL; 13370efe6b67SAdrian Hunter } 13380efe6b67SAdrian Hunter /* 13390efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 13400efe6b67SAdrian Hunter * silently truncated. 13410efe6b67SAdrian Hunter */ 13420efe6b67SAdrian Hunter } 13430efe6b67SAdrian Hunter 1344688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 1345cd82a32eSJiri Olsa return 0; 1346cd82a32eSJiri Olsa } 1347cd82a32eSJiri Olsa 13484ac22b48SIan Rogers int perf_pmu__config_terms(const char *pmu_name, struct list_head *formats, 1349cff7f956SJiri Olsa struct perf_event_attr *attr, 1350dc0a6202SAdrian Hunter struct list_head *head_terms, 1351e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1352cd82a32eSJiri Olsa { 13536cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 1354cd82a32eSJiri Olsa 1355688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 13564ac22b48SIan Rogers if (pmu_config_term(pmu_name, formats, attr, term, head_terms, 1357e64b020bSJiri Olsa zero, err)) 1358cd82a32eSJiri Olsa return -EINVAL; 1359688d4dfcSCody P Schafer } 1360cd82a32eSJiri Olsa 1361cd82a32eSJiri Olsa return 0; 1362cd82a32eSJiri Olsa } 1363cd82a32eSJiri Olsa 1364cd82a32eSJiri Olsa /* 1365cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 1366cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 1367cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 1368cd82a32eSJiri Olsa */ 1369cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1370e64b020bSJiri Olsa struct list_head *head_terms, 1371e64b020bSJiri Olsa struct parse_events_error *err) 1372cd82a32eSJiri Olsa { 1373dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 1374dc0a6202SAdrian Hunter 1375cd82a32eSJiri Olsa attr->type = pmu->type; 13764ac22b48SIan Rogers return perf_pmu__config_terms(pmu->name, &pmu->format, attr, 13774ac22b48SIan Rogers head_terms, zero, err); 1378cd82a32eSJiri Olsa } 1379cd82a32eSJiri Olsa 13805c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 13816cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 1382a6146d50SZheng Yan { 13835c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1384a6146d50SZheng Yan char *name; 1385a6146d50SZheng Yan 1386a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 1387a6146d50SZheng Yan return NULL; 1388a6146d50SZheng Yan 1389a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1390a6146d50SZheng Yan if (term->val.num != 1) 1391a6146d50SZheng Yan return NULL; 1392a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 1393a6146d50SZheng Yan return NULL; 1394a6146d50SZheng Yan name = term->config; 1395a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1396a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 1397a6146d50SZheng Yan return NULL; 1398a6146d50SZheng Yan name = term->val.str; 1399a6146d50SZheng Yan } else { 1400a6146d50SZheng Yan return NULL; 1401a6146d50SZheng Yan } 1402a6146d50SZheng Yan 1403a6146d50SZheng Yan list_for_each_entry(alias, &pmu->aliases, list) { 1404a6146d50SZheng Yan if (!strcasecmp(alias->name, name)) 1405a6146d50SZheng Yan return alias; 1406a6146d50SZheng Yan } 1407a6146d50SZheng Yan return NULL; 1408a6146d50SZheng Yan } 1409a6146d50SZheng Yan 1410410136f5SStephane Eranian 14111d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 14121d9e446bSJiri Olsa struct perf_pmu_info *info) 1413410136f5SStephane Eranian { 1414410136f5SStephane Eranian /* 1415410136f5SStephane Eranian * Only one term in event definition can 14161d9e446bSJiri Olsa * define unit, scale and snapshot, fail 14171d9e446bSJiri Olsa * if there's more than one. 1418410136f5SStephane Eranian */ 1419b30a7d1fSArnaldo Carvalho de Melo if ((info->unit && alias->unit[0]) || 14201d9e446bSJiri Olsa (info->scale && alias->scale) || 14211d9e446bSJiri Olsa (info->snapshot && alias->snapshot)) 1422410136f5SStephane Eranian return -EINVAL; 1423410136f5SStephane Eranian 1424b30a7d1fSArnaldo Carvalho de Melo if (alias->unit[0]) 14251d9e446bSJiri Olsa info->unit = alias->unit; 1426410136f5SStephane Eranian 1427410136f5SStephane Eranian if (alias->scale) 14281d9e446bSJiri Olsa info->scale = alias->scale; 14291d9e446bSJiri Olsa 14301d9e446bSJiri Olsa if (alias->snapshot) 14311d9e446bSJiri Olsa info->snapshot = alias->snapshot; 1432410136f5SStephane Eranian 1433410136f5SStephane Eranian return 0; 1434410136f5SStephane Eranian } 1435410136f5SStephane Eranian 1436a6146d50SZheng Yan /* 1437a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 1438a6146d50SZheng Yan * defined for the alias 1439a6146d50SZheng Yan */ 1440410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 144146441bdcSMatt Fleming struct perf_pmu_info *info) 1442a6146d50SZheng Yan { 14436cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 14445c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1445a6146d50SZheng Yan int ret; 1446a6146d50SZheng Yan 1447044330c1SMatt Fleming info->per_pkg = false; 1448044330c1SMatt Fleming 14498a398897SStephane Eranian /* 14508a398897SStephane Eranian * Mark unit and scale as not set 14518a398897SStephane Eranian * (different from default values, see below) 14528a398897SStephane Eranian */ 145346441bdcSMatt Fleming info->unit = NULL; 145446441bdcSMatt Fleming info->scale = 0.0; 14551d9e446bSJiri Olsa info->snapshot = false; 145637932c18SAndi Kleen info->metric_expr = NULL; 145796284814SAndi Kleen info->metric_name = NULL; 1458410136f5SStephane Eranian 1459a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 1460a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 1461a6146d50SZheng Yan if (!alias) 1462a6146d50SZheng Yan continue; 1463a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 1464a6146d50SZheng Yan if (ret) 1465a6146d50SZheng Yan return ret; 1466410136f5SStephane Eranian 14671d9e446bSJiri Olsa ret = check_info_data(alias, info); 1468410136f5SStephane Eranian if (ret) 1469410136f5SStephane Eranian return ret; 1470410136f5SStephane Eranian 1471044330c1SMatt Fleming if (alias->per_pkg) 1472044330c1SMatt Fleming info->per_pkg = true; 147337932c18SAndi Kleen info->metric_expr = alias->metric_expr; 147496284814SAndi Kleen info->metric_name = alias->metric_name; 1475044330c1SMatt Fleming 1476e56fbc9dSArnaldo Carvalho de Melo list_del_init(&term->list); 14771dc92556SIan Rogers parse_events_term__delete(term); 1478a6146d50SZheng Yan } 14798a398897SStephane Eranian 14808a398897SStephane Eranian /* 14818a398897SStephane Eranian * if no unit or scale found in aliases, then 14828a398897SStephane Eranian * set defaults as for evsel 14838a398897SStephane Eranian * unit cannot left to NULL 14848a398897SStephane Eranian */ 148546441bdcSMatt Fleming if (info->unit == NULL) 148646441bdcSMatt Fleming info->unit = ""; 14878a398897SStephane Eranian 148846441bdcSMatt Fleming if (info->scale == 0.0) 148946441bdcSMatt Fleming info->scale = 1.0; 14908a398897SStephane Eranian 1491a6146d50SZheng Yan return 0; 1492a6146d50SZheng Yan } 1493a6146d50SZheng Yan 1494cd82a32eSJiri Olsa int perf_pmu__new_format(struct list_head *list, char *name, 1495cd82a32eSJiri Olsa int config, unsigned long *bits) 1496cd82a32eSJiri Olsa { 14975c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1498cd82a32eSJiri Olsa 1499cd82a32eSJiri Olsa format = zalloc(sizeof(*format)); 1500cd82a32eSJiri Olsa if (!format) 1501cd82a32eSJiri Olsa return -ENOMEM; 1502cd82a32eSJiri Olsa 1503cd82a32eSJiri Olsa format->name = strdup(name); 1504cd82a32eSJiri Olsa format->value = config; 1505cd82a32eSJiri Olsa memcpy(format->bits, bits, sizeof(format->bits)); 1506cd82a32eSJiri Olsa 1507cd82a32eSJiri Olsa list_add_tail(&format->list, list); 1508cd82a32eSJiri Olsa return 0; 1509cd82a32eSJiri Olsa } 1510cd82a32eSJiri Olsa 1511cd82a32eSJiri Olsa void perf_pmu__set_format(unsigned long *bits, long from, long to) 1512cd82a32eSJiri Olsa { 1513cd82a32eSJiri Olsa long b; 1514cd82a32eSJiri Olsa 1515cd82a32eSJiri Olsa if (!to) 1516cd82a32eSJiri Olsa to = from; 1517cd82a32eSJiri Olsa 151815268138SSukadev Bhattiprolu memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 1519cd82a32eSJiri Olsa for (b = from; b <= to; b++) 1520cd82a32eSJiri Olsa set_bit(b, bits); 1521cd82a32eSJiri Olsa } 1522dc098b35SAndi Kleen 1523d26383dcSNamhyung Kim void perf_pmu__del_formats(struct list_head *formats) 1524d26383dcSNamhyung Kim { 1525d26383dcSNamhyung Kim struct perf_pmu_format *fmt, *tmp; 1526d26383dcSNamhyung Kim 1527d26383dcSNamhyung Kim list_for_each_entry_safe(fmt, tmp, formats, list) { 1528d26383dcSNamhyung Kim list_del(&fmt->list); 1529d26383dcSNamhyung Kim free(fmt->name); 1530d26383dcSNamhyung Kim free(fmt); 1531d26383dcSNamhyung Kim } 1532d26383dcSNamhyung Kim } 1533d26383dcSNamhyung Kim 1534aaea3617SCody P Schafer static int sub_non_neg(int a, int b) 1535aaea3617SCody P Schafer { 1536aaea3617SCody P Schafer if (b > a) 1537aaea3617SCody P Schafer return 0; 1538aaea3617SCody P Schafer return a - b; 1539aaea3617SCody P Schafer } 1540aaea3617SCody P Schafer 1541dc098b35SAndi Kleen static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 1542dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1543dc098b35SAndi Kleen { 1544aaea3617SCody P Schafer struct parse_events_term *term; 1545aaea3617SCody P Schafer int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1546aaea3617SCody P Schafer 1547aaea3617SCody P Schafer list_for_each_entry(term, &alias->terms, list) { 1548aaea3617SCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1549aaea3617SCody P Schafer used += snprintf(buf + used, sub_non_neg(len, used), 1550aaea3617SCody P Schafer ",%s=%s", term->config, 1551aaea3617SCody P Schafer term->val.str); 1552aaea3617SCody P Schafer } 1553aaea3617SCody P Schafer 1554aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1555aaea3617SCody P Schafer buf[used] = '/'; 1556aaea3617SCody P Schafer used++; 1557aaea3617SCody P Schafer } 1558aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1559aaea3617SCody P Schafer buf[used] = '\0'; 1560aaea3617SCody P Schafer used++; 1561aaea3617SCody P Schafer } else 1562aaea3617SCody P Schafer buf[len - 1] = '\0'; 1563aaea3617SCody P Schafer 1564dc098b35SAndi Kleen return buf; 1565dc098b35SAndi Kleen } 1566dc098b35SAndi Kleen 1567dc098b35SAndi Kleen static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 1568dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1569dc098b35SAndi Kleen { 1570dc098b35SAndi Kleen snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 1571dc098b35SAndi Kleen return buf; 1572dc098b35SAndi Kleen } 1573dc098b35SAndi Kleen 1574dd5f1036SAndi Kleen struct sevent { 157508e60ed1SAndi Kleen char *name; 157608e60ed1SAndi Kleen char *desc; 1577dd5f1036SAndi Kleen char *topic; 1578f2361024SAndi Kleen char *str; 1579f2361024SAndi Kleen char *pmu; 15807f372a63SAndi Kleen char *metric_expr; 158196284814SAndi Kleen char *metric_name; 1582ce0dc7d2SJohn Garry int is_cpu; 158308e60ed1SAndi Kleen }; 158408e60ed1SAndi Kleen 1585dd5f1036SAndi Kleen static int cmp_sevent(const void *a, const void *b) 1586dc098b35SAndi Kleen { 1587dd5f1036SAndi Kleen const struct sevent *as = a; 1588dd5f1036SAndi Kleen const struct sevent *bs = b; 15890e0ae874SJin Yao int ret; 159008e60ed1SAndi Kleen 159108e60ed1SAndi Kleen /* Put extra events last */ 159208e60ed1SAndi Kleen if (!!as->desc != !!bs->desc) 159308e60ed1SAndi Kleen return !!as->desc - !!bs->desc; 1594dd5f1036SAndi Kleen if (as->topic && bs->topic) { 1595dd5f1036SAndi Kleen int n = strcmp(as->topic, bs->topic); 1596dd5f1036SAndi Kleen 1597dd5f1036SAndi Kleen if (n) 1598dd5f1036SAndi Kleen return n; 1599dd5f1036SAndi Kleen } 1600ce0dc7d2SJohn Garry 1601ce0dc7d2SJohn Garry /* Order CPU core events to be first */ 1602ce0dc7d2SJohn Garry if (as->is_cpu != bs->is_cpu) 1603ce0dc7d2SJohn Garry return bs->is_cpu - as->is_cpu; 1604ce0dc7d2SJohn Garry 16050e0ae874SJin Yao ret = strcmp(as->name, bs->name); 16060e0ae874SJin Yao if (!ret) { 16070e0ae874SJin Yao if (as->pmu && bs->pmu) 16080e0ae874SJin Yao return strcmp(as->pmu, bs->pmu); 16090e0ae874SJin Yao } 16100e0ae874SJin Yao 16110e0ae874SJin Yao return ret; 161208e60ed1SAndi Kleen } 161308e60ed1SAndi Kleen 161408e60ed1SAndi Kleen static void wordwrap(char *s, int start, int max, int corr) 161508e60ed1SAndi Kleen { 161608e60ed1SAndi Kleen int column = start; 161708e60ed1SAndi Kleen int n; 161808e60ed1SAndi Kleen 161908e60ed1SAndi Kleen while (*s) { 162008e60ed1SAndi Kleen int wlen = strcspn(s, " \t"); 162108e60ed1SAndi Kleen 162208e60ed1SAndi Kleen if (column + wlen >= max && column > start) { 162308e60ed1SAndi Kleen printf("\n%*s", start, ""); 162408e60ed1SAndi Kleen column = start + corr; 162508e60ed1SAndi Kleen } 162608e60ed1SAndi Kleen n = printf("%s%.*s", column > start ? " " : "", wlen, s); 162708e60ed1SAndi Kleen if (n <= 0) 162808e60ed1SAndi Kleen break; 162908e60ed1SAndi Kleen s += wlen; 163008e60ed1SAndi Kleen column += n; 163132858480SArnaldo Carvalho de Melo s = skip_spaces(s); 163208e60ed1SAndi Kleen } 1633dc098b35SAndi Kleen } 1634dc098b35SAndi Kleen 1635d504fae9SJohn Garry bool is_pmu_core(const char *name) 1636d504fae9SJohn Garry { 1637d504fae9SJohn Garry return !strcmp(name, "cpu") || is_arm_pmu_core(name); 1638d504fae9SJohn Garry } 1639d504fae9SJohn Garry 1640e0257a01SJohn Garry static bool pmu_alias_is_duplicate(struct sevent *alias_a, 1641e0257a01SJohn Garry struct sevent *alias_b) 1642e0257a01SJohn Garry { 1643e0257a01SJohn Garry /* Different names -> never duplicates */ 1644e0257a01SJohn Garry if (strcmp(alias_a->name, alias_b->name)) 1645e0257a01SJohn Garry return false; 1646e0257a01SJohn Garry 1647e0257a01SJohn Garry /* Don't remove duplicates for hybrid PMUs */ 1648e0257a01SJohn Garry if (perf_pmu__is_hybrid(alias_a->pmu) && 1649e0257a01SJohn Garry perf_pmu__is_hybrid(alias_b->pmu)) 1650e0257a01SJohn Garry return false; 1651e0257a01SJohn Garry 1652e0257a01SJohn Garry return true; 1653e0257a01SJohn Garry } 1654e0257a01SJohn Garry 1655c8d6828aSSukadev Bhattiprolu void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag, 16560e0ae874SJin Yao bool long_desc, bool details_flag, bool deprecated, 16570e0ae874SJin Yao const char *pmu_name) 1658dc098b35SAndi Kleen { 1659dc098b35SAndi Kleen struct perf_pmu *pmu; 1660dc098b35SAndi Kleen struct perf_pmu_alias *alias; 1661dc098b35SAndi Kleen char buf[1024]; 1662dc098b35SAndi Kleen int printed = 0; 1663dc098b35SAndi Kleen int len, j; 1664dd5f1036SAndi Kleen struct sevent *aliases; 166508e60ed1SAndi Kleen int numdesc = 0; 166661eb2eb4SAndi Kleen int columns = pager_get_columns(); 1667dd5f1036SAndi Kleen char *topic = NULL; 1668dc098b35SAndi Kleen 1669dc098b35SAndi Kleen pmu = NULL; 1670dc098b35SAndi Kleen len = 0; 167142634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1672dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 1673dc098b35SAndi Kleen len++; 167442634bc7SAdrian Hunter if (pmu->selectable) 167542634bc7SAdrian Hunter len++; 167642634bc7SAdrian Hunter } 1677dd5f1036SAndi Kleen aliases = zalloc(sizeof(struct sevent) * len); 1678dc098b35SAndi Kleen if (!aliases) 16797e4772dcSArnaldo Carvalho de Melo goto out_enomem; 1680dc098b35SAndi Kleen pmu = NULL; 1681dc098b35SAndi Kleen j = 0; 168242634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 16830e0ae874SJin Yao if (pmu_name && perf_pmu__is_hybrid(pmu->name) && 16840e0ae874SJin Yao strcmp(pmu_name, pmu->name)) { 16850e0ae874SJin Yao continue; 16860e0ae874SJin Yao } 16870e0ae874SJin Yao 1688dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) { 168908e60ed1SAndi Kleen char *name = alias->desc ? alias->name : 169008e60ed1SAndi Kleen format_alias(buf, sizeof(buf), pmu, alias); 16910e0ae874SJin Yao bool is_cpu = is_pmu_core(pmu->name) || 16920e0ae874SJin Yao perf_pmu__is_hybrid(pmu->name); 1693dc098b35SAndi Kleen 1694a7f6c8c8SJin Yao if (alias->deprecated && !deprecated) 1695a7f6c8c8SJin Yao continue; 1696a7f6c8c8SJin Yao 1697dc098b35SAndi Kleen if (event_glob != NULL && 169838d14f0cSAndi Kleen !(strglobmatch_nocase(name, event_glob) || 169938d14f0cSAndi Kleen (!is_cpu && strglobmatch_nocase(alias->name, 170067bdc35fSAndi Kleen event_glob)) || 170167bdc35fSAndi Kleen (alias->topic && 170267bdc35fSAndi Kleen strglobmatch_nocase(alias->topic, event_glob)))) 1703dc098b35SAndi Kleen continue; 17047e4772dcSArnaldo Carvalho de Melo 170508e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 17067e4772dcSArnaldo Carvalho de Melo name = format_alias_or(buf, sizeof(buf), pmu, alias); 17077e4772dcSArnaldo Carvalho de Melo 170808e60ed1SAndi Kleen aliases[j].name = name; 170908e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 171008e60ed1SAndi Kleen aliases[j].name = format_alias_or(buf, 171108e60ed1SAndi Kleen sizeof(buf), 171208e60ed1SAndi Kleen pmu, alias); 171308e60ed1SAndi Kleen aliases[j].name = strdup(aliases[j].name); 171408e60ed1SAndi Kleen if (!aliases[j].name) 17157e4772dcSArnaldo Carvalho de Melo goto out_enomem; 171608e60ed1SAndi Kleen 1717c8d6828aSSukadev Bhattiprolu aliases[j].desc = long_desc ? alias->long_desc : 1718c8d6828aSSukadev Bhattiprolu alias->desc; 1719dd5f1036SAndi Kleen aliases[j].topic = alias->topic; 1720f2361024SAndi Kleen aliases[j].str = alias->str; 1721f2361024SAndi Kleen aliases[j].pmu = pmu->name; 17227f372a63SAndi Kleen aliases[j].metric_expr = alias->metric_expr; 172396284814SAndi Kleen aliases[j].metric_name = alias->metric_name; 1724ce0dc7d2SJohn Garry aliases[j].is_cpu = is_cpu; 1725dc098b35SAndi Kleen j++; 1726dc098b35SAndi Kleen } 1727fa52ceabSArnaldo Carvalho de Melo if (pmu->selectable && 1728fa52ceabSArnaldo Carvalho de Melo (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 17297e4772dcSArnaldo Carvalho de Melo char *s; 17307e4772dcSArnaldo Carvalho de Melo if (asprintf(&s, "%s//", pmu->name) < 0) 17317e4772dcSArnaldo Carvalho de Melo goto out_enomem; 173208e60ed1SAndi Kleen aliases[j].name = s; 173342634bc7SAdrian Hunter j++; 173442634bc7SAdrian Hunter } 173542634bc7SAdrian Hunter } 1736dc098b35SAndi Kleen len = j; 1737dd5f1036SAndi Kleen qsort(aliases, len, sizeof(struct sevent), cmp_sevent); 1738dc098b35SAndi Kleen for (j = 0; j < len; j++) { 173915b22ed3SAndi Kleen /* Skip duplicates */ 1740e0257a01SJohn Garry if (j > 0 && pmu_alias_is_duplicate(&aliases[j], &aliases[j - 1])) 174115b22ed3SAndi Kleen continue; 17420e0ae874SJin Yao 1743dc098b35SAndi Kleen if (name_only) { 174408e60ed1SAndi Kleen printf("%s ", aliases[j].name); 1745dc098b35SAndi Kleen continue; 1746dc098b35SAndi Kleen } 17471c5f01feSAndi Kleen if (aliases[j].desc && !quiet_flag) { 174808e60ed1SAndi Kleen if (numdesc++ == 0) 174908e60ed1SAndi Kleen printf("\n"); 1750dd5f1036SAndi Kleen if (aliases[j].topic && (!topic || 1751dd5f1036SAndi Kleen strcmp(topic, aliases[j].topic))) { 1752dd5f1036SAndi Kleen printf("%s%s:\n", topic ? "\n" : "", 1753dd5f1036SAndi Kleen aliases[j].topic); 1754dd5f1036SAndi Kleen topic = aliases[j].topic; 1755dd5f1036SAndi Kleen } 175608e60ed1SAndi Kleen printf(" %-50s\n", aliases[j].name); 175708e60ed1SAndi Kleen printf("%*s", 8, "["); 175808e60ed1SAndi Kleen wordwrap(aliases[j].desc, 8, columns, 0); 175908e60ed1SAndi Kleen printf("]\n"); 1760bf874fcfSAndi Kleen if (details_flag) { 17617f372a63SAndi Kleen printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str); 176296284814SAndi Kleen if (aliases[j].metric_name) 176396284814SAndi Kleen printf(" MetricName: %s", aliases[j].metric_name); 17647f372a63SAndi Kleen if (aliases[j].metric_expr) 17657f372a63SAndi Kleen printf(" MetricExpr: %s", aliases[j].metric_expr); 17667f372a63SAndi Kleen putchar('\n'); 17677f372a63SAndi Kleen } 176808e60ed1SAndi Kleen } else 176908e60ed1SAndi Kleen printf(" %-50s [Kernel PMU event]\n", aliases[j].name); 1770dc098b35SAndi Kleen printed++; 1771dc098b35SAndi Kleen } 1772dfc431cbSArnaldo Carvalho de Melo if (printed && pager_in_use()) 1773dc098b35SAndi Kleen printf("\n"); 17747e4772dcSArnaldo Carvalho de Melo out_free: 17757e4772dcSArnaldo Carvalho de Melo for (j = 0; j < len; j++) 177608e60ed1SAndi Kleen zfree(&aliases[j].name); 17777e4772dcSArnaldo Carvalho de Melo zfree(&aliases); 17787e4772dcSArnaldo Carvalho de Melo return; 17797e4772dcSArnaldo Carvalho de Melo 17807e4772dcSArnaldo Carvalho de Melo out_enomem: 17817e4772dcSArnaldo Carvalho de Melo printf("FATAL: not enough memory to print PMU events\n"); 17827e4772dcSArnaldo Carvalho de Melo if (aliases) 17837e4772dcSArnaldo Carvalho de Melo goto out_free; 1784dc098b35SAndi Kleen } 17854cabc3d1SAndi Kleen 17864cabc3d1SAndi Kleen bool pmu_have_event(const char *pname, const char *name) 17874cabc3d1SAndi Kleen { 17884cabc3d1SAndi Kleen struct perf_pmu *pmu; 17894cabc3d1SAndi Kleen struct perf_pmu_alias *alias; 17904cabc3d1SAndi Kleen 17914cabc3d1SAndi Kleen pmu = NULL; 17924cabc3d1SAndi Kleen while ((pmu = perf_pmu__scan(pmu)) != NULL) { 17934cabc3d1SAndi Kleen if (strcmp(pname, pmu->name)) 17944cabc3d1SAndi Kleen continue; 17954cabc3d1SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 17964cabc3d1SAndi Kleen if (!strcmp(alias->name, name)) 17974cabc3d1SAndi Kleen return true; 17984cabc3d1SAndi Kleen } 17994cabc3d1SAndi Kleen return false; 18004cabc3d1SAndi Kleen } 18017d4bdab5SAdrian Hunter 18027d4bdab5SAdrian Hunter static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 18037d4bdab5SAdrian Hunter { 18047d4bdab5SAdrian Hunter char path[PATH_MAX]; 18057d4bdab5SAdrian Hunter const char *sysfs; 18067d4bdab5SAdrian Hunter 18077d4bdab5SAdrian Hunter sysfs = sysfs__mountpoint(); 18087d4bdab5SAdrian Hunter if (!sysfs) 18097d4bdab5SAdrian Hunter return NULL; 18107d4bdab5SAdrian Hunter 18117d4bdab5SAdrian Hunter snprintf(path, PATH_MAX, 18127d4bdab5SAdrian Hunter "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 1813d9664582SAndi Kleen if (!file_available(path)) 18147d4bdab5SAdrian Hunter return NULL; 18157d4bdab5SAdrian Hunter return fopen(path, "r"); 18167d4bdab5SAdrian Hunter } 18177d4bdab5SAdrian Hunter 18187d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 18197d4bdab5SAdrian Hunter ...) 18207d4bdab5SAdrian Hunter { 18217d4bdab5SAdrian Hunter va_list args; 18227d4bdab5SAdrian Hunter FILE *file; 18237d4bdab5SAdrian Hunter int ret = EOF; 18247d4bdab5SAdrian Hunter 18257d4bdab5SAdrian Hunter va_start(args, fmt); 18267d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 18277d4bdab5SAdrian Hunter if (file) { 18287d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 18297d4bdab5SAdrian Hunter fclose(file); 18307d4bdab5SAdrian Hunter } 18317d4bdab5SAdrian Hunter va_end(args); 18327d4bdab5SAdrian Hunter return ret; 18337d4bdab5SAdrian Hunter } 18349fbc61f8SKan Liang 18359fbc61f8SKan Liang static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 18369fbc61f8SKan Liang { 18379fbc61f8SKan Liang struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 18389fbc61f8SKan Liang 18399fbc61f8SKan Liang if (!caps) 18409fbc61f8SKan Liang return -ENOMEM; 18419fbc61f8SKan Liang 18429fbc61f8SKan Liang caps->name = strdup(name); 18439fbc61f8SKan Liang if (!caps->name) 18449fbc61f8SKan Liang goto free_caps; 18459fbc61f8SKan Liang caps->value = strndup(value, strlen(value) - 1); 18469fbc61f8SKan Liang if (!caps->value) 18479fbc61f8SKan Liang goto free_name; 18489fbc61f8SKan Liang list_add_tail(&caps->list, list); 18499fbc61f8SKan Liang return 0; 18509fbc61f8SKan Liang 18519fbc61f8SKan Liang free_name: 18529fbc61f8SKan Liang zfree(caps->name); 18539fbc61f8SKan Liang free_caps: 18549fbc61f8SKan Liang free(caps); 18559fbc61f8SKan Liang 18569fbc61f8SKan Liang return -ENOMEM; 18579fbc61f8SKan Liang } 18589fbc61f8SKan Liang 18599fbc61f8SKan Liang /* 18609fbc61f8SKan Liang * Reading/parsing the given pmu capabilities, which should be located at: 18619fbc61f8SKan Liang * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 18629fbc61f8SKan Liang * Return the number of capabilities 18639fbc61f8SKan Liang */ 18649fbc61f8SKan Liang int perf_pmu__caps_parse(struct perf_pmu *pmu) 18659fbc61f8SKan Liang { 18669fbc61f8SKan Liang struct stat st; 18679fbc61f8SKan Liang char caps_path[PATH_MAX]; 18689fbc61f8SKan Liang const char *sysfs = sysfs__mountpoint(); 18699fbc61f8SKan Liang DIR *caps_dir; 18709fbc61f8SKan Liang struct dirent *evt_ent; 18713339ec44SRavi Bangoria 18723339ec44SRavi Bangoria if (pmu->caps_initialized) 18733339ec44SRavi Bangoria return pmu->nr_caps; 18743339ec44SRavi Bangoria 18753339ec44SRavi Bangoria pmu->nr_caps = 0; 18769fbc61f8SKan Liang 18779fbc61f8SKan Liang if (!sysfs) 18789fbc61f8SKan Liang return -1; 18799fbc61f8SKan Liang 18809fbc61f8SKan Liang snprintf(caps_path, PATH_MAX, 18819fbc61f8SKan Liang "%s" EVENT_SOURCE_DEVICE_PATH "%s/caps", sysfs, pmu->name); 18829fbc61f8SKan Liang 18833339ec44SRavi Bangoria if (stat(caps_path, &st) < 0) { 18843339ec44SRavi Bangoria pmu->caps_initialized = true; 18859fbc61f8SKan Liang return 0; /* no error if caps does not exist */ 18863339ec44SRavi Bangoria } 18879fbc61f8SKan Liang 18889fbc61f8SKan Liang caps_dir = opendir(caps_path); 18899fbc61f8SKan Liang if (!caps_dir) 18909fbc61f8SKan Liang return -EINVAL; 18919fbc61f8SKan Liang 18929fbc61f8SKan Liang while ((evt_ent = readdir(caps_dir)) != NULL) { 18939fbc61f8SKan Liang char path[PATH_MAX + NAME_MAX + 1]; 18949fbc61f8SKan Liang char *name = evt_ent->d_name; 18959fbc61f8SKan Liang char value[128]; 18969fbc61f8SKan Liang FILE *file; 18979fbc61f8SKan Liang 18989fbc61f8SKan Liang if (!strcmp(name, ".") || !strcmp(name, "..")) 18999fbc61f8SKan Liang continue; 19009fbc61f8SKan Liang 19019fbc61f8SKan Liang snprintf(path, sizeof(path), "%s/%s", caps_path, name); 19029fbc61f8SKan Liang 19039fbc61f8SKan Liang file = fopen(path, "r"); 19049fbc61f8SKan Liang if (!file) 19059fbc61f8SKan Liang continue; 19069fbc61f8SKan Liang 19079fbc61f8SKan Liang if (!fgets(value, sizeof(value), file) || 19089fbc61f8SKan Liang (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 19099fbc61f8SKan Liang fclose(file); 19109fbc61f8SKan Liang continue; 19119fbc61f8SKan Liang } 19129fbc61f8SKan Liang 19133339ec44SRavi Bangoria pmu->nr_caps++; 19149fbc61f8SKan Liang fclose(file); 19159fbc61f8SKan Liang } 19169fbc61f8SKan Liang 19179fbc61f8SKan Liang closedir(caps_dir); 19189fbc61f8SKan Liang 19193339ec44SRavi Bangoria pmu->caps_initialized = true; 19203339ec44SRavi Bangoria return pmu->nr_caps; 19219fbc61f8SKan Liang } 1922e4064776SJin Yao 1923e4064776SJin Yao void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 19248e8bbfb3SIan Rogers const char *name) 1925e4064776SJin Yao { 1926e4064776SJin Yao struct perf_pmu_format *format; 1927e4064776SJin Yao __u64 masks = 0, bits; 1928e4064776SJin Yao char buf[100]; 1929e4064776SJin Yao unsigned int i; 1930e4064776SJin Yao 1931e4064776SJin Yao list_for_each_entry(format, &pmu->format, list) { 1932e4064776SJin Yao if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG) 1933e4064776SJin Yao continue; 1934e4064776SJin Yao 1935e4064776SJin Yao for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 1936e4064776SJin Yao masks |= 1ULL << i; 1937e4064776SJin Yao } 1938e4064776SJin Yao 1939e4064776SJin Yao /* 1940e4064776SJin Yao * Kernel doesn't export any valid format bits. 1941e4064776SJin Yao */ 1942e4064776SJin Yao if (masks == 0) 1943e4064776SJin Yao return; 1944e4064776SJin Yao 1945e4064776SJin Yao bits = config & ~masks; 1946e4064776SJin Yao if (bits == 0) 1947e4064776SJin Yao return; 1948e4064776SJin Yao 1949e4064776SJin Yao bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 1950e4064776SJin Yao 1951e4064776SJin Yao pr_warning("WARNING: event '%s' not valid (bits %s of config " 1952e4064776SJin Yao "'%llx' not supported by kernel)!\n", 1953e4064776SJin Yao name ?: "N/A", buf, config); 1954e4064776SJin Yao } 1955c5a26ea4SJin Yao 1956c5a26ea4SJin Yao bool perf_pmu__has_hybrid(void) 1957c5a26ea4SJin Yao { 1958c5a26ea4SJin Yao if (!hybrid_scanned) { 1959c5a26ea4SJin Yao hybrid_scanned = true; 1960c5a26ea4SJin Yao perf_pmu__scan(NULL); 1961c5a26ea4SJin Yao } 1962c5a26ea4SJin Yao 1963c5a26ea4SJin Yao return !list_empty(&perf_pmu__hybrid_pmus); 1964c5a26ea4SJin Yao } 1965c47a5599SJin Yao 1966c47a5599SJin Yao int perf_pmu__match(char *pattern, char *name, char *tok) 1967c47a5599SJin Yao { 196813d60ba0SKan Liang if (!name) 196913d60ba0SKan Liang return -1; 197013d60ba0SKan Liang 1971c47a5599SJin Yao if (fnmatch(pattern, name, 0)) 1972c47a5599SJin Yao return -1; 1973c47a5599SJin Yao 1974c47a5599SJin Yao if (tok && !perf_pmu__valid_suffix(name, tok)) 1975c47a5599SJin Yao return -1; 1976c47a5599SJin Yao 1977c47a5599SJin Yao return 0; 1978c47a5599SJin Yao } 19791d3351e6SJin Yao 19801d3351e6SJin Yao int perf_pmu__cpus_match(struct perf_pmu *pmu, struct perf_cpu_map *cpus, 19811d3351e6SJin Yao struct perf_cpu_map **mcpus_ptr, 19821d3351e6SJin Yao struct perf_cpu_map **ucpus_ptr) 19831d3351e6SJin Yao { 19841d3351e6SJin Yao struct perf_cpu_map *pmu_cpus = pmu->cpus; 19851d3351e6SJin Yao struct perf_cpu_map *matched_cpus, *unmatched_cpus; 19866a12a63eSIan Rogers struct perf_cpu cpu; 19876a12a63eSIan Rogers int i, matched_nr = 0, unmatched_nr = 0; 19881d3351e6SJin Yao 19891d3351e6SJin Yao matched_cpus = perf_cpu_map__default_new(); 19901d3351e6SJin Yao if (!matched_cpus) 19911d3351e6SJin Yao return -1; 19921d3351e6SJin Yao 19931d3351e6SJin Yao unmatched_cpus = perf_cpu_map__default_new(); 19941d3351e6SJin Yao if (!unmatched_cpus) { 19951d3351e6SJin Yao perf_cpu_map__put(matched_cpus); 19961d3351e6SJin Yao return -1; 19971d3351e6SJin Yao } 19981d3351e6SJin Yao 19996a12a63eSIan Rogers perf_cpu_map__for_each_cpu(cpu, i, cpus) { 20006a12a63eSIan Rogers if (!perf_cpu_map__has(pmu_cpus, cpu)) 20016a12a63eSIan Rogers unmatched_cpus->map[unmatched_nr++] = cpu; 20021d3351e6SJin Yao else 20036a12a63eSIan Rogers matched_cpus->map[matched_nr++] = cpu; 20041d3351e6SJin Yao } 20051d3351e6SJin Yao 20061d3351e6SJin Yao unmatched_cpus->nr = unmatched_nr; 20071d3351e6SJin Yao matched_cpus->nr = matched_nr; 20081d3351e6SJin Yao *mcpus_ptr = matched_cpus; 20091d3351e6SJin Yao *ucpus_ptr = unmatched_cpus; 20101d3351e6SJin Yao return 0; 20111d3351e6SJin Yao } 2012