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> 7cd82a32eSJiri Olsa #include <sys/types.h> 8c23c2a0fSArnaldo Carvalho de Melo #include <fcntl.h> 97a8ef4c4SArnaldo Carvalho de Melo #include <sys/stat.h> 10cd82a32eSJiri Olsa #include <unistd.h> 11cd82a32eSJiri Olsa #include <stdio.h> 12dc0a6202SAdrian Hunter #include <stdbool.h> 13cd82a32eSJiri Olsa #include <dirent.h> 14cd0cfad7SBorislav Petkov #include <api/fs/fs.h> 15410136f5SStephane Eranian #include <locale.h> 16c47a5599SJin Yao #include <fnmatch.h> 17acef233bSJing Zhang #include <math.h> 185e51b0bbSArnaldo Carvalho de Melo #include "debug.h" 19e12ee9f7SAdrian Hunter #include "evsel.h" 20cd82a32eSJiri Olsa #include "pmu.h" 21336b92daSRavi Bangoria #include "pmus.h" 22c7e97f21SNamhyung Kim #include <util/pmu-bison.h> 23c7e97f21SNamhyung Kim #include <util/pmu-flex.h> 24cd82a32eSJiri Olsa #include "parse-events.h" 25e5c6109fSIan Rogers #include "print-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" 306593f019SJames Clark #include "util/evsel_config.h" 31cd82a32eSJiri Olsa 32e46fc8d9SArnaldo Carvalho de Melo struct perf_pmu perf_pmu__fake; 33e46fc8d9SArnaldo Carvalho de Melo 34c3245d20SIan Rogers #define UNIT_MAX_LEN 31 /* max length for event unit name */ 35c3245d20SIan Rogers 36c3245d20SIan Rogers /** 37c3245d20SIan Rogers * struct perf_pmu_alias - An event either read from sysfs or builtin in 38c3245d20SIan Rogers * pmu-events.c, created by parsing the pmu-events json files. 39c3245d20SIan Rogers */ 40c3245d20SIan Rogers struct perf_pmu_alias { 41c3245d20SIan Rogers /** @name: Name of the event like "mem-loads". */ 42c3245d20SIan Rogers char *name; 43c3245d20SIan Rogers /** @desc: Optional short description of the event. */ 44c3245d20SIan Rogers char *desc; 45c3245d20SIan Rogers /** @long_desc: Optional long description. */ 46c3245d20SIan Rogers char *long_desc; 47c3245d20SIan Rogers /** 48c3245d20SIan Rogers * @topic: Optional topic such as cache or pipeline, particularly for 49c3245d20SIan Rogers * json events. 50c3245d20SIan Rogers */ 51c3245d20SIan Rogers char *topic; 52c3245d20SIan Rogers /** 53c3245d20SIan Rogers * @str: Comma separated parameter list like 54c3245d20SIan Rogers * "event=0xcd,umask=0x1,ldlat=0x3". 55c3245d20SIan Rogers */ 56c3245d20SIan Rogers char *str; 57c3245d20SIan Rogers /** @terms: Owned list of the original parsed parameters. */ 58c3245d20SIan Rogers struct list_head terms; 59c3245d20SIan Rogers /** @list: List element of struct perf_pmu aliases. */ 60c3245d20SIan Rogers struct list_head list; 61c3245d20SIan Rogers /** @unit: Units for the event, such as bytes or cache lines. */ 62c3245d20SIan Rogers char unit[UNIT_MAX_LEN+1]; 63c3245d20SIan Rogers /** @scale: Value to scale read counter values by. */ 64c3245d20SIan Rogers double scale; 65c3245d20SIan Rogers /** 66c3245d20SIan Rogers * @per_pkg: Does the file 67c3245d20SIan Rogers * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.per-pkg or 68c3245d20SIan Rogers * equivalent json value exist and have the value 1. 69c3245d20SIan Rogers */ 70c3245d20SIan Rogers bool per_pkg; 71c3245d20SIan Rogers /** 72c3245d20SIan Rogers * @snapshot: Does the file 73c3245d20SIan Rogers * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.snapshot 74c3245d20SIan Rogers * exist and have the value 1. 75c3245d20SIan Rogers */ 76c3245d20SIan Rogers bool snapshot; 77c3245d20SIan Rogers /** 78c3245d20SIan Rogers * @deprecated: Is the event hidden and so not shown in perf list by 79c3245d20SIan Rogers * default. 80c3245d20SIan Rogers */ 81c3245d20SIan Rogers bool deprecated; 82c3245d20SIan Rogers /** 83c3245d20SIan Rogers * @pmu_name: The name copied from the json struct pmu_event. This can 84c3245d20SIan Rogers * differ from the PMU name as it won't have suffixes. 85c3245d20SIan Rogers */ 86c3245d20SIan Rogers char *pmu_name; 87c3245d20SIan Rogers }; 88c3245d20SIan Rogers 89fe13d43dSIan Rogers /** 90fe13d43dSIan Rogers * struct perf_pmu_format - Values from a format file read from 91fe13d43dSIan Rogers * <sysfs>/devices/cpu/format/ held in struct perf_pmu. 92fe13d43dSIan Rogers * 93fe13d43dSIan Rogers * For example, the contents of <sysfs>/devices/cpu/format/event may be 94fe13d43dSIan Rogers * "config:0-7" and will be represented here as name="event", 95fe13d43dSIan Rogers * value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set. 96fe13d43dSIan Rogers */ 97ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 9850402641SIan Rogers /** @list: Element on list within struct perf_pmu. */ 9950402641SIan Rogers struct list_head list; 10050402641SIan Rogers /** @bits: Which config bits are set by this format value. */ 10150402641SIan Rogers DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 102fe13d43dSIan Rogers /** @name: The modifier/file name. */ 103ab1bf653SArnaldo Carvalho de Melo char *name; 104fe13d43dSIan Rogers /** 105fe13d43dSIan Rogers * @value : Which config value the format relates to. Supported values 106fe13d43dSIan Rogers * are from PERF_PMU_FORMAT_VALUE_CONFIG to 107fe13d43dSIan Rogers * PERF_PMU_FORMAT_VALUE_CONFIG_END. 108fe13d43dSIan Rogers */ 10950402641SIan Rogers u16 value; 11050402641SIan Rogers /** @loaded: Has the contents been loaded/parsed. */ 11150402641SIan Rogers bool loaded; 112ab1bf653SArnaldo Carvalho de Melo }; 113ab1bf653SArnaldo Carvalho de Melo 11450402641SIan Rogers static struct perf_pmu_format *perf_pmu__new_format(struct list_head *list, char *name) 11550402641SIan Rogers { 11650402641SIan Rogers struct perf_pmu_format *format; 11750402641SIan Rogers 11850402641SIan Rogers format = zalloc(sizeof(*format)); 11950402641SIan Rogers if (!format) 12050402641SIan Rogers return NULL; 12150402641SIan Rogers 12250402641SIan Rogers format->name = strdup(name); 12350402641SIan Rogers if (!format->name) { 12450402641SIan Rogers free(format); 12550402641SIan Rogers return NULL; 12650402641SIan Rogers } 12750402641SIan Rogers list_add_tail(&format->list, list); 12850402641SIan Rogers return format; 12950402641SIan Rogers } 13050402641SIan Rogers 13150402641SIan Rogers /* Called at the end of parsing a format. */ 13250402641SIan Rogers void perf_pmu_format__set_value(void *vformat, int config, unsigned long *bits) 13350402641SIan Rogers { 13450402641SIan Rogers struct perf_pmu_format *format = vformat; 13550402641SIan Rogers 13650402641SIan Rogers format->value = config; 13750402641SIan Rogers memcpy(format->bits, bits, sizeof(format->bits)); 13850402641SIan Rogers } 13950402641SIan Rogers 14050402641SIan Rogers static void __perf_pmu_format__load(struct perf_pmu_format *format, FILE *file) 14150402641SIan Rogers { 14250402641SIan Rogers void *scanner; 14350402641SIan Rogers int ret; 14450402641SIan Rogers 14550402641SIan Rogers ret = perf_pmu_lex_init(&scanner); 14650402641SIan Rogers if (ret) 14750402641SIan Rogers return; 14850402641SIan Rogers 14950402641SIan Rogers perf_pmu_set_in(file, scanner); 15050402641SIan Rogers ret = perf_pmu_parse(format, scanner); 15150402641SIan Rogers perf_pmu_lex_destroy(scanner); 15250402641SIan Rogers format->loaded = true; 15350402641SIan Rogers } 15450402641SIan Rogers 15550402641SIan Rogers static void perf_pmu_format__load(struct perf_pmu *pmu, struct perf_pmu_format *format) 15650402641SIan Rogers { 15750402641SIan Rogers char path[PATH_MAX]; 15850402641SIan Rogers FILE *file = NULL; 15950402641SIan Rogers 16050402641SIan Rogers if (format->loaded) 16150402641SIan Rogers return; 16250402641SIan Rogers 16350402641SIan Rogers if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, "format")) 16450402641SIan Rogers return; 16550402641SIan Rogers 16650402641SIan Rogers assert(strlen(path) + strlen(format->name) + 2 < sizeof(path)); 16750402641SIan Rogers strcat(path, "/"); 16850402641SIan Rogers strcat(path, format->name); 16950402641SIan Rogers 17050402641SIan Rogers file = fopen(path, "r"); 17150402641SIan Rogers if (!file) 17250402641SIan Rogers return; 17350402641SIan Rogers __perf_pmu_format__load(format, file); 17450402641SIan Rogers fclose(file); 17550402641SIan Rogers } 17650402641SIan Rogers 177cd82a32eSJiri Olsa /* 178cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 179cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 180cd82a32eSJiri Olsa */ 18150402641SIan Rogers int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load) 182cd82a32eSJiri Olsa { 183cd82a32eSJiri Olsa struct dirent *evt_ent; 184cd82a32eSJiri Olsa DIR *format_dir; 185cd82a32eSJiri Olsa int ret = 0; 186cd82a32eSJiri Olsa 187e293a5e8SNamhyung Kim format_dir = fdopendir(dirfd); 188cd82a32eSJiri Olsa if (!format_dir) 189cd82a32eSJiri Olsa return -EINVAL; 190cd82a32eSJiri Olsa 19150402641SIan Rogers while ((evt_ent = readdir(format_dir)) != NULL) { 19250402641SIan Rogers struct perf_pmu_format *format; 193cd82a32eSJiri Olsa char *name = evt_ent->d_name; 194cd82a32eSJiri Olsa 195cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 196cd82a32eSJiri Olsa continue; 197cd82a32eSJiri Olsa 19850402641SIan Rogers format = perf_pmu__new_format(&pmu->format, name); 19950402641SIan Rogers if (!format) { 20050402641SIan Rogers ret = -ENOMEM; 201cd82a32eSJiri Olsa break; 20250402641SIan Rogers } 203cd82a32eSJiri Olsa 20450402641SIan Rogers if (eager_load) { 20550402641SIan Rogers FILE *file; 20650402641SIan Rogers int fd = openat(dirfd, name, O_RDONLY); 20750402641SIan Rogers 20850402641SIan Rogers if (fd < 0) { 20950402641SIan Rogers ret = -errno; 21050402641SIan Rogers break; 21150402641SIan Rogers } 2123d88aec0SIan Rogers file = fdopen(fd, "r"); 2133d88aec0SIan Rogers if (!file) { 2143d88aec0SIan Rogers close(fd); 2153d88aec0SIan Rogers break; 2163d88aec0SIan Rogers } 21750402641SIan Rogers __perf_pmu_format__load(format, file); 2183d88aec0SIan Rogers fclose(file); 2193d88aec0SIan Rogers } 220cd82a32eSJiri Olsa } 221cd82a32eSJiri Olsa 222cd82a32eSJiri Olsa closedir(format_dir); 223cd82a32eSJiri Olsa return ret; 224cd82a32eSJiri Olsa } 225cd82a32eSJiri Olsa 226cd82a32eSJiri Olsa /* 227cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 228cd82a32eSJiri Olsa * located at: 229cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 230cd82a32eSJiri Olsa */ 231838a8c5fSIan Rogers static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name) 232cd82a32eSJiri Olsa { 233e293a5e8SNamhyung Kim int fd; 234cd82a32eSJiri Olsa 235e293a5e8SNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "format", O_DIRECTORY); 236e293a5e8SNamhyung Kim if (fd < 0) 237d9664582SAndi Kleen return 0; 238cd82a32eSJiri Olsa 239e293a5e8SNamhyung Kim /* it'll close the fd */ 24050402641SIan Rogers if (perf_pmu__format_parse(pmu, fd, /*eager_load=*/false)) 241cd82a32eSJiri Olsa return -1; 242cd82a32eSJiri Olsa 243cd82a32eSJiri Olsa return 0; 244cd82a32eSJiri Olsa } 245cd82a32eSJiri Olsa 246a55ab7c4SJin Yao int perf_pmu__convert_scale(const char *scale, char **end, double *sval) 247d02fc6bcSAndi Kleen { 248d02fc6bcSAndi Kleen char *lc; 249d02fc6bcSAndi Kleen int ret = 0; 250d02fc6bcSAndi Kleen 251d02fc6bcSAndi Kleen /* 252d02fc6bcSAndi Kleen * save current locale 253d02fc6bcSAndi Kleen */ 254d02fc6bcSAndi Kleen lc = setlocale(LC_NUMERIC, NULL); 255d02fc6bcSAndi Kleen 256d02fc6bcSAndi Kleen /* 257d02fc6bcSAndi Kleen * The lc string may be allocated in static storage, 258d02fc6bcSAndi Kleen * so get a dynamic copy to make it survive setlocale 259d02fc6bcSAndi Kleen * call below. 260d02fc6bcSAndi Kleen */ 261d02fc6bcSAndi Kleen lc = strdup(lc); 262d02fc6bcSAndi Kleen if (!lc) { 263d02fc6bcSAndi Kleen ret = -ENOMEM; 264d02fc6bcSAndi Kleen goto out; 265d02fc6bcSAndi Kleen } 266d02fc6bcSAndi Kleen 267d02fc6bcSAndi Kleen /* 268d02fc6bcSAndi Kleen * force to C locale to ensure kernel 269d02fc6bcSAndi Kleen * scale string is converted correctly. 270d02fc6bcSAndi Kleen * kernel uses default C locale. 271d02fc6bcSAndi Kleen */ 272d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, "C"); 273d02fc6bcSAndi Kleen 274d02fc6bcSAndi Kleen *sval = strtod(scale, end); 275d02fc6bcSAndi Kleen 276d02fc6bcSAndi Kleen out: 277d02fc6bcSAndi Kleen /* restore locale */ 278d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, lc); 279d02fc6bcSAndi Kleen free(lc); 280d02fc6bcSAndi Kleen return ret; 281d02fc6bcSAndi Kleen } 282d02fc6bcSAndi Kleen 283*edb217ffSIan Rogers static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, int dirfd, const char *name) 284410136f5SStephane Eranian { 285410136f5SStephane Eranian struct stat st; 286410136f5SStephane Eranian ssize_t sret; 287410136f5SStephane Eranian char scale[128]; 288410136f5SStephane Eranian int fd, ret = -1; 289410136f5SStephane Eranian char path[PATH_MAX]; 290410136f5SStephane Eranian 291e293a5e8SNamhyung Kim scnprintf(path, PATH_MAX, "%s.scale", name); 292410136f5SStephane Eranian 293e293a5e8SNamhyung Kim fd = openat(dirfd, path, O_RDONLY); 294410136f5SStephane Eranian if (fd == -1) 295410136f5SStephane Eranian return -1; 296410136f5SStephane Eranian 297410136f5SStephane Eranian if (fstat(fd, &st) < 0) 298410136f5SStephane Eranian goto error; 299410136f5SStephane Eranian 300410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 301410136f5SStephane Eranian if (sret < 0) 302410136f5SStephane Eranian goto error; 303410136f5SStephane Eranian 3049ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 3059ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 3069ecae065SMadhavan Srinivasan else 307410136f5SStephane Eranian scale[sret] = '\0'; 3089ecae065SMadhavan Srinivasan 309a55ab7c4SJin Yao ret = perf_pmu__convert_scale(scale, NULL, &alias->scale); 310410136f5SStephane Eranian error: 311410136f5SStephane Eranian close(fd); 312410136f5SStephane Eranian return ret; 313410136f5SStephane Eranian } 314410136f5SStephane Eranian 315*edb217ffSIan Rogers static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, int dirfd, const char *name) 316410136f5SStephane Eranian { 317410136f5SStephane Eranian char path[PATH_MAX]; 318410136f5SStephane Eranian ssize_t sret; 319410136f5SStephane Eranian int fd; 320410136f5SStephane Eranian 321e293a5e8SNamhyung Kim scnprintf(path, PATH_MAX, "%s.unit", name); 322410136f5SStephane Eranian 323e293a5e8SNamhyung Kim fd = openat(dirfd, path, O_RDONLY); 324410136f5SStephane Eranian if (fd == -1) 325410136f5SStephane Eranian return -1; 326410136f5SStephane Eranian 327410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 328410136f5SStephane Eranian if (sret < 0) 329410136f5SStephane Eranian goto error; 330410136f5SStephane Eranian 331410136f5SStephane Eranian close(fd); 332410136f5SStephane Eranian 3339ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 3349ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 3359ecae065SMadhavan Srinivasan else 336410136f5SStephane Eranian alias->unit[sret] = '\0'; 337410136f5SStephane Eranian 338410136f5SStephane Eranian return 0; 339410136f5SStephane Eranian error: 340410136f5SStephane Eranian close(fd); 341410136f5SStephane Eranian alias->unit[0] = '\0'; 342410136f5SStephane Eranian return -1; 343410136f5SStephane Eranian } 344410136f5SStephane Eranian 345044330c1SMatt Fleming static int 346*edb217ffSIan Rogers perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, int dirfd, const char *name) 347044330c1SMatt Fleming { 348044330c1SMatt Fleming char path[PATH_MAX]; 349044330c1SMatt Fleming int fd; 350044330c1SMatt Fleming 351e293a5e8SNamhyung Kim scnprintf(path, PATH_MAX, "%s.per-pkg", name); 352044330c1SMatt Fleming 353e293a5e8SNamhyung Kim fd = openat(dirfd, path, O_RDONLY); 354044330c1SMatt Fleming if (fd == -1) 355044330c1SMatt Fleming return -1; 356044330c1SMatt Fleming 357044330c1SMatt Fleming close(fd); 358044330c1SMatt Fleming 359044330c1SMatt Fleming alias->per_pkg = true; 360044330c1SMatt Fleming return 0; 361044330c1SMatt Fleming } 362044330c1SMatt Fleming 3631d9e446bSJiri Olsa static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 364*edb217ffSIan Rogers int dirfd, const char *name) 3651d9e446bSJiri Olsa { 3661d9e446bSJiri Olsa char path[PATH_MAX]; 3671d9e446bSJiri Olsa int fd; 3681d9e446bSJiri Olsa 369e293a5e8SNamhyung Kim scnprintf(path, PATH_MAX, "%s.snapshot", name); 3701d9e446bSJiri Olsa 371e293a5e8SNamhyung Kim fd = openat(dirfd, path, O_RDONLY); 3721d9e446bSJiri Olsa if (fd == -1) 3731d9e446bSJiri Olsa return -1; 3741d9e446bSJiri Olsa 3751d9e446bSJiri Olsa alias->snapshot = true; 3761d9e446bSJiri Olsa close(fd); 3771d9e446bSJiri Olsa return 0; 3781d9e446bSJiri Olsa } 3791d9e446bSJiri Olsa 3806dde6429SThomas Richter static void perf_pmu_assign_str(char *name, const char *field, char **old_str, 3816dde6429SThomas Richter char **new_str) 3826dde6429SThomas Richter { 3836dde6429SThomas Richter if (!*old_str) 3846dde6429SThomas Richter goto set_new; 3856dde6429SThomas Richter 3866dde6429SThomas Richter if (*new_str) { /* Have new string, check with old */ 3876dde6429SThomas Richter if (strcasecmp(*old_str, *new_str)) 3886dde6429SThomas Richter pr_debug("alias %s differs in field '%s'\n", 3896dde6429SThomas Richter name, field); 3906dde6429SThomas Richter zfree(old_str); 3916dde6429SThomas Richter } else /* Nothing new --> keep old string */ 3926dde6429SThomas Richter return; 3936dde6429SThomas Richter set_new: 3946dde6429SThomas Richter *old_str = *new_str; 3956dde6429SThomas Richter *new_str = NULL; 3966dde6429SThomas Richter } 3976dde6429SThomas Richter 3986dde6429SThomas Richter static void perf_pmu_update_alias(struct perf_pmu_alias *old, 3996dde6429SThomas Richter struct perf_pmu_alias *newalias) 4006dde6429SThomas Richter { 4016dde6429SThomas Richter perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc); 4026dde6429SThomas Richter perf_pmu_assign_str(old->name, "long_desc", &old->long_desc, 4036dde6429SThomas Richter &newalias->long_desc); 4046dde6429SThomas Richter perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic); 4056dde6429SThomas Richter perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str); 4066dde6429SThomas Richter old->scale = newalias->scale; 4076dde6429SThomas Richter old->per_pkg = newalias->per_pkg; 4086dde6429SThomas Richter old->snapshot = newalias->snapshot; 4096dde6429SThomas Richter memcpy(old->unit, newalias->unit, sizeof(old->unit)); 4106dde6429SThomas Richter } 4116dde6429SThomas Richter 4126dde6429SThomas Richter /* Delete an alias entry. */ 413c3245d20SIan Rogers static void perf_pmu_free_alias(struct perf_pmu_alias *newalias) 4146dde6429SThomas Richter { 4156dde6429SThomas Richter zfree(&newalias->name); 4166dde6429SThomas Richter zfree(&newalias->desc); 4176dde6429SThomas Richter zfree(&newalias->long_desc); 4186dde6429SThomas Richter zfree(&newalias->topic); 4196dde6429SThomas Richter zfree(&newalias->str); 42032705de7SJin Yao zfree(&newalias->pmu_name); 4216dde6429SThomas Richter parse_events_terms__purge(&newalias->terms); 4226dde6429SThomas Richter free(newalias); 4236dde6429SThomas Richter } 4246dde6429SThomas Richter 425eec11310SNamhyung Kim static void perf_pmu__del_aliases(struct perf_pmu *pmu) 426eec11310SNamhyung Kim { 427eec11310SNamhyung Kim struct perf_pmu_alias *alias, *tmp; 428eec11310SNamhyung Kim 429eec11310SNamhyung Kim list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) { 430eec11310SNamhyung Kim list_del(&alias->list); 431eec11310SNamhyung Kim perf_pmu_free_alias(alias); 432eec11310SNamhyung Kim } 433eec11310SNamhyung Kim } 434eec11310SNamhyung Kim 4356dde6429SThomas Richter /* Merge an alias, search in alias list. If this name is already 4366dde6429SThomas Richter * present merge both of them to combine all information. 4376dde6429SThomas Richter */ 4386dde6429SThomas Richter static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias, 4396dde6429SThomas Richter struct list_head *alist) 4406dde6429SThomas Richter { 4416dde6429SThomas Richter struct perf_pmu_alias *a; 4426dde6429SThomas Richter 4436dde6429SThomas Richter list_for_each_entry(a, alist, list) { 4446dde6429SThomas Richter if (!strcasecmp(newalias->name, a->name)) { 44532705de7SJin Yao if (newalias->pmu_name && a->pmu_name && 44632705de7SJin Yao !strcasecmp(newalias->pmu_name, a->pmu_name)) { 44732705de7SJin Yao continue; 44832705de7SJin Yao } 4496dde6429SThomas Richter perf_pmu_update_alias(a, newalias); 4506dde6429SThomas Richter perf_pmu_free_alias(newalias); 4516dde6429SThomas Richter return true; 4526dde6429SThomas Richter } 4536dde6429SThomas Richter } 4546dde6429SThomas Richter return false; 4556dde6429SThomas Richter } 4566dde6429SThomas Richter 457*edb217ffSIan Rogers static int perf_pmu__new_alias(struct list_head *list, int dirfd, const char *name, 458*edb217ffSIan Rogers const char *desc, const char *val, FILE *val_fd, 459*edb217ffSIan Rogers const struct pmu_event *pe) 460a6146d50SZheng Yan { 4610c24d6fbSThomas Richter struct parse_events_term *term; 4625c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 463a6146d50SZheng Yan int ret; 4640c24d6fbSThomas Richter char newval[256]; 465330f40a0SIan Rogers const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL; 466bd680861SIan Rogers bool deprecated = false, perpkg = false; 467eab35953SJin Yao 468eab35953SJin Yao if (pe) { 469330f40a0SIan Rogers long_desc = pe->long_desc; 470330f40a0SIan Rogers topic = pe->topic; 471330f40a0SIan Rogers unit = pe->unit; 472bd680861SIan Rogers perpkg = pe->perpkg; 4739ed8b7dcSIan Rogers deprecated = pe->deprecated; 474330f40a0SIan Rogers pmu_name = pe->pmu; 475eab35953SJin Yao } 476a6146d50SZheng Yan 477a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 478a6146d50SZheng Yan if (!alias) 479a6146d50SZheng Yan return -ENOMEM; 480a6146d50SZheng Yan 481a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 482410136f5SStephane Eranian alias->scale = 1.0; 483410136f5SStephane Eranian alias->unit[0] = '\0'; 484bd680861SIan Rogers alias->per_pkg = perpkg; 48584530920SStephane Eranian alias->snapshot = false; 4869ed8b7dcSIan Rogers alias->deprecated = deprecated; 487410136f5SStephane Eranian 488*edb217ffSIan Rogers ret = parse_events_terms(&alias->terms, val, val_fd); 489a6146d50SZheng Yan if (ret) { 49070c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 491a6146d50SZheng Yan free(alias); 492a6146d50SZheng Yan return ret; 493a6146d50SZheng Yan } 494a6146d50SZheng Yan 4950c24d6fbSThomas Richter /* Scan event and remove leading zeroes, spaces, newlines, some 4960c24d6fbSThomas Richter * platforms have terms specified as 4970c24d6fbSThomas Richter * event=0x0091 (read from files ../<PMU>/events/<FILE> 4980c24d6fbSThomas Richter * and terms specified as event=0x91 (read from JSON files). 4990c24d6fbSThomas Richter * 5000c24d6fbSThomas Richter * Rebuild string to make alias->str member comparable. 5010c24d6fbSThomas Richter */ 5020c24d6fbSThomas Richter memset(newval, 0, sizeof(newval)); 5030c24d6fbSThomas Richter ret = 0; 5040c24d6fbSThomas Richter list_for_each_entry(term, &alias->terms, list) { 5050c24d6fbSThomas Richter if (ret) 5060c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 5070c24d6fbSThomas Richter ","); 5080c24d6fbSThomas Richter if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 5090c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 5100c24d6fbSThomas Richter "%s=%#x", term->config, term->val.num); 5110c24d6fbSThomas Richter else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 5120c24d6fbSThomas Richter ret += scnprintf(newval + ret, sizeof(newval) - ret, 5130c24d6fbSThomas Richter "%s=%s", term->config, term->val.str); 5140c24d6fbSThomas Richter } 5150c24d6fbSThomas Richter 516a6146d50SZheng Yan alias->name = strdup(name); 517e293a5e8SNamhyung Kim if (dirfd >= 0) { 518410136f5SStephane Eranian /* 519410136f5SStephane Eranian * load unit name and scale if available 520410136f5SStephane Eranian */ 521e293a5e8SNamhyung Kim perf_pmu__parse_unit(alias, dirfd, name); 522e293a5e8SNamhyung Kim perf_pmu__parse_scale(alias, dirfd, name); 523e293a5e8SNamhyung Kim perf_pmu__parse_per_pkg(alias, dirfd, name); 524e293a5e8SNamhyung Kim perf_pmu__parse_snapshot(alias, dirfd, name); 52570c646e0SSukadev Bhattiprolu } 526410136f5SStephane Eranian 52708e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 528c8d6828aSSukadev Bhattiprolu alias->long_desc = long_desc ? strdup(long_desc) : 529c8d6828aSSukadev Bhattiprolu desc ? strdup(desc) : NULL; 530dd5f1036SAndi Kleen alias->topic = topic ? strdup(topic) : NULL; 531fedb2b51SAndi Kleen if (unit) { 532330f40a0SIan Rogers if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) 533fedb2b51SAndi Kleen return -1; 534fedb2b51SAndi Kleen snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 535fedb2b51SAndi Kleen } 5360c24d6fbSThomas Richter alias->str = strdup(newval); 53732705de7SJin Yao alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; 538f2361024SAndi Kleen 5396dde6429SThomas Richter if (!perf_pmu_merge_alias(alias, list)) 540a6146d50SZheng Yan list_add_tail(&alias->list, list); 541410136f5SStephane Eranian 542a6146d50SZheng Yan return 0; 543a6146d50SZheng Yan } 544a6146d50SZheng Yan 54546441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 54646441bdcSMatt Fleming { 54746441bdcSMatt Fleming size_t len; 54846441bdcSMatt Fleming 54946441bdcSMatt Fleming len = strlen(name); 55046441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 55146441bdcSMatt Fleming return true; 55246441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 55346441bdcSMatt Fleming return true; 554044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 555044330c1SMatt Fleming return true; 5561d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 5571d9e446bSJiri Olsa return true; 55846441bdcSMatt Fleming 55946441bdcSMatt Fleming return false; 56046441bdcSMatt Fleming } 56146441bdcSMatt Fleming 562a6146d50SZheng Yan /* 563a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 564a6146d50SZheng Yan * specified in 'dir' parameter. 565a6146d50SZheng Yan */ 566e293a5e8SNamhyung Kim static int pmu_aliases_parse(int dirfd, struct list_head *head) 567a6146d50SZheng Yan { 568a6146d50SZheng Yan struct dirent *evt_ent; 569a6146d50SZheng Yan DIR *event_dir; 570e293a5e8SNamhyung Kim int fd; 571a6146d50SZheng Yan 572e293a5e8SNamhyung Kim event_dir = fdopendir(dirfd); 573a6146d50SZheng Yan if (!event_dir) 574a6146d50SZheng Yan return -EINVAL; 575a6146d50SZheng Yan 576940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 577a6146d50SZheng Yan char *name = evt_ent->d_name; 578a6146d50SZheng Yan FILE *file; 579a6146d50SZheng Yan 580a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 581a6146d50SZheng Yan continue; 582a6146d50SZheng Yan 583410136f5SStephane Eranian /* 58446441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 585410136f5SStephane Eranian */ 58646441bdcSMatt Fleming if (pmu_alias_info_file(name)) 587410136f5SStephane Eranian continue; 588410136f5SStephane Eranian 589e293a5e8SNamhyung Kim fd = openat(dirfd, name, O_RDONLY); 5900ea8920eSIan Rogers if (fd == -1) { 5910ea8920eSIan Rogers pr_debug("Cannot open %s\n", name); 5920ea8920eSIan Rogers continue; 5930ea8920eSIan Rogers } 594e293a5e8SNamhyung Kim file = fdopen(fd, "r"); 595940db6dcSAndi Kleen if (!file) { 5960ea8920eSIan Rogers close(fd); 597940db6dcSAndi Kleen continue; 598940db6dcSAndi Kleen } 599410136f5SStephane Eranian 600*edb217ffSIan Rogers if (perf_pmu__new_alias(head, dirfd, name, /*desc=*/ NULL, 601*edb217ffSIan Rogers /*val=*/ NULL, file, /*pe=*/ NULL) < 0) 602940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 603a6146d50SZheng Yan fclose(file); 604a6146d50SZheng Yan } 605a6146d50SZheng Yan 606a6146d50SZheng Yan closedir(event_dir); 607940db6dcSAndi Kleen return 0; 608a6146d50SZheng Yan } 609a6146d50SZheng Yan 610a6146d50SZheng Yan /* 611a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 612a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 613a6146d50SZheng Yan */ 614838a8c5fSIan Rogers static int pmu_aliases(struct perf_pmu *pmu, int dirfd, const char *name) 615a6146d50SZheng Yan { 616e293a5e8SNamhyung Kim int fd; 617a6146d50SZheng Yan 618e293a5e8SNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "events", O_DIRECTORY); 619e293a5e8SNamhyung Kim if (fd < 0) 620d9664582SAndi Kleen return 0; 621a6146d50SZheng Yan 622e293a5e8SNamhyung Kim /* it'll close the fd */ 623838a8c5fSIan Rogers if (pmu_aliases_parse(fd, &pmu->aliases)) 624a6146d50SZheng Yan return -1; 625a6146d50SZheng Yan 626a6146d50SZheng Yan return 0; 627a6146d50SZheng Yan } 628a6146d50SZheng Yan 6295c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 630a6146d50SZheng Yan struct list_head *terms) 631a6146d50SZheng Yan { 6327c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 633a6146d50SZheng Yan LIST_HEAD(list); 634a6146d50SZheng Yan int ret; 635a6146d50SZheng Yan 636a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 6377c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 638a6146d50SZheng Yan if (ret) { 639682dc24cSArnaldo Carvalho de Melo parse_events_terms__purge(&list); 640a6146d50SZheng Yan return ret; 641a6146d50SZheng Yan } 642c2f1ceadSAndi Kleen /* 643c2f1ceadSAndi Kleen * Weak terms don't override command line options, 644c2f1ceadSAndi Kleen * which we don't want for implicit terms in aliases. 645c2f1ceadSAndi Kleen */ 646c2f1ceadSAndi Kleen cloned->weak = true; 6477c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 648a6146d50SZheng Yan } 649a6146d50SZheng Yan list_splice(&list, terms); 650a6146d50SZheng Yan return 0; 651a6146d50SZheng Yan } 652a6146d50SZheng Yan 65366ec1191SMark Rutland /* 65466ec1191SMark Rutland * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 65566ec1191SMark Rutland * may have a "cpus" file. 65666ec1191SMark Rutland */ 657d06593aaSIan Rogers static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core) 6587ae92e74SYan, Zheng { 659f854839bSJiri Olsa struct perf_cpu_map *cpus; 6607e3fcffeSMark Rutland const char *templates[] = { 661d50a79cdSJames Clark "cpumask", 662d50a79cdSJames Clark "cpus", 6637e3fcffeSMark Rutland NULL 6647e3fcffeSMark Rutland }; 6657e3fcffeSMark Rutland const char **template; 666d50a79cdSJames Clark char pmu_name[PATH_MAX]; 667d50a79cdSJames Clark struct perf_pmu pmu = {.name = pmu_name}; 668d50a79cdSJames Clark FILE *file; 6697ae92e74SYan, Zheng 670d50a79cdSJames Clark strlcpy(pmu_name, name, sizeof(pmu_name)); 6717e3fcffeSMark Rutland for (template = templates; *template; template++) { 6723a69672eSNamhyung Kim file = perf_pmu__open_file_at(&pmu, dirfd, *template); 673d50a79cdSJames Clark if (!file) 674d50a79cdSJames Clark continue; 675d50a79cdSJames Clark cpus = perf_cpu_map__read(file); 6763a69672eSNamhyung Kim fclose(file); 67766ec1191SMark Rutland if (cpus) 67866ec1191SMark Rutland return cpus; 6797e3fcffeSMark Rutland } 6807ae92e74SYan, Zheng 681d06593aaSIan Rogers /* Nothing found, for core PMUs assume this means all CPUs. */ 682d06593aaSIan Rogers return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL; 68366ec1191SMark Rutland } 6847ae92e74SYan, Zheng 6853a69672eSNamhyung Kim static bool pmu_is_uncore(int dirfd, const char *name) 68666ec1191SMark Rutland { 6873a69672eSNamhyung Kim int fd; 6887ae92e74SYan, Zheng 6893a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH); 6903a69672eSNamhyung Kim if (fd < 0) 6913a69672eSNamhyung Kim return false; 6923a69672eSNamhyung Kim 6933a69672eSNamhyung Kim close(fd); 6943a69672eSNamhyung Kim return true; 6957ae92e74SYan, Zheng } 6967ae92e74SYan, Zheng 69751d54847SJohn Garry static char *pmu_id(const char *name) 69851d54847SJohn Garry { 69951d54847SJohn Garry char path[PATH_MAX], *str; 70051d54847SJohn Garry size_t len; 70151d54847SJohn Garry 7025f2c8efaSJames Clark perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier"); 70351d54847SJohn Garry 7045f2c8efaSJames Clark if (filename__read_str(path, &str, &len) < 0) 70551d54847SJohn Garry return NULL; 70651d54847SJohn Garry 70751d54847SJohn Garry str[len - 1] = 0; /* remove line feed */ 70851d54847SJohn Garry 70951d54847SJohn Garry return str; 71051d54847SJohn Garry } 71151d54847SJohn Garry 7124bf7e81aSIan Rogers /** 7134bf7e81aSIan Rogers * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in 7144bf7e81aSIan Rogers * sysfs on some platforms like ARM or Intel hybrid. Looking for 7154bf7e81aSIan Rogers * possible the cpus file in sysfs files to identify whether this is a 7164bf7e81aSIan Rogers * core device. 7174bf7e81aSIan Rogers * @name: The PMU name such as "cpu_atom". 71814b22ae0SGanapatrao Kulkarni */ 7194bf7e81aSIan Rogers static int is_sysfs_pmu_core(const char *name) 72014b22ae0SGanapatrao Kulkarni { 72114b22ae0SGanapatrao Kulkarni char path[PATH_MAX]; 72214b22ae0SGanapatrao Kulkarni 723f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus")) 72414b22ae0SGanapatrao Kulkarni return 0; 725d9664582SAndi Kleen return file_available(path); 72614b22ae0SGanapatrao Kulkarni } 72714b22ae0SGanapatrao Kulkarni 72829be2fe0SIan Rogers char *perf_pmu__getcpuid(struct perf_pmu *pmu) 729d77ade9fSAndi Kleen { 730d77ade9fSAndi Kleen char *cpuid; 731d77ade9fSAndi Kleen static bool printed; 732d77ade9fSAndi Kleen 733d77ade9fSAndi Kleen cpuid = getenv("PERF_CPUID"); 734d77ade9fSAndi Kleen if (cpuid) 735d77ade9fSAndi Kleen cpuid = strdup(cpuid); 736d77ade9fSAndi Kleen if (!cpuid) 73754e32dc0SGanapatrao Kulkarni cpuid = get_cpuid_str(pmu); 738d77ade9fSAndi Kleen if (!cpuid) 739d77ade9fSAndi Kleen return NULL; 740d77ade9fSAndi Kleen 741d77ade9fSAndi Kleen if (!printed) { 742d77ade9fSAndi Kleen pr_debug("Using CPUID %s\n", cpuid); 743d77ade9fSAndi Kleen printed = true; 744d77ade9fSAndi Kleen } 745d77ade9fSAndi Kleen return cpuid; 746d77ade9fSAndi Kleen } 747d77ade9fSAndi Kleen 7481ba3752aSIan Rogers __weak const struct pmu_events_table *pmu_events_table__find(void) 749e126bef5SJohn Garry { 75096d2a746SIan Rogers return perf_pmu__find_events_table(NULL); 751e126bef5SJohn Garry } 752e126bef5SJohn Garry 753f8ea2c15SIan Rogers __weak const struct pmu_metrics_table *pmu_metrics_table__find(void) 754f8ea2c15SIan Rogers { 755f8ea2c15SIan Rogers return perf_pmu__find_metrics_table(NULL); 756f8ea2c15SIan Rogers } 757f8ea2c15SIan Rogers 758240e6fd0SIan Rogers /** 759240e6fd0SIan Rogers * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any 760240e6fd0SIan Rogers * trailing suffix? The Suffix must be in form 761240e6fd0SIan Rogers * tok_{digits}, or tok{digits}. 762240e6fd0SIan Rogers * @pmu_name: The pmu_name with possible suffix. 763240e6fd0SIan Rogers * @tok: The possible match to pmu_name without suffix. 764c07d5c92SJohn Garry */ 765240e6fd0SIan Rogers static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok) 766c47a5599SJin Yao { 767c07d5c92SJohn Garry const char *p; 768c47a5599SJin Yao 769c47a5599SJin Yao if (strncmp(pmu_name, tok, strlen(tok))) 770c47a5599SJin Yao return false; 771c47a5599SJin Yao 772c47a5599SJin Yao p = pmu_name + strlen(tok); 773c47a5599SJin Yao if (*p == 0) 774c47a5599SJin Yao return true; 775c47a5599SJin Yao 776c07d5c92SJohn Garry if (*p == '_') 777c47a5599SJin Yao ++p; 778c07d5c92SJohn Garry 779c07d5c92SJohn Garry /* Ensure we end in a number */ 780c07d5c92SJohn Garry while (1) { 781c07d5c92SJohn Garry if (!isdigit(*p)) 782c47a5599SJin Yao return false; 783c07d5c92SJohn Garry if (*(++p) == 0) 784c07d5c92SJohn Garry break; 785c07d5c92SJohn Garry } 786c47a5599SJin Yao 787c47a5599SJin Yao return true; 788c47a5599SJin Yao } 789c47a5599SJin Yao 790240e6fd0SIan Rogers /** 791240e6fd0SIan Rogers * pmu_uncore_alias_match - does name match the PMU name? 792240e6fd0SIan Rogers * @pmu_name: the json struct pmu_event name. This may lack a suffix (which 793240e6fd0SIan Rogers * matches) or be of the form "socket,pmuname" which will match 794240e6fd0SIan Rogers * "socketX_pmunameY". 795240e6fd0SIan Rogers * @name: a real full PMU name as from sysfs. 796240e6fd0SIan Rogers */ 797240e6fd0SIan Rogers static bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 798730670b1SJohn Garry { 799730670b1SJohn Garry char *tmp = NULL, *tok, *str; 800730670b1SJohn Garry bool res; 801730670b1SJohn Garry 802240e6fd0SIan Rogers if (strchr(pmu_name, ',') == NULL) 803240e6fd0SIan Rogers return perf_pmu__match_ignoring_suffix(name, pmu_name); 804240e6fd0SIan Rogers 805730670b1SJohn Garry str = strdup(pmu_name); 806730670b1SJohn Garry if (!str) 807730670b1SJohn Garry return false; 808730670b1SJohn Garry 809730670b1SJohn Garry /* 810730670b1SJohn Garry * uncore alias may be from different PMU with common prefix 811730670b1SJohn Garry */ 812730670b1SJohn Garry tok = strtok_r(str, ",", &tmp); 813730670b1SJohn Garry if (strncmp(pmu_name, tok, strlen(tok))) { 814730670b1SJohn Garry res = false; 815730670b1SJohn Garry goto out; 816730670b1SJohn Garry } 817730670b1SJohn Garry 818730670b1SJohn Garry /* 819730670b1SJohn Garry * Match more complex aliases where the alias name is a comma-delimited 820730670b1SJohn Garry * list of tokens, orderly contained in the matching PMU name. 821730670b1SJohn Garry * 822730670b1SJohn Garry * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 823730670b1SJohn Garry * match "socket" in "socketX_pmunameY" and then "pmuname" in 824730670b1SJohn Garry * "pmunameY". 825730670b1SJohn Garry */ 826c07d5c92SJohn Garry while (1) { 827c07d5c92SJohn Garry char *next_tok = strtok_r(NULL, ",", &tmp); 828c07d5c92SJohn Garry 829730670b1SJohn Garry name = strstr(name, tok); 830c07d5c92SJohn Garry if (!name || 831240e6fd0SIan Rogers (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) { 832730670b1SJohn Garry res = false; 833730670b1SJohn Garry goto out; 834730670b1SJohn Garry } 835c07d5c92SJohn Garry if (!next_tok) 836c07d5c92SJohn Garry break; 837c07d5c92SJohn Garry tok = next_tok; 838c07d5c92SJohn Garry name += strlen(tok); 839730670b1SJohn Garry } 840730670b1SJohn Garry 841730670b1SJohn Garry res = true; 842730670b1SJohn Garry out: 843730670b1SJohn Garry free(str); 844730670b1SJohn Garry return res; 845730670b1SJohn Garry } 846730670b1SJohn Garry 847660842e4SIan Rogers static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, 8481ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 849660842e4SIan Rogers void *vdata) 850660842e4SIan Rogers { 851e3edd6cfSIan Rogers struct list_head *head = vdata; 852660842e4SIan Rogers 853660842e4SIan Rogers /* need type casts to override 'const' */ 854*edb217ffSIan Rogers perf_pmu__new_alias(head, -1, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe); 855660842e4SIan Rogers return 0; 856660842e4SIan Rogers } 857660842e4SIan Rogers 858933f82ffSSukadev Bhattiprolu /* 859d685819bSIan Rogers * From the pmu_events_table, find the events that correspond to the given 860d685819bSIan Rogers * PMU and add them to the list 'head'. 861933f82ffSSukadev Bhattiprolu */ 862838a8c5fSIan Rogers void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table) 863933f82ffSSukadev Bhattiprolu { 864e3edd6cfSIan Rogers pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, &pmu->aliases); 865933f82ffSSukadev Bhattiprolu } 866933f82ffSSukadev Bhattiprolu 867838a8c5fSIan Rogers static void pmu_add_cpu_aliases(struct perf_pmu *pmu) 868e45ad701SJohn Garry { 8691ba3752aSIan Rogers const struct pmu_events_table *table; 870e45ad701SJohn Garry 87196d2a746SIan Rogers table = perf_pmu__find_events_table(pmu); 872eeac7730SIan Rogers if (!table) 873e45ad701SJohn Garry return; 874e45ad701SJohn Garry 875838a8c5fSIan Rogers pmu_add_cpu_aliases_table(pmu, table); 876e45ad701SJohn Garry } 877e45ad701SJohn Garry 8784513c719SJohn Garry struct pmu_sys_event_iter_data { 8794513c719SJohn Garry struct list_head *head; 8804513c719SJohn Garry struct perf_pmu *pmu; 8814513c719SJohn Garry }; 8824513c719SJohn Garry 88329be2fe0SIan Rogers static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, 8841ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 88529be2fe0SIan Rogers void *data) 8864513c719SJohn Garry { 8874513c719SJohn Garry struct pmu_sys_event_iter_data *idata = data; 8884513c719SJohn Garry struct perf_pmu *pmu = idata->pmu; 8894513c719SJohn Garry 8904513c719SJohn Garry if (!pe->compat || !pe->pmu) 8914513c719SJohn Garry return 0; 8924513c719SJohn Garry 8934513c719SJohn Garry if (!strcmp(pmu->id, pe->compat) && 8944513c719SJohn Garry pmu_uncore_alias_match(pe->pmu, pmu->name)) { 895*edb217ffSIan Rogers perf_pmu__new_alias(idata->head, -1, 896*edb217ffSIan Rogers pe->name, 897*edb217ffSIan Rogers pe->desc, 898*edb217ffSIan Rogers pe->event, 899*edb217ffSIan Rogers /*val_fd=*/ NULL, 900eab35953SJin Yao pe); 9014513c719SJohn Garry } 9024513c719SJohn Garry 9034513c719SJohn Garry return 0; 9044513c719SJohn Garry } 9054513c719SJohn Garry 906838a8c5fSIan Rogers void pmu_add_sys_aliases(struct perf_pmu *pmu) 9074513c719SJohn Garry { 9084513c719SJohn Garry struct pmu_sys_event_iter_data idata = { 909838a8c5fSIan Rogers .head = &pmu->aliases, 9104513c719SJohn Garry .pmu = pmu, 9114513c719SJohn Garry }; 9124513c719SJohn Garry 9134513c719SJohn Garry if (!pmu->id) 9144513c719SJohn Garry return; 9154513c719SJohn Garry 9164513c719SJohn Garry pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata); 9174513c719SJohn Garry } 9184513c719SJohn Garry 919c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 920dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 921dc0a6202SAdrian Hunter { 922dc0a6202SAdrian Hunter return NULL; 923dc0a6202SAdrian Hunter } 924dc0a6202SAdrian Hunter 92513d60ba0SKan Liang char * __weak 92613d60ba0SKan Liang pmu_find_real_name(const char *name) 92713d60ba0SKan Liang { 92813d60ba0SKan Liang return (char *)name; 92913d60ba0SKan Liang } 93013d60ba0SKan Liang 93113d60ba0SKan Liang char * __weak 93213d60ba0SKan Liang pmu_find_alias_name(const char *name __maybe_unused) 93313d60ba0SKan Liang { 93413d60ba0SKan Liang return NULL; 93513d60ba0SKan Liang } 93613d60ba0SKan Liang 9373a69672eSNamhyung Kim static int pmu_max_precise(int dirfd, struct perf_pmu *pmu) 93890a86bdeSJiri Olsa { 93990a86bdeSJiri Olsa int max_precise = -1; 94090a86bdeSJiri Olsa 9413a69672eSNamhyung Kim perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise); 94290a86bdeSJiri Olsa return max_precise; 94390a86bdeSJiri Olsa } 94490a86bdeSJiri Olsa 9451eaf496eSIan Rogers struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *lookup_name) 946cd82a32eSJiri Olsa { 947cd82a32eSJiri Olsa struct perf_pmu *pmu; 948cd82a32eSJiri Olsa __u32 type; 94913d60ba0SKan Liang char *name = pmu_find_real_name(lookup_name); 95013d60ba0SKan Liang char *alias_name; 95149afa7f6SJin Yao 952cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 953cd82a32eSJiri Olsa if (!pmu) 954cd82a32eSJiri Olsa return NULL; 955cd82a32eSJiri Olsa 956838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->format); 957838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->aliases); 958838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->caps); 959838a8c5fSIan Rogers /* 960838a8c5fSIan Rogers * The pmu data we store & need consists of the pmu 961838a8c5fSIan Rogers * type value and format definitions. Load both right 962838a8c5fSIan Rogers * now. 963838a8c5fSIan Rogers */ 964838a8c5fSIan Rogers if (pmu_format(pmu, dirfd, name)) { 965838a8c5fSIan Rogers free(pmu); 966838a8c5fSIan Rogers return NULL; 967838a8c5fSIan Rogers } 968838a8c5fSIan Rogers /* 969838a8c5fSIan Rogers * Check the aliases first to avoid unnecessary work. 970838a8c5fSIan Rogers */ 971838a8c5fSIan Rogers if (pmu_aliases(pmu, dirfd, name)) { 972838a8c5fSIan Rogers free(pmu); 973838a8c5fSIan Rogers return NULL; 974838a8c5fSIan Rogers } 975d06593aaSIan Rogers pmu->is_core = is_pmu_core(name); 976d06593aaSIan Rogers pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core); 97754e32dc0SGanapatrao Kulkarni pmu->name = strdup(name); 97813d60ba0SKan Liang if (!pmu->name) 97913d60ba0SKan Liang goto err; 98013d60ba0SKan Liang 981f8ad6018SJames Clark /* Read type, and ensure that type value is successfully assigned (return 1) */ 9823a69672eSNamhyung Kim if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1) 983f8ad6018SJames Clark goto err; 984f8ad6018SJames Clark 98513d60ba0SKan Liang alias_name = pmu_find_alias_name(name); 98613d60ba0SKan Liang if (alias_name) { 98713d60ba0SKan Liang pmu->alias_name = strdup(alias_name); 98813d60ba0SKan Liang if (!pmu->alias_name) 98913d60ba0SKan Liang goto err; 99013d60ba0SKan Liang } 99113d60ba0SKan Liang 99254e32dc0SGanapatrao Kulkarni pmu->type = type; 9933a69672eSNamhyung Kim pmu->is_uncore = pmu_is_uncore(dirfd, name); 99451d54847SJohn Garry if (pmu->is_uncore) 99551d54847SJohn Garry pmu->id = pmu_id(name); 9963a69672eSNamhyung Kim pmu->max_precise = pmu_max_precise(dirfd, pmu); 997838a8c5fSIan Rogers pmu_add_cpu_aliases(pmu); 998838a8c5fSIan Rogers pmu_add_sys_aliases(pmu); 9991eaf496eSIan Rogers list_add_tail(&pmu->list, pmus); 1000dc0a6202SAdrian Hunter 1001dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 1002dc0a6202SAdrian Hunter 1003cd82a32eSJiri Olsa return pmu; 100413d60ba0SKan Liang err: 1005efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 100613d60ba0SKan Liang free(pmu); 100713d60ba0SKan Liang return NULL; 1008cd82a32eSJiri Olsa } 1009cd82a32eSJiri Olsa 1010628eaa4eSIan Rogers /* Creates the PMU when sysfs scanning fails. */ 1011628eaa4eSIan Rogers struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus) 1012628eaa4eSIan Rogers { 1013628eaa4eSIan Rogers struct perf_pmu *pmu = zalloc(sizeof(*pmu)); 1014628eaa4eSIan Rogers 1015628eaa4eSIan Rogers if (!pmu) 1016628eaa4eSIan Rogers return NULL; 1017628eaa4eSIan Rogers 1018628eaa4eSIan Rogers pmu->name = strdup("cpu"); 1019628eaa4eSIan Rogers if (!pmu->name) { 1020628eaa4eSIan Rogers free(pmu); 1021628eaa4eSIan Rogers return NULL; 1022628eaa4eSIan Rogers } 1023628eaa4eSIan Rogers 1024628eaa4eSIan Rogers pmu->is_core = true; 1025628eaa4eSIan Rogers pmu->type = PERF_TYPE_RAW; 1026628eaa4eSIan Rogers pmu->cpus = cpu_map__online(); 1027628eaa4eSIan Rogers 1028628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->format); 1029628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->aliases); 1030628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->caps); 1031628eaa4eSIan Rogers list_add_tail(&pmu->list, core_pmus); 1032628eaa4eSIan Rogers return pmu; 1033628eaa4eSIan Rogers } 1034628eaa4eSIan Rogers 1035e552b7beSRob Herring void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1036e552b7beSRob Herring { 1037e552b7beSRob Herring struct perf_pmu_format *format; 1038e552b7beSRob Herring 103968c25043SIan Rogers if (pmu->formats_checked) 104068c25043SIan Rogers return; 104168c25043SIan Rogers 104268c25043SIan Rogers pmu->formats_checked = true; 104368c25043SIan Rogers 1044e552b7beSRob Herring /* fake pmu doesn't have format list */ 1045e552b7beSRob Herring if (pmu == &perf_pmu__fake) 1046e552b7beSRob Herring return; 1047e552b7beSRob Herring 104850402641SIan Rogers list_for_each_entry(format, &pmu->format, list) { 104950402641SIan Rogers perf_pmu_format__load(pmu, format); 1050e552b7beSRob Herring if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { 1051e552b7beSRob Herring pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" 1052e552b7beSRob Herring "which is not supported by this version of perf!\n", 1053e552b7beSRob Herring pmu->name, format->name, format->value); 1054e552b7beSRob Herring return; 1055e552b7beSRob Herring } 1056e552b7beSRob Herring } 105750402641SIan Rogers } 1058e552b7beSRob Herring 1059c6d616feSIan Rogers bool evsel__is_aux_event(const struct evsel *evsel) 1060e12ee9f7SAdrian Hunter { 1061e76026bdSArnaldo Carvalho de Melo struct perf_pmu *pmu = evsel__find_pmu(evsel); 1062e12ee9f7SAdrian Hunter 1063e12ee9f7SAdrian Hunter return pmu && pmu->auxtrace; 1064e12ee9f7SAdrian Hunter } 1065e12ee9f7SAdrian Hunter 10666593f019SJames Clark /* 10676593f019SJames Clark * Set @config_name to @val as long as the user hasn't already set or cleared it 10686593f019SJames Clark * by passing a config term on the command line. 10696593f019SJames Clark * 10706593f019SJames Clark * @val is the value to put into the bits specified by @config_name rather than 10716593f019SJames Clark * the bit pattern. It is shifted into position by this function, so to set 10726593f019SJames Clark * something to true, pass 1 for val rather than a pre shifted value. 10736593f019SJames Clark */ 10746593f019SJames Clark #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask)) 10756593f019SJames Clark void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel, 10766593f019SJames Clark const char *config_name, u64 val) 10776593f019SJames Clark { 10786593f019SJames Clark u64 user_bits = 0, bits; 10796593f019SJames Clark struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG); 10806593f019SJames Clark 10816593f019SJames Clark if (term) 10826593f019SJames Clark user_bits = term->val.cfg_chg; 10836593f019SJames Clark 1084da6a5afdSIan Rogers bits = perf_pmu__format_bits(pmu, config_name); 10856593f019SJames Clark 10866593f019SJames Clark /* Do nothing if the user changed the value */ 10876593f019SJames Clark if (bits & user_bits) 10886593f019SJames Clark return; 10896593f019SJames Clark 10906593f019SJames Clark /* Otherwise replace it */ 10916593f019SJames Clark evsel->core.attr.config &= ~bits; 10926593f019SJames Clark evsel->core.attr.config |= field_prep(bits, val); 10936593f019SJames Clark } 10946593f019SJames Clark 10955c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 109609ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 1097cd82a32eSJiri Olsa { 10985c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1099cd82a32eSJiri Olsa 1100cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 1101cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 1102cd82a32eSJiri Olsa return format; 1103cd82a32eSJiri Olsa 1104cd82a32eSJiri Olsa return NULL; 1105cd82a32eSJiri Olsa } 1106cd82a32eSJiri Olsa 1107da6a5afdSIan Rogers __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name) 110809ff6071SAdrian Hunter { 1109da6a5afdSIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 111009ff6071SAdrian Hunter __u64 bits = 0; 111109ff6071SAdrian Hunter int fbit; 111209ff6071SAdrian Hunter 111309ff6071SAdrian Hunter if (!format) 111409ff6071SAdrian Hunter return 0; 111509ff6071SAdrian Hunter 111609ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 111709ff6071SAdrian Hunter bits |= 1ULL << fbit; 111809ff6071SAdrian Hunter 111909ff6071SAdrian Hunter return bits; 112009ff6071SAdrian Hunter } 112109ff6071SAdrian Hunter 11227eb54733SIan Rogers int perf_pmu__format_type(struct perf_pmu *pmu, const char *name) 1123a1ac7de6SAdrian Hunter { 11247eb54733SIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 1125a1ac7de6SAdrian Hunter 1126a1ac7de6SAdrian Hunter if (!format) 1127a1ac7de6SAdrian Hunter return -1; 1128a1ac7de6SAdrian Hunter 112950402641SIan Rogers perf_pmu_format__load(pmu, format); 1130a1ac7de6SAdrian Hunter return format->value; 1131a1ac7de6SAdrian Hunter } 1132a1ac7de6SAdrian Hunter 1133cd82a32eSJiri Olsa /* 1134dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 11354d39c89fSIngo Molnar * and unformatted value (value parameter). 1136cd82a32eSJiri Olsa */ 1137dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1138dc0a6202SAdrian Hunter bool zero) 1139cd82a32eSJiri Olsa { 1140cd82a32eSJiri Olsa unsigned long fbit, vbit; 1141cd82a32eSJiri Olsa 1142cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1143cd82a32eSJiri Olsa 1144cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 1145cd82a32eSJiri Olsa continue; 1146cd82a32eSJiri Olsa 1147dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 1148dc0a6202SAdrian Hunter *v |= (1llu << fbit); 1149dc0a6202SAdrian Hunter else if (zero) 1150dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 1151cd82a32eSJiri Olsa } 1152cd82a32eSJiri Olsa } 1153cd82a32eSJiri Olsa 11540efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 11550efe6b67SAdrian Hunter { 11561b9caa10SJiri Olsa int w; 11570efe6b67SAdrian Hunter 11581b9caa10SJiri Olsa w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 11591b9caa10SJiri Olsa if (!w) 11601b9caa10SJiri Olsa return 0; 11611b9caa10SJiri Olsa if (w < 64) 11621b9caa10SJiri Olsa return (1ULL << w) - 1; 11631b9caa10SJiri Olsa return -1; 11640efe6b67SAdrian Hunter } 11650efe6b67SAdrian Hunter 1166cd82a32eSJiri Olsa /* 1167688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 1168688d4dfcSCody P Schafer * in the remaining terms. 1169688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 1170688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 1171688d4dfcSCody P Schafer * in a config string) later on in the term list. 1172688d4dfcSCody P Schafer */ 1173688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 1174688d4dfcSCody P Schafer struct list_head *head_terms, 1175688d4dfcSCody P Schafer __u64 *value) 1176688d4dfcSCody P Schafer { 1177688d4dfcSCody P Schafer struct parse_events_term *t; 1178688d4dfcSCody P Schafer 1179688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 11802a3d252dSIan Rogers if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 11812a3d252dSIan Rogers t->config && !strcmp(t->config, term->config)) { 1182688d4dfcSCody P Schafer t->used = true; 1183688d4dfcSCody P Schafer *value = t->val.num; 1184688d4dfcSCody P Schafer return 0; 1185688d4dfcSCody P Schafer } 1186688d4dfcSCody P Schafer } 1187688d4dfcSCody P Schafer 1188bb963e16SNamhyung Kim if (verbose > 0) 1189688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 1190688d4dfcSCody P Schafer 1191688d4dfcSCody P Schafer return -1; 1192688d4dfcSCody P Schafer } 1193688d4dfcSCody P Schafer 1194ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 1195e64b020bSJiri Olsa { 1196e64b020bSJiri Olsa struct perf_pmu_format *format; 119711db4e29SMasami Hiramatsu char *str = NULL; 119811db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1199f1417ceaSXin Gao unsigned int i = 0; 1200e64b020bSJiri Olsa 1201ffeb883eSHe Kuang if (!formats) 1202e64b020bSJiri Olsa return NULL; 1203e64b020bSJiri Olsa 1204e64b020bSJiri Olsa /* sysfs exported terms */ 1205ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 120611db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 120711db4e29SMasami Hiramatsu goto error; 1208e64b020bSJiri Olsa 1209ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 121011db4e29SMasami Hiramatsu error: 1211ffeb883eSHe Kuang strbuf_release(&buf); 1212e64b020bSJiri Olsa 1213e64b020bSJiri Olsa return str; 1214e64b020bSJiri Olsa } 1215e64b020bSJiri Olsa 1216688d4dfcSCody P Schafer /* 1217cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 121888aca8d9SCody P Schafer * user input data - term parameter. 1219cd82a32eSJiri Olsa */ 1220804fee5dSIan Rogers static int pmu_config_term(struct perf_pmu *pmu, 1221cd82a32eSJiri Olsa struct perf_event_attr *attr, 1222dc0a6202SAdrian Hunter struct parse_events_term *term, 1223688d4dfcSCody P Schafer struct list_head *head_terms, 1224e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1225cd82a32eSJiri Olsa { 12265c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1227cd82a32eSJiri Olsa __u64 *vp; 12280efe6b67SAdrian Hunter __u64 val, max_val; 1229cd82a32eSJiri Olsa 1230cd82a32eSJiri Olsa /* 1231688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 1232688d4dfcSCody P Schafer * skip it in normal eval. 1233688d4dfcSCody P Schafer */ 1234688d4dfcSCody P Schafer if (term->used) 1235688d4dfcSCody P Schafer return 0; 1236688d4dfcSCody P Schafer 1237688d4dfcSCody P Schafer /* 1238cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 1239cd82a32eSJiri Olsa * to be done for them. 1240cd82a32eSJiri Olsa */ 1241cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 1242cd82a32eSJiri Olsa return 0; 1243cd82a32eSJiri Olsa 1244804fee5dSIan Rogers format = pmu_find_format(&pmu->format, term->config); 1245688d4dfcSCody P Schafer if (!format) { 1246804fee5dSIan Rogers char *pmu_term = pmu_formats_string(&pmu->format); 12474ac22b48SIan Rogers char *unknown_term; 12484ac22b48SIan Rogers char *help_msg; 1249ffeb883eSHe Kuang 12504ac22b48SIan Rogers if (asprintf(&unknown_term, 12514ac22b48SIan Rogers "unknown term '%s' for pmu '%s'", 1252804fee5dSIan Rogers term->config, pmu->name) < 0) 12534ac22b48SIan Rogers unknown_term = NULL; 12544ac22b48SIan Rogers help_msg = parse_events_formats_error_string(pmu_term); 12554ac22b48SIan Rogers if (err) { 12566c191289SIan Rogers parse_events_error__handle(err, term->err_term, 12574ac22b48SIan Rogers unknown_term, 12584ac22b48SIan Rogers help_msg); 12594ac22b48SIan Rogers } else { 12604ac22b48SIan Rogers pr_debug("%s (%s)\n", unknown_term, help_msg); 12614ac22b48SIan Rogers free(unknown_term); 1262e64b020bSJiri Olsa } 12634ac22b48SIan Rogers free(pmu_term); 1264cd82a32eSJiri Olsa return -EINVAL; 1265688d4dfcSCody P Schafer } 126650402641SIan Rogers perf_pmu_format__load(pmu, format); 1267cd82a32eSJiri Olsa switch (format->value) { 1268cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 1269cd82a32eSJiri Olsa vp = &attr->config; 1270cd82a32eSJiri Olsa break; 1271cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 1272cd82a32eSJiri Olsa vp = &attr->config1; 1273cd82a32eSJiri Olsa break; 1274cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 1275cd82a32eSJiri Olsa vp = &attr->config2; 1276cd82a32eSJiri Olsa break; 1277204e7c49SRob Herring case PERF_PMU_FORMAT_VALUE_CONFIG3: 1278204e7c49SRob Herring vp = &attr->config3; 1279204e7c49SRob Herring break; 1280cd82a32eSJiri Olsa default: 1281cd82a32eSJiri Olsa return -EINVAL; 1282cd82a32eSJiri Olsa } 1283cd82a32eSJiri Olsa 128416fa7e82SJiri Olsa /* 1285688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 1286688d4dfcSCody P Schafer * using event parameters. 128716fa7e82SJiri Olsa */ 128899e7138eSJiri Olsa if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 128999e7138eSJiri Olsa if (term->no_value && 129099e7138eSJiri Olsa bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 129199e7138eSJiri Olsa if (err) { 12926c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1293448d732cSIan Rogers strdup("no value assigned for term"), 1294448d732cSIan Rogers NULL); 129599e7138eSJiri Olsa } 129699e7138eSJiri Olsa return -EINVAL; 129799e7138eSJiri Olsa } 129899e7138eSJiri Olsa 1299688d4dfcSCody P Schafer val = term->val.num; 130099e7138eSJiri Olsa } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1301688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 1302bb963e16SNamhyung Kim if (verbose > 0) { 1303688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 1304688d4dfcSCody P Schafer term->config, term->val.str); 1305e64b020bSJiri Olsa } 1306e64b020bSJiri Olsa if (err) { 13076c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1308448d732cSIan Rogers strdup("expected numeric value"), 1309448d732cSIan Rogers NULL); 1310e64b020bSJiri Olsa } 1311688d4dfcSCody P Schafer return -EINVAL; 1312688d4dfcSCody P Schafer } 1313688d4dfcSCody P Schafer 1314688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 1315688d4dfcSCody P Schafer return -EINVAL; 1316688d4dfcSCody P Schafer } else 1317688d4dfcSCody P Schafer return -EINVAL; 1318688d4dfcSCody P Schafer 13190efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 13200efe6b67SAdrian Hunter if (val > max_val) { 13210efe6b67SAdrian Hunter if (err) { 1322448d732cSIan Rogers char *err_str; 1323448d732cSIan Rogers 13246c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1325448d732cSIan Rogers asprintf(&err_str, 13260efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 1327448d732cSIan Rogers (unsigned long long)max_val) < 0 1328448d732cSIan Rogers ? strdup("value too big for format") 1329448d732cSIan Rogers : err_str, 1330448d732cSIan Rogers NULL); 13310efe6b67SAdrian Hunter return -EINVAL; 13320efe6b67SAdrian Hunter } 13330efe6b67SAdrian Hunter /* 13340efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 13350efe6b67SAdrian Hunter * silently truncated. 13360efe6b67SAdrian Hunter */ 13370efe6b67SAdrian Hunter } 13380efe6b67SAdrian Hunter 1339688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 1340cd82a32eSJiri Olsa return 0; 1341cd82a32eSJiri Olsa } 1342cd82a32eSJiri Olsa 1343804fee5dSIan Rogers int perf_pmu__config_terms(struct perf_pmu *pmu, 1344cff7f956SJiri Olsa struct perf_event_attr *attr, 1345dc0a6202SAdrian Hunter struct list_head *head_terms, 1346e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1347cd82a32eSJiri Olsa { 13486cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 1349cd82a32eSJiri Olsa 1350688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 1351804fee5dSIan Rogers if (pmu_config_term(pmu, attr, term, head_terms, zero, err)) 1352cd82a32eSJiri Olsa return -EINVAL; 1353688d4dfcSCody P Schafer } 1354cd82a32eSJiri Olsa 1355cd82a32eSJiri Olsa return 0; 1356cd82a32eSJiri Olsa } 1357cd82a32eSJiri Olsa 1358cd82a32eSJiri Olsa /* 1359cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 1360cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 1361cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 1362cd82a32eSJiri Olsa */ 1363cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1364e64b020bSJiri Olsa struct list_head *head_terms, 1365e64b020bSJiri Olsa struct parse_events_error *err) 1366cd82a32eSJiri Olsa { 1367dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 1368dc0a6202SAdrian Hunter 1369804fee5dSIan Rogers return perf_pmu__config_terms(pmu, attr, head_terms, zero, err); 1370cd82a32eSJiri Olsa } 1371cd82a32eSJiri Olsa 1372c3245d20SIan Rogers static struct perf_pmu_alias *perf_pmu__find_alias(const struct perf_pmu *pmu, const char *str) 1373c3245d20SIan Rogers { 1374c3245d20SIan Rogers struct perf_pmu_alias *alias; 1375c3245d20SIan Rogers 1376c3245d20SIan Rogers list_for_each_entry(alias, &pmu->aliases, list) { 1377c3245d20SIan Rogers if (!strcasecmp(alias->name, str)) 1378c3245d20SIan Rogers return alias; 1379c3245d20SIan Rogers } 1380c3245d20SIan Rogers return NULL; 1381c3245d20SIan Rogers } 1382c3245d20SIan Rogers 13835c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 13846cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 1385a6146d50SZheng Yan { 1386a6146d50SZheng Yan char *name; 1387a6146d50SZheng Yan 1388a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 1389a6146d50SZheng Yan return NULL; 1390a6146d50SZheng Yan 1391a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1392a6146d50SZheng Yan if (term->val.num != 1) 1393a6146d50SZheng Yan return NULL; 1394a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 1395a6146d50SZheng Yan return NULL; 1396a6146d50SZheng Yan name = term->config; 1397c3245d20SIan Rogers 1398a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1399a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 1400a6146d50SZheng Yan return NULL; 1401a6146d50SZheng Yan name = term->val.str; 1402a6146d50SZheng Yan } else { 1403a6146d50SZheng Yan return NULL; 1404a6146d50SZheng Yan } 1405a6146d50SZheng Yan 1406c3245d20SIan Rogers return perf_pmu__find_alias(pmu, name); 1407a6146d50SZheng Yan } 1408a6146d50SZheng Yan 1409410136f5SStephane Eranian 14101d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 14119d31cb93SIan Rogers struct perf_pmu_info *info, 14129d31cb93SIan Rogers struct parse_events_error *err, 14139d31cb93SIan Rogers int column) 1414410136f5SStephane Eranian { 1415410136f5SStephane Eranian /* 1416410136f5SStephane Eranian * Only one term in event definition can 14171d9e446bSJiri Olsa * define unit, scale and snapshot, fail 14181d9e446bSJiri Olsa * if there's more than one. 1419410136f5SStephane Eranian */ 14209d31cb93SIan Rogers if (info->unit && alias->unit[0]) { 14219d31cb93SIan Rogers parse_events_error__handle(err, column, 14229d31cb93SIan Rogers strdup("Attempt to set event's unit twice"), 14239d31cb93SIan Rogers NULL); 1424410136f5SStephane Eranian return -EINVAL; 14259d31cb93SIan Rogers } 14269d31cb93SIan Rogers if (info->scale && alias->scale) { 14279d31cb93SIan Rogers parse_events_error__handle(err, column, 14289d31cb93SIan Rogers strdup("Attempt to set event's scale twice"), 14299d31cb93SIan Rogers NULL); 14309d31cb93SIan Rogers return -EINVAL; 14319d31cb93SIan Rogers } 14329d31cb93SIan Rogers if (info->snapshot && alias->snapshot) { 14339d31cb93SIan Rogers parse_events_error__handle(err, column, 14349d31cb93SIan Rogers strdup("Attempt to set event snapshot twice"), 14359d31cb93SIan Rogers NULL); 14369d31cb93SIan Rogers return -EINVAL; 14379d31cb93SIan Rogers } 1438410136f5SStephane Eranian 1439b30a7d1fSArnaldo Carvalho de Melo if (alias->unit[0]) 14401d9e446bSJiri Olsa info->unit = alias->unit; 1441410136f5SStephane Eranian 1442410136f5SStephane Eranian if (alias->scale) 14431d9e446bSJiri Olsa info->scale = alias->scale; 14441d9e446bSJiri Olsa 14451d9e446bSJiri Olsa if (alias->snapshot) 14461d9e446bSJiri Olsa info->snapshot = alias->snapshot; 1447410136f5SStephane Eranian 1448410136f5SStephane Eranian return 0; 1449410136f5SStephane Eranian } 1450410136f5SStephane Eranian 1451a6146d50SZheng Yan /* 1452a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 1453a6146d50SZheng Yan * defined for the alias 1454a6146d50SZheng Yan */ 1455410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 14569d31cb93SIan Rogers struct perf_pmu_info *info, struct parse_events_error *err) 1457a6146d50SZheng Yan { 14586cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 14595c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1460a6146d50SZheng Yan int ret; 1461a6146d50SZheng Yan 1462044330c1SMatt Fleming info->per_pkg = false; 1463044330c1SMatt Fleming 14648a398897SStephane Eranian /* 14658a398897SStephane Eranian * Mark unit and scale as not set 14668a398897SStephane Eranian * (different from default values, see below) 14678a398897SStephane Eranian */ 146846441bdcSMatt Fleming info->unit = NULL; 146946441bdcSMatt Fleming info->scale = 0.0; 14701d9e446bSJiri Olsa info->snapshot = false; 1471410136f5SStephane Eranian 1472a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 1473a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 1474a6146d50SZheng Yan if (!alias) 1475a6146d50SZheng Yan continue; 1476a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 14779d31cb93SIan Rogers if (ret) { 14789d31cb93SIan Rogers parse_events_error__handle(err, term->err_term, 14799d31cb93SIan Rogers strdup("Failure to duplicate terms"), 14809d31cb93SIan Rogers NULL); 1481a6146d50SZheng Yan return ret; 14829d31cb93SIan Rogers } 1483410136f5SStephane Eranian 14849d31cb93SIan Rogers ret = check_info_data(alias, info, err, term->err_term); 1485410136f5SStephane Eranian if (ret) 1486410136f5SStephane Eranian return ret; 1487410136f5SStephane Eranian 1488044330c1SMatt Fleming if (alias->per_pkg) 1489044330c1SMatt Fleming info->per_pkg = true; 1490044330c1SMatt Fleming 1491e56fbc9dSArnaldo Carvalho de Melo list_del_init(&term->list); 14921dc92556SIan Rogers parse_events_term__delete(term); 1493a6146d50SZheng Yan } 14948a398897SStephane Eranian 14958a398897SStephane Eranian /* 14968a398897SStephane Eranian * if no unit or scale found in aliases, then 14978a398897SStephane Eranian * set defaults as for evsel 14988a398897SStephane Eranian * unit cannot left to NULL 14998a398897SStephane Eranian */ 150046441bdcSMatt Fleming if (info->unit == NULL) 150146441bdcSMatt Fleming info->unit = ""; 15028a398897SStephane Eranian 150346441bdcSMatt Fleming if (info->scale == 0.0) 150446441bdcSMatt Fleming info->scale = 1.0; 15058a398897SStephane Eranian 1506a6146d50SZheng Yan return 0; 1507a6146d50SZheng Yan } 1508a6146d50SZheng Yan 1509c3245d20SIan Rogers struct find_event_args { 1510c3245d20SIan Rogers const char *event; 1511c3245d20SIan Rogers void *state; 1512c3245d20SIan Rogers pmu_event_callback cb; 1513c3245d20SIan Rogers }; 1514c3245d20SIan Rogers 1515c3245d20SIan Rogers static int find_event_callback(void *state, struct pmu_event_info *info) 1516838a8c5fSIan Rogers { 1517c3245d20SIan Rogers struct find_event_args *args = state; 1518838a8c5fSIan Rogers 1519c3245d20SIan Rogers if (!strcmp(args->event, info->name)) 1520c3245d20SIan Rogers return args->cb(args->state, info); 1521838a8c5fSIan Rogers 1522c3245d20SIan Rogers return 0; 1523838a8c5fSIan Rogers } 1524c3245d20SIan Rogers 1525c3245d20SIan Rogers int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb) 1526c3245d20SIan Rogers { 1527c3245d20SIan Rogers struct find_event_args args = { 1528c3245d20SIan Rogers .event = event, 1529c3245d20SIan Rogers .state = state, 1530c3245d20SIan Rogers .cb = cb, 1531c3245d20SIan Rogers }; 1532c3245d20SIan Rogers 1533c3245d20SIan Rogers return perf_pmu__for_each_event(pmu, &args, find_event_callback); 1534c3245d20SIan Rogers } 1535c3245d20SIan Rogers 1536804fee5dSIan Rogers static void perf_pmu__del_formats(struct list_head *formats) 1537d26383dcSNamhyung Kim { 1538d26383dcSNamhyung Kim struct perf_pmu_format *fmt, *tmp; 1539d26383dcSNamhyung Kim 1540d26383dcSNamhyung Kim list_for_each_entry_safe(fmt, tmp, formats, list) { 1541d26383dcSNamhyung Kim list_del(&fmt->list); 1542efe98a7aSArnaldo Carvalho de Melo zfree(&fmt->name); 1543d26383dcSNamhyung Kim free(fmt); 1544d26383dcSNamhyung Kim } 1545d26383dcSNamhyung Kim } 1546d26383dcSNamhyung Kim 154707d2b820SIan Rogers bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name) 154807d2b820SIan Rogers { 154907d2b820SIan Rogers struct perf_pmu_format *format; 155007d2b820SIan Rogers 155107d2b820SIan Rogers list_for_each_entry(format, &pmu->format, list) { 155207d2b820SIan Rogers if (!strcmp(format->name, name)) 155307d2b820SIan Rogers return true; 155407d2b820SIan Rogers } 155507d2b820SIan Rogers return false; 155607d2b820SIan Rogers } 155707d2b820SIan Rogers 1558d504fae9SJohn Garry bool is_pmu_core(const char *name) 1559d504fae9SJohn Garry { 15606fbd67b0SThomas Richter return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name); 15614bf7e81aSIan Rogers } 15624bf7e81aSIan Rogers 15636fd1e519SIan Rogers bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu) 15646fd1e519SIan Rogers { 1565e20d1f2fSIan Rogers return pmu->is_core; 15666fd1e519SIan Rogers } 15676fd1e519SIan Rogers 156852c7b4d3SIan Rogers bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu) 156952c7b4d3SIan Rogers { 1570710dffc9SIan Rogers return !pmu->is_core || perf_pmus__num_core_pmus() == 1; 157152c7b4d3SIan Rogers } 157252c7b4d3SIan Rogers 15731eaf496eSIan Rogers bool perf_pmu__have_event(const struct perf_pmu *pmu, const char *name) 1574abe9544eSIan Rogers { 1575c3245d20SIan Rogers return perf_pmu__find_alias(pmu, name) != NULL; 15764cabc3d1SAndi Kleen } 1577c3245d20SIan Rogers 1578c3245d20SIan Rogers size_t perf_pmu__num_events(const struct perf_pmu *pmu) 1579c3245d20SIan Rogers { 1580c3245d20SIan Rogers struct list_head *list; 1581c3245d20SIan Rogers size_t nr = 0; 1582c3245d20SIan Rogers 1583c3245d20SIan Rogers list_for_each(list, &pmu->aliases) 1584c3245d20SIan Rogers nr++; 1585c3245d20SIan Rogers 1586c3245d20SIan Rogers return pmu->selectable ? nr + 1 : nr; 1587c3245d20SIan Rogers } 1588c3245d20SIan Rogers 1589c3245d20SIan Rogers static int sub_non_neg(int a, int b) 1590c3245d20SIan Rogers { 1591c3245d20SIan Rogers if (b > a) 1592c3245d20SIan Rogers return 0; 1593c3245d20SIan Rogers return a - b; 1594c3245d20SIan Rogers } 1595c3245d20SIan Rogers 1596c3245d20SIan Rogers static char *format_alias(char *buf, int len, const struct perf_pmu *pmu, 1597c3245d20SIan Rogers const struct perf_pmu_alias *alias) 1598c3245d20SIan Rogers { 1599c3245d20SIan Rogers struct parse_events_term *term; 1600c3245d20SIan Rogers int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1601c3245d20SIan Rogers 1602c3245d20SIan Rogers list_for_each_entry(term, &alias->terms, list) { 1603c3245d20SIan Rogers if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1604c3245d20SIan Rogers used += snprintf(buf + used, sub_non_neg(len, used), 1605c3245d20SIan Rogers ",%s=%s", term->config, 1606c3245d20SIan Rogers term->val.str); 1607c3245d20SIan Rogers } 1608c3245d20SIan Rogers 1609c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1610c3245d20SIan Rogers buf[used] = '/'; 1611c3245d20SIan Rogers used++; 1612c3245d20SIan Rogers } 1613c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1614c3245d20SIan Rogers buf[used] = '\0'; 1615c3245d20SIan Rogers used++; 1616c3245d20SIan Rogers } else 1617c3245d20SIan Rogers buf[len - 1] = '\0'; 1618c3245d20SIan Rogers 1619c3245d20SIan Rogers return buf; 1620c3245d20SIan Rogers } 1621c3245d20SIan Rogers 1622c3245d20SIan Rogers int perf_pmu__for_each_event(const struct perf_pmu *pmu, void *state, pmu_event_callback cb) 1623c3245d20SIan Rogers { 1624c3245d20SIan Rogers char buf[1024]; 1625c3245d20SIan Rogers struct perf_pmu_alias *event; 1626c3245d20SIan Rogers struct pmu_event_info info = { 1627c3245d20SIan Rogers .pmu = pmu, 1628c3245d20SIan Rogers }; 1629c3245d20SIan Rogers int ret = 0; 1630c3245d20SIan Rogers 1631c3245d20SIan Rogers list_for_each_entry(event, &pmu->aliases, list) { 1632c3245d20SIan Rogers size_t buf_used; 1633c3245d20SIan Rogers 1634c3245d20SIan Rogers info.pmu_name = event->pmu_name ?: pmu->name; 1635c3245d20SIan Rogers info.alias = NULL; 1636c3245d20SIan Rogers if (event->desc) { 1637c3245d20SIan Rogers info.name = event->name; 1638c3245d20SIan Rogers buf_used = 0; 1639c3245d20SIan Rogers } else { 1640c3245d20SIan Rogers info.name = format_alias(buf, sizeof(buf), pmu, event); 1641c3245d20SIan Rogers if (pmu->is_core) { 1642c3245d20SIan Rogers info.alias = info.name; 1643c3245d20SIan Rogers info.name = event->name; 1644c3245d20SIan Rogers } 1645c3245d20SIan Rogers buf_used = strlen(buf) + 1; 1646c3245d20SIan Rogers } 1647c3245d20SIan Rogers info.scale_unit = NULL; 1648c3245d20SIan Rogers if (strlen(event->unit) || event->scale != 1.0) { 1649c3245d20SIan Rogers info.scale_unit = buf + buf_used; 1650c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1651c3245d20SIan Rogers "%G%s", event->scale, event->unit) + 1; 1652c3245d20SIan Rogers } 1653c3245d20SIan Rogers info.desc = event->desc; 1654c3245d20SIan Rogers info.long_desc = event->long_desc; 1655c3245d20SIan Rogers info.encoding_desc = buf + buf_used; 1656c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1657c3245d20SIan Rogers "%s/%s/", info.pmu_name, event->str) + 1; 1658c3245d20SIan Rogers info.topic = event->topic; 1659c3245d20SIan Rogers info.str = event->str; 1660c3245d20SIan Rogers info.deprecated = event->deprecated; 1661c3245d20SIan Rogers ret = cb(state, &info); 1662c3245d20SIan Rogers if (ret) 1663c3245d20SIan Rogers return ret; 1664c3245d20SIan Rogers } 1665c3245d20SIan Rogers if (pmu->selectable) { 1666c3245d20SIan Rogers info.name = buf; 1667c3245d20SIan Rogers snprintf(buf, sizeof(buf), "%s//", pmu->name); 1668c3245d20SIan Rogers info.alias = NULL; 1669c3245d20SIan Rogers info.scale_unit = NULL; 1670c3245d20SIan Rogers info.desc = NULL; 1671c3245d20SIan Rogers info.long_desc = NULL; 1672c3245d20SIan Rogers info.encoding_desc = NULL; 1673c3245d20SIan Rogers info.topic = NULL; 1674c3245d20SIan Rogers info.pmu_name = pmu->name; 1675c3245d20SIan Rogers info.deprecated = false; 1676c3245d20SIan Rogers ret = cb(state, &info); 1677c3245d20SIan Rogers } 1678c3245d20SIan Rogers return ret; 16794cabc3d1SAndi Kleen } 16807d4bdab5SAdrian Hunter 1681e3edd6cfSIan Rogers bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name) 1682e3edd6cfSIan Rogers { 1683e3edd6cfSIan Rogers return !strcmp(pmu->name, pmu_name) || 1684e3edd6cfSIan Rogers (pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)); 1685e3edd6cfSIan Rogers } 1686e3edd6cfSIan Rogers 1687251aa040SIan Rogers bool perf_pmu__is_software(const struct perf_pmu *pmu) 1688251aa040SIan Rogers { 1689251aa040SIan Rogers if (pmu->is_core || pmu->is_uncore || pmu->auxtrace) 1690251aa040SIan Rogers return false; 1691251aa040SIan Rogers switch (pmu->type) { 1692251aa040SIan Rogers case PERF_TYPE_HARDWARE: return false; 1693251aa040SIan Rogers case PERF_TYPE_SOFTWARE: return true; 1694251aa040SIan Rogers case PERF_TYPE_TRACEPOINT: return true; 1695251aa040SIan Rogers case PERF_TYPE_HW_CACHE: return false; 1696251aa040SIan Rogers case PERF_TYPE_RAW: return false; 1697251aa040SIan Rogers case PERF_TYPE_BREAKPOINT: return true; 1698251aa040SIan Rogers default: break; 1699251aa040SIan Rogers } 1700251aa040SIan Rogers return !strcmp(pmu->name, "kprobe") || !strcmp(pmu->name, "uprobe"); 1701251aa040SIan Rogers } 1702251aa040SIan Rogers 1703d50a79cdSJames Clark FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 17047d4bdab5SAdrian Hunter { 17057d4bdab5SAdrian Hunter char path[PATH_MAX]; 17067d4bdab5SAdrian Hunter 1707f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) || 1708f8ad6018SJames Clark !file_available(path)) 17097d4bdab5SAdrian Hunter return NULL; 17107d4bdab5SAdrian Hunter 17117d4bdab5SAdrian Hunter return fopen(path, "r"); 17127d4bdab5SAdrian Hunter } 17137d4bdab5SAdrian Hunter 17143a69672eSNamhyung Kim FILE *perf_pmu__open_file_at(struct perf_pmu *pmu, int dirfd, const char *name) 17153a69672eSNamhyung Kim { 17163a69672eSNamhyung Kim int fd; 17173a69672eSNamhyung Kim 17183a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY); 17193a69672eSNamhyung Kim if (fd < 0) 17203a69672eSNamhyung Kim return NULL; 17213a69672eSNamhyung Kim 17223a69672eSNamhyung Kim return fdopen(fd, "r"); 17233a69672eSNamhyung Kim } 17243a69672eSNamhyung Kim 17257d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 17267d4bdab5SAdrian Hunter ...) 17277d4bdab5SAdrian Hunter { 17287d4bdab5SAdrian Hunter va_list args; 17297d4bdab5SAdrian Hunter FILE *file; 17307d4bdab5SAdrian Hunter int ret = EOF; 17317d4bdab5SAdrian Hunter 17327d4bdab5SAdrian Hunter va_start(args, fmt); 17337d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 17347d4bdab5SAdrian Hunter if (file) { 17357d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 17367d4bdab5SAdrian Hunter fclose(file); 17377d4bdab5SAdrian Hunter } 17387d4bdab5SAdrian Hunter va_end(args); 17397d4bdab5SAdrian Hunter return ret; 17407d4bdab5SAdrian Hunter } 17419fbc61f8SKan Liang 17423a69672eSNamhyung Kim int perf_pmu__scan_file_at(struct perf_pmu *pmu, int dirfd, const char *name, 17433a69672eSNamhyung Kim const char *fmt, ...) 17443a69672eSNamhyung Kim { 17453a69672eSNamhyung Kim va_list args; 17463a69672eSNamhyung Kim FILE *file; 17473a69672eSNamhyung Kim int ret = EOF; 17483a69672eSNamhyung Kim 17493a69672eSNamhyung Kim va_start(args, fmt); 17503a69672eSNamhyung Kim file = perf_pmu__open_file_at(pmu, dirfd, name); 17513a69672eSNamhyung Kim if (file) { 17523a69672eSNamhyung Kim ret = vfscanf(file, fmt, args); 17533a69672eSNamhyung Kim fclose(file); 17543a69672eSNamhyung Kim } 17553a69672eSNamhyung Kim va_end(args); 17563a69672eSNamhyung Kim return ret; 17573a69672eSNamhyung Kim } 17583a69672eSNamhyung Kim 1759c2b6a896SGerman Gomez bool perf_pmu__file_exists(struct perf_pmu *pmu, const char *name) 1760c2b6a896SGerman Gomez { 1761c2b6a896SGerman Gomez char path[PATH_MAX]; 1762c2b6a896SGerman Gomez 1763c2b6a896SGerman Gomez if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name)) 1764c2b6a896SGerman Gomez return false; 1765c2b6a896SGerman Gomez 1766c2b6a896SGerman Gomez return file_available(path); 1767c2b6a896SGerman Gomez } 1768c2b6a896SGerman Gomez 17699fbc61f8SKan Liang static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 17709fbc61f8SKan Liang { 17719fbc61f8SKan Liang struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 17729fbc61f8SKan Liang 17739fbc61f8SKan Liang if (!caps) 17749fbc61f8SKan Liang return -ENOMEM; 17759fbc61f8SKan Liang 17769fbc61f8SKan Liang caps->name = strdup(name); 17779fbc61f8SKan Liang if (!caps->name) 17789fbc61f8SKan Liang goto free_caps; 17799fbc61f8SKan Liang caps->value = strndup(value, strlen(value) - 1); 17809fbc61f8SKan Liang if (!caps->value) 17819fbc61f8SKan Liang goto free_name; 17829fbc61f8SKan Liang list_add_tail(&caps->list, list); 17839fbc61f8SKan Liang return 0; 17849fbc61f8SKan Liang 17859fbc61f8SKan Liang free_name: 178657f14b5aSArnaldo Carvalho de Melo zfree(&caps->name); 17879fbc61f8SKan Liang free_caps: 17889fbc61f8SKan Liang free(caps); 17899fbc61f8SKan Liang 17909fbc61f8SKan Liang return -ENOMEM; 17919fbc61f8SKan Liang } 17929fbc61f8SKan Liang 1793eec11310SNamhyung Kim static void perf_pmu__del_caps(struct perf_pmu *pmu) 1794eec11310SNamhyung Kim { 1795eec11310SNamhyung Kim struct perf_pmu_caps *caps, *tmp; 1796eec11310SNamhyung Kim 1797eec11310SNamhyung Kim list_for_each_entry_safe(caps, tmp, &pmu->caps, list) { 1798eec11310SNamhyung Kim list_del(&caps->list); 1799efe98a7aSArnaldo Carvalho de Melo zfree(&caps->name); 1800efe98a7aSArnaldo Carvalho de Melo zfree(&caps->value); 1801eec11310SNamhyung Kim free(caps); 1802eec11310SNamhyung Kim } 1803eec11310SNamhyung Kim } 1804eec11310SNamhyung Kim 18059fbc61f8SKan Liang /* 18069fbc61f8SKan Liang * Reading/parsing the given pmu capabilities, which should be located at: 18079fbc61f8SKan Liang * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 18089fbc61f8SKan Liang * Return the number of capabilities 18099fbc61f8SKan Liang */ 18109fbc61f8SKan Liang int perf_pmu__caps_parse(struct perf_pmu *pmu) 18119fbc61f8SKan Liang { 18129fbc61f8SKan Liang struct stat st; 18139fbc61f8SKan Liang char caps_path[PATH_MAX]; 18149fbc61f8SKan Liang DIR *caps_dir; 18159fbc61f8SKan Liang struct dirent *evt_ent; 1816b39094d3SNamhyung Kim int caps_fd; 18173339ec44SRavi Bangoria 18183339ec44SRavi Bangoria if (pmu->caps_initialized) 18193339ec44SRavi Bangoria return pmu->nr_caps; 18203339ec44SRavi Bangoria 18213339ec44SRavi Bangoria pmu->nr_caps = 0; 18229fbc61f8SKan Liang 1823f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps")) 18249fbc61f8SKan Liang return -1; 18259fbc61f8SKan Liang 18263339ec44SRavi Bangoria if (stat(caps_path, &st) < 0) { 18273339ec44SRavi Bangoria pmu->caps_initialized = true; 18289fbc61f8SKan Liang return 0; /* no error if caps does not exist */ 18293339ec44SRavi Bangoria } 18309fbc61f8SKan Liang 18319fbc61f8SKan Liang caps_dir = opendir(caps_path); 18329fbc61f8SKan Liang if (!caps_dir) 18339fbc61f8SKan Liang return -EINVAL; 18349fbc61f8SKan Liang 1835b39094d3SNamhyung Kim caps_fd = dirfd(caps_dir); 1836b39094d3SNamhyung Kim 18379fbc61f8SKan Liang while ((evt_ent = readdir(caps_dir)) != NULL) { 18389fbc61f8SKan Liang char *name = evt_ent->d_name; 18399fbc61f8SKan Liang char value[128]; 18409fbc61f8SKan Liang FILE *file; 1841b39094d3SNamhyung Kim int fd; 18429fbc61f8SKan Liang 18439fbc61f8SKan Liang if (!strcmp(name, ".") || !strcmp(name, "..")) 18449fbc61f8SKan Liang continue; 18459fbc61f8SKan Liang 1846b39094d3SNamhyung Kim fd = openat(caps_fd, name, O_RDONLY); 18470ea8920eSIan Rogers if (fd == -1) 18489fbc61f8SKan Liang continue; 18490ea8920eSIan Rogers file = fdopen(fd, "r"); 18500ea8920eSIan Rogers if (!file) { 18510ea8920eSIan Rogers close(fd); 18520ea8920eSIan Rogers continue; 18530ea8920eSIan Rogers } 18549fbc61f8SKan Liang 18559fbc61f8SKan Liang if (!fgets(value, sizeof(value), file) || 18569fbc61f8SKan Liang (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 18579fbc61f8SKan Liang fclose(file); 18589fbc61f8SKan Liang continue; 18599fbc61f8SKan Liang } 18609fbc61f8SKan Liang 18613339ec44SRavi Bangoria pmu->nr_caps++; 18629fbc61f8SKan Liang fclose(file); 18639fbc61f8SKan Liang } 18649fbc61f8SKan Liang 18659fbc61f8SKan Liang closedir(caps_dir); 18669fbc61f8SKan Liang 18673339ec44SRavi Bangoria pmu->caps_initialized = true; 18683339ec44SRavi Bangoria return pmu->nr_caps; 18699fbc61f8SKan Liang } 1870e4064776SJin Yao 1871b9f01032SIan Rogers static void perf_pmu__compute_config_masks(struct perf_pmu *pmu) 1872e4064776SJin Yao { 1873e4064776SJin Yao struct perf_pmu_format *format; 1874b9f01032SIan Rogers 1875b9f01032SIan Rogers if (pmu->config_masks_computed) 1876b9f01032SIan Rogers return; 1877e4064776SJin Yao 1878e4064776SJin Yao list_for_each_entry(format, &pmu->format, list) { 1879b9f01032SIan Rogers unsigned int i; 1880b9f01032SIan Rogers __u64 *mask; 1881b9f01032SIan Rogers 1882b9f01032SIan Rogers if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) 1883e4064776SJin Yao continue; 1884e4064776SJin Yao 1885b9f01032SIan Rogers pmu->config_masks_present = true; 1886b9f01032SIan Rogers mask = &pmu->config_masks[format->value]; 1887b9f01032SIan Rogers 1888e4064776SJin Yao for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 1889b9f01032SIan Rogers *mask |= 1ULL << i; 1890e4064776SJin Yao } 1891b9f01032SIan Rogers pmu->config_masks_computed = true; 1892b9f01032SIan Rogers } 1893b9f01032SIan Rogers 1894b9f01032SIan Rogers void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 1895b9f01032SIan Rogers const char *name, int config_num, 1896b9f01032SIan Rogers const char *config_name) 1897b9f01032SIan Rogers { 1898b9f01032SIan Rogers __u64 bits; 1899b9f01032SIan Rogers char buf[100]; 1900b9f01032SIan Rogers 1901b9f01032SIan Rogers perf_pmu__compute_config_masks(pmu); 1902e4064776SJin Yao 1903e4064776SJin Yao /* 1904e4064776SJin Yao * Kernel doesn't export any valid format bits. 1905e4064776SJin Yao */ 1906b9f01032SIan Rogers if (!pmu->config_masks_present) 1907e4064776SJin Yao return; 1908e4064776SJin Yao 1909b9f01032SIan Rogers bits = config & ~pmu->config_masks[config_num]; 1910e4064776SJin Yao if (bits == 0) 1911e4064776SJin Yao return; 1912e4064776SJin Yao 1913e4064776SJin Yao bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 1914e4064776SJin Yao 1915b9f01032SIan Rogers pr_warning("WARNING: event '%s' not valid (bits %s of %s " 1916e4064776SJin Yao "'%llx' not supported by kernel)!\n", 1917b9f01032SIan Rogers name ?: "N/A", buf, config_name, config); 1918e4064776SJin Yao } 1919c5a26ea4SJin Yao 1920c47a5599SJin Yao int perf_pmu__match(char *pattern, char *name, char *tok) 1921c47a5599SJin Yao { 192213d60ba0SKan Liang if (!name) 192313d60ba0SKan Liang return -1; 192413d60ba0SKan Liang 1925c47a5599SJin Yao if (fnmatch(pattern, name, 0)) 1926c47a5599SJin Yao return -1; 1927c47a5599SJin Yao 1928240e6fd0SIan Rogers if (tok && !perf_pmu__match_ignoring_suffix(name, tok)) 1929c47a5599SJin Yao return -1; 1930c47a5599SJin Yao 1931c47a5599SJin Yao return 0; 1932c47a5599SJin Yao } 19331d3351e6SJin Yao 1934acef233bSJing Zhang double __weak perf_pmu__cpu_slots_per_cycle(void) 1935acef233bSJing Zhang { 1936acef233bSJing Zhang return NAN; 1937acef233bSJing Zhang } 1938f8ad6018SJames Clark 1939f8ad6018SJames Clark int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size) 1940f8ad6018SJames Clark { 1941f8ad6018SJames Clark const char *sysfs = sysfs__mountpoint(); 1942f8ad6018SJames Clark 1943f8ad6018SJames Clark if (!sysfs) 1944f8ad6018SJames Clark return 0; 1945f8ad6018SJames Clark return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs); 1946f8ad6018SJames Clark } 1947f8ad6018SJames Clark 1948e293a5e8SNamhyung Kim int perf_pmu__event_source_devices_fd(void) 1949e293a5e8SNamhyung Kim { 1950e293a5e8SNamhyung Kim char path[PATH_MAX]; 1951e293a5e8SNamhyung Kim const char *sysfs = sysfs__mountpoint(); 1952e293a5e8SNamhyung Kim 1953e293a5e8SNamhyung Kim if (!sysfs) 1954e293a5e8SNamhyung Kim return -1; 1955e293a5e8SNamhyung Kim 1956e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs); 1957e293a5e8SNamhyung Kim return open(path, O_DIRECTORY); 1958e293a5e8SNamhyung Kim } 1959e293a5e8SNamhyung Kim 1960f8ad6018SJames Clark /* 1961f8ad6018SJames Clark * Fill 'buf' with the path to a file or folder in 'pmu_name' in 1962f8ad6018SJames Clark * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format" 1963f8ad6018SJames Clark * then pathname will be filled with 1964f8ad6018SJames Clark * "/sys/bus/event_source/devices/cs_etm/format" 1965f8ad6018SJames Clark * 1966e1a3aad3SIan Rogers * Return 0 if the sysfs mountpoint couldn't be found, if no characters were 1967e1a3aad3SIan Rogers * written or if the buffer size is exceeded. 1968f8ad6018SJames Clark */ 1969f8ad6018SJames Clark int perf_pmu__pathname_scnprintf(char *buf, size_t size, 1970f8ad6018SJames Clark const char *pmu_name, const char *filename) 1971f8ad6018SJames Clark { 1972e1a3aad3SIan Rogers size_t len; 1973f8ad6018SJames Clark 1974e1a3aad3SIan Rogers len = perf_pmu__event_source_devices_scnprintf(buf, size); 1975e1a3aad3SIan Rogers if (!len || (len + strlen(pmu_name) + strlen(filename) + 1) >= size) 1976f8ad6018SJames Clark return 0; 1977e1a3aad3SIan Rogers 1978e1a3aad3SIan Rogers return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename); 1979f8ad6018SJames Clark } 1980eec11310SNamhyung Kim 1981e293a5e8SNamhyung Kim int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags) 1982e293a5e8SNamhyung Kim { 1983e293a5e8SNamhyung Kim char path[PATH_MAX]; 1984e293a5e8SNamhyung Kim 1985e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename); 1986e293a5e8SNamhyung Kim return openat(dirfd, path, flags); 1987e293a5e8SNamhyung Kim } 1988e293a5e8SNamhyung Kim 19891eaf496eSIan Rogers void perf_pmu__delete(struct perf_pmu *pmu) 1990eec11310SNamhyung Kim { 1991eec11310SNamhyung Kim perf_pmu__del_formats(&pmu->format); 1992eec11310SNamhyung Kim perf_pmu__del_aliases(pmu); 1993eec11310SNamhyung Kim perf_pmu__del_caps(pmu); 1994eec11310SNamhyung Kim 1995eec11310SNamhyung Kim perf_cpu_map__put(pmu->cpus); 1996eec11310SNamhyung Kim 1997efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->default_config); 1998efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 1999efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->alias_name); 2000eec11310SNamhyung Kim free(pmu); 2001eec11310SNamhyung Kim } 20029d5da30eSJames Clark 20039d5da30eSJames Clark struct perf_pmu *pmu__find_core_pmu(void) 20049d5da30eSJames Clark { 20059d5da30eSJames Clark struct perf_pmu *pmu = NULL; 20069d5da30eSJames Clark 20079d5da30eSJames Clark while ((pmu = perf_pmus__scan_core(pmu))) { 20089d5da30eSJames Clark /* 20099d5da30eSJames Clark * The cpumap should cover all CPUs. Otherwise, some CPUs may 20109d5da30eSJames Clark * not support some events or have different event IDs. 20119d5da30eSJames Clark */ 20129d5da30eSJames Clark if (RC_CHK_ACCESS(pmu->cpus)->nr != cpu__max_cpu().cpu) 20139d5da30eSJames Clark return NULL; 20149d5da30eSJames Clark 20159d5da30eSJames Clark return pmu; 20169d5da30eSJames Clark } 20179d5da30eSJames Clark return NULL; 20189d5da30eSJames Clark } 2019