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 283edb217ffSIan 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 315edb217ffSIan 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 346edb217ffSIan 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, 364edb217ffSIan 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 /* Delete an alias entry. */ 381c3245d20SIan Rogers static void perf_pmu_free_alias(struct perf_pmu_alias *newalias) 3826dde6429SThomas Richter { 3836dde6429SThomas Richter zfree(&newalias->name); 3846dde6429SThomas Richter zfree(&newalias->desc); 3856dde6429SThomas Richter zfree(&newalias->long_desc); 3866dde6429SThomas Richter zfree(&newalias->topic); 3876dde6429SThomas Richter zfree(&newalias->str); 38832705de7SJin Yao zfree(&newalias->pmu_name); 3896dde6429SThomas Richter parse_events_terms__purge(&newalias->terms); 3906dde6429SThomas Richter free(newalias); 3916dde6429SThomas Richter } 3926dde6429SThomas Richter 393eec11310SNamhyung Kim static void perf_pmu__del_aliases(struct perf_pmu *pmu) 394eec11310SNamhyung Kim { 395eec11310SNamhyung Kim struct perf_pmu_alias *alias, *tmp; 396eec11310SNamhyung Kim 397eec11310SNamhyung Kim list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) { 398eec11310SNamhyung Kim list_del(&alias->list); 399eec11310SNamhyung Kim perf_pmu_free_alias(alias); 400eec11310SNamhyung Kim } 401eec11310SNamhyung Kim } 402eec11310SNamhyung Kim 403f63a536fSIan Rogers static struct perf_pmu_alias *perf_pmu__find_alias(const struct perf_pmu *pmu, const char *name) 4046dde6429SThomas Richter { 405f63a536fSIan Rogers struct perf_pmu_alias *alias; 4066dde6429SThomas Richter 407f63a536fSIan Rogers list_for_each_entry(alias, &pmu->aliases, list) { 408f63a536fSIan Rogers if (!strcasecmp(alias->name, name)) 409f63a536fSIan Rogers return alias; 41032705de7SJin Yao } 411f63a536fSIan Rogers return NULL; 412f63a536fSIan Rogers } 413f63a536fSIan Rogers 414f63a536fSIan Rogers static bool assign_str(const char *name, const char *field, char **old_str, 415f63a536fSIan Rogers const char *new_str) 416f63a536fSIan Rogers { 417f63a536fSIan Rogers if (!*old_str && new_str) { 418f63a536fSIan Rogers *old_str = strdup(new_str); 4196dde6429SThomas Richter return true; 4206dde6429SThomas Richter } 421f63a536fSIan Rogers 422f63a536fSIan Rogers if (!new_str || !strcasecmp(*old_str, new_str)) 423f63a536fSIan Rogers return false; /* Nothing to update. */ 424f63a536fSIan Rogers 425f63a536fSIan Rogers pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n", 426f63a536fSIan Rogers name, field, *old_str, new_str); 427f63a536fSIan Rogers zfree(old_str); 428f63a536fSIan Rogers *old_str = strdup(new_str); 429f63a536fSIan Rogers return true; 4306dde6429SThomas Richter } 431f63a536fSIan Rogers 432f63a536fSIan Rogers static int update_alias(const struct pmu_event *pe, 433f63a536fSIan Rogers const struct pmu_events_table *table __maybe_unused, 434f63a536fSIan Rogers void *vdata) 435f63a536fSIan Rogers { 436f63a536fSIan Rogers struct perf_pmu_alias *alias = vdata; 437f63a536fSIan Rogers int ret = 0; 438f63a536fSIan Rogers 439f63a536fSIan Rogers assign_str(pe->name, "desc", &alias->desc, pe->desc); 440f63a536fSIan Rogers assign_str(pe->name, "long_desc", &alias->long_desc, pe->long_desc); 441f63a536fSIan Rogers assign_str(pe->name, "topic", &alias->topic, pe->topic); 442f63a536fSIan Rogers alias->per_pkg = pe->perpkg; 443f63a536fSIan Rogers if (assign_str(pe->name, "value", &alias->str, pe->event)) { 444f63a536fSIan Rogers parse_events_terms__purge(&alias->terms); 445f63a536fSIan Rogers ret = parse_events_terms(&alias->terms, pe->event, /*input=*/NULL); 446f63a536fSIan Rogers } 447f63a536fSIan Rogers if (!ret && pe->unit) { 448f63a536fSIan Rogers char *unit; 449f63a536fSIan Rogers 450f63a536fSIan Rogers ret = perf_pmu__convert_scale(pe->unit, &unit, &alias->scale); 451f63a536fSIan Rogers if (!ret) 452f63a536fSIan Rogers snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 453f63a536fSIan Rogers } 454f63a536fSIan Rogers return ret; 4556dde6429SThomas Richter } 4566dde6429SThomas Richter 457f26d22f1SIan Rogers static int perf_pmu__new_alias(struct perf_pmu *pmu, int dirfd, const char *name, 458edb217ffSIan Rogers const char *desc, const char *val, FILE *val_fd, 459edb217ffSIan 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 468f63a536fSIan Rogers if (perf_pmu__find_alias(pmu, name)) { 469f63a536fSIan Rogers /* Alias was already created/loaded. */ 470f63a536fSIan Rogers return 0; 471f63a536fSIan Rogers } 472f63a536fSIan Rogers 473eab35953SJin Yao if (pe) { 474330f40a0SIan Rogers long_desc = pe->long_desc; 475330f40a0SIan Rogers topic = pe->topic; 476330f40a0SIan Rogers unit = pe->unit; 477bd680861SIan Rogers perpkg = pe->perpkg; 4789ed8b7dcSIan Rogers deprecated = pe->deprecated; 479330f40a0SIan Rogers pmu_name = pe->pmu; 480eab35953SJin Yao } 481a6146d50SZheng Yan 482a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 483a6146d50SZheng Yan if (!alias) 484a6146d50SZheng Yan return -ENOMEM; 485a6146d50SZheng Yan 486a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 487410136f5SStephane Eranian alias->scale = 1.0; 488410136f5SStephane Eranian alias->unit[0] = '\0'; 489bd680861SIan Rogers alias->per_pkg = perpkg; 49084530920SStephane Eranian alias->snapshot = false; 4919ed8b7dcSIan Rogers alias->deprecated = deprecated; 492410136f5SStephane Eranian 493edb217ffSIan Rogers ret = parse_events_terms(&alias->terms, val, val_fd); 494a6146d50SZheng Yan if (ret) { 49570c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 496a6146d50SZheng Yan free(alias); 497a6146d50SZheng Yan return ret; 498a6146d50SZheng Yan } 499a6146d50SZheng Yan 500a6146d50SZheng Yan alias->name = strdup(name); 501e293a5e8SNamhyung Kim if (dirfd >= 0) { 502410136f5SStephane Eranian /* 503410136f5SStephane Eranian * load unit name and scale if available 504410136f5SStephane Eranian */ 505e293a5e8SNamhyung Kim perf_pmu__parse_unit(alias, dirfd, name); 506e293a5e8SNamhyung Kim perf_pmu__parse_scale(alias, dirfd, name); 507e293a5e8SNamhyung Kim perf_pmu__parse_per_pkg(alias, dirfd, name); 508e293a5e8SNamhyung Kim perf_pmu__parse_snapshot(alias, dirfd, name); 50970c646e0SSukadev Bhattiprolu } 510410136f5SStephane Eranian 51108e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 512c8d6828aSSukadev Bhattiprolu alias->long_desc = long_desc ? strdup(long_desc) : 513c8d6828aSSukadev Bhattiprolu desc ? strdup(desc) : NULL; 514dd5f1036SAndi Kleen alias->topic = topic ? strdup(topic) : NULL; 515f63a536fSIan Rogers alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; 516fedb2b51SAndi Kleen if (unit) { 517f63a536fSIan Rogers if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) { 518f63a536fSIan Rogers perf_pmu_free_alias(alias); 519fedb2b51SAndi Kleen return -1; 520f63a536fSIan Rogers } 521fedb2b51SAndi Kleen snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 522fedb2b51SAndi Kleen } 523f63a536fSIan Rogers if (!pe) { 524f63a536fSIan Rogers /* Update an event from sysfs with json data. */ 525*7c52f10cSIan Rogers if (pmu->events_table) { 526*7c52f10cSIan Rogers pmu_events_table__find_event(pmu->events_table, pmu, name, 527*7c52f10cSIan Rogers update_alias, alias); 528*7c52f10cSIan Rogers } 529f63a536fSIan Rogers } 530f63a536fSIan Rogers 531f63a536fSIan Rogers /* Scan event and remove leading zeroes, spaces, newlines, some 532f63a536fSIan Rogers * platforms have terms specified as 533f63a536fSIan Rogers * event=0x0091 (read from files ../<PMU>/events/<FILE> 534f63a536fSIan Rogers * and terms specified as event=0x91 (read from JSON files). 535f63a536fSIan Rogers * 536f63a536fSIan Rogers * Rebuild string to make alias->str member comparable. 537f63a536fSIan Rogers */ 538f63a536fSIan Rogers ret = 0; 539f63a536fSIan Rogers list_for_each_entry(term, &alias->terms, list) { 540f63a536fSIan Rogers if (ret) 541f63a536fSIan Rogers ret += scnprintf(newval + ret, sizeof(newval) - ret, 542f63a536fSIan Rogers ","); 543f63a536fSIan Rogers if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 544f63a536fSIan Rogers ret += scnprintf(newval + ret, sizeof(newval) - ret, 545f63a536fSIan Rogers "%s=%#x", term->config, term->val.num); 546f63a536fSIan Rogers else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 547f63a536fSIan Rogers ret += scnprintf(newval + ret, sizeof(newval) - ret, 548f63a536fSIan Rogers "%s=%s", term->config, term->val.str); 549f63a536fSIan Rogers } 5500c24d6fbSThomas Richter alias->str = strdup(newval); 551f26d22f1SIan Rogers list_add_tail(&alias->list, &pmu->aliases); 552a6146d50SZheng Yan return 0; 553a6146d50SZheng Yan } 554a6146d50SZheng Yan 55546441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 55646441bdcSMatt Fleming { 55746441bdcSMatt Fleming size_t len; 55846441bdcSMatt Fleming 55946441bdcSMatt Fleming len = strlen(name); 56046441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 56146441bdcSMatt Fleming return true; 56246441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 56346441bdcSMatt Fleming return true; 564044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 565044330c1SMatt Fleming return true; 5661d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 5671d9e446bSJiri Olsa return true; 56846441bdcSMatt Fleming 56946441bdcSMatt Fleming return false; 57046441bdcSMatt Fleming } 57146441bdcSMatt Fleming 572a6146d50SZheng Yan /* 573a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 574a6146d50SZheng Yan * specified in 'dir' parameter. 575a6146d50SZheng Yan */ 576f26d22f1SIan Rogers static int pmu_aliases_parse(struct perf_pmu *pmu, int dirfd) 577a6146d50SZheng Yan { 578a6146d50SZheng Yan struct dirent *evt_ent; 579a6146d50SZheng Yan DIR *event_dir; 580e293a5e8SNamhyung Kim int fd; 581a6146d50SZheng Yan 582e293a5e8SNamhyung Kim event_dir = fdopendir(dirfd); 583a6146d50SZheng Yan if (!event_dir) 584a6146d50SZheng Yan return -EINVAL; 585a6146d50SZheng Yan 586940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 587a6146d50SZheng Yan char *name = evt_ent->d_name; 588a6146d50SZheng Yan FILE *file; 589a6146d50SZheng Yan 590a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 591a6146d50SZheng Yan continue; 592a6146d50SZheng Yan 593410136f5SStephane Eranian /* 59446441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 595410136f5SStephane Eranian */ 59646441bdcSMatt Fleming if (pmu_alias_info_file(name)) 597410136f5SStephane Eranian continue; 598410136f5SStephane Eranian 599e293a5e8SNamhyung Kim fd = openat(dirfd, name, O_RDONLY); 6000ea8920eSIan Rogers if (fd == -1) { 6010ea8920eSIan Rogers pr_debug("Cannot open %s\n", name); 6020ea8920eSIan Rogers continue; 6030ea8920eSIan Rogers } 604e293a5e8SNamhyung Kim file = fdopen(fd, "r"); 605940db6dcSAndi Kleen if (!file) { 6060ea8920eSIan Rogers close(fd); 607940db6dcSAndi Kleen continue; 608940db6dcSAndi Kleen } 609410136f5SStephane Eranian 610f26d22f1SIan Rogers if (perf_pmu__new_alias(pmu, dirfd, name, /*desc=*/ NULL, 611edb217ffSIan Rogers /*val=*/ NULL, file, /*pe=*/ NULL) < 0) 612940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 613a6146d50SZheng Yan fclose(file); 614a6146d50SZheng Yan } 615a6146d50SZheng Yan 616a6146d50SZheng Yan closedir(event_dir); 617940db6dcSAndi Kleen return 0; 618a6146d50SZheng Yan } 619a6146d50SZheng Yan 620a6146d50SZheng Yan /* 621a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 622a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 623a6146d50SZheng Yan */ 624838a8c5fSIan Rogers static int pmu_aliases(struct perf_pmu *pmu, int dirfd, const char *name) 625a6146d50SZheng Yan { 626e293a5e8SNamhyung Kim int fd; 627a6146d50SZheng Yan 628e293a5e8SNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "events", O_DIRECTORY); 629e293a5e8SNamhyung Kim if (fd < 0) 630d9664582SAndi Kleen return 0; 631a6146d50SZheng Yan 632e293a5e8SNamhyung Kim /* it'll close the fd */ 633f26d22f1SIan Rogers if (pmu_aliases_parse(pmu, fd)) 634a6146d50SZheng Yan return -1; 635a6146d50SZheng Yan 636a6146d50SZheng Yan return 0; 637a6146d50SZheng Yan } 638a6146d50SZheng Yan 6395c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 640a6146d50SZheng Yan struct list_head *terms) 641a6146d50SZheng Yan { 6427c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 643a6146d50SZheng Yan LIST_HEAD(list); 644a6146d50SZheng Yan int ret; 645a6146d50SZheng Yan 646a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 6477c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 648a6146d50SZheng Yan if (ret) { 649682dc24cSArnaldo Carvalho de Melo parse_events_terms__purge(&list); 650a6146d50SZheng Yan return ret; 651a6146d50SZheng Yan } 652c2f1ceadSAndi Kleen /* 653c2f1ceadSAndi Kleen * Weak terms don't override command line options, 654c2f1ceadSAndi Kleen * which we don't want for implicit terms in aliases. 655c2f1ceadSAndi Kleen */ 656c2f1ceadSAndi Kleen cloned->weak = true; 6577c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 658a6146d50SZheng Yan } 659a6146d50SZheng Yan list_splice(&list, terms); 660a6146d50SZheng Yan return 0; 661a6146d50SZheng Yan } 662a6146d50SZheng Yan 66366ec1191SMark Rutland /* 66466ec1191SMark Rutland * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 66566ec1191SMark Rutland * may have a "cpus" file. 66666ec1191SMark Rutland */ 667d06593aaSIan Rogers static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core) 6687ae92e74SYan, Zheng { 669f854839bSJiri Olsa struct perf_cpu_map *cpus; 6707e3fcffeSMark Rutland const char *templates[] = { 671d50a79cdSJames Clark "cpumask", 672d50a79cdSJames Clark "cpus", 6737e3fcffeSMark Rutland NULL 6747e3fcffeSMark Rutland }; 6757e3fcffeSMark Rutland const char **template; 676d50a79cdSJames Clark char pmu_name[PATH_MAX]; 677d50a79cdSJames Clark struct perf_pmu pmu = {.name = pmu_name}; 678d50a79cdSJames Clark FILE *file; 6797ae92e74SYan, Zheng 680d50a79cdSJames Clark strlcpy(pmu_name, name, sizeof(pmu_name)); 6817e3fcffeSMark Rutland for (template = templates; *template; template++) { 6823a69672eSNamhyung Kim file = perf_pmu__open_file_at(&pmu, dirfd, *template); 683d50a79cdSJames Clark if (!file) 684d50a79cdSJames Clark continue; 685d50a79cdSJames Clark cpus = perf_cpu_map__read(file); 6863a69672eSNamhyung Kim fclose(file); 68766ec1191SMark Rutland if (cpus) 68866ec1191SMark Rutland return cpus; 6897e3fcffeSMark Rutland } 6907ae92e74SYan, Zheng 691d06593aaSIan Rogers /* Nothing found, for core PMUs assume this means all CPUs. */ 692d06593aaSIan Rogers return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL; 69366ec1191SMark Rutland } 6947ae92e74SYan, Zheng 6953a69672eSNamhyung Kim static bool pmu_is_uncore(int dirfd, const char *name) 69666ec1191SMark Rutland { 6973a69672eSNamhyung Kim int fd; 6987ae92e74SYan, Zheng 6993a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH); 7003a69672eSNamhyung Kim if (fd < 0) 7013a69672eSNamhyung Kim return false; 7023a69672eSNamhyung Kim 7033a69672eSNamhyung Kim close(fd); 7043a69672eSNamhyung Kim return true; 7057ae92e74SYan, Zheng } 7067ae92e74SYan, Zheng 70751d54847SJohn Garry static char *pmu_id(const char *name) 70851d54847SJohn Garry { 70951d54847SJohn Garry char path[PATH_MAX], *str; 71051d54847SJohn Garry size_t len; 71151d54847SJohn Garry 7125f2c8efaSJames Clark perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier"); 71351d54847SJohn Garry 7145f2c8efaSJames Clark if (filename__read_str(path, &str, &len) < 0) 71551d54847SJohn Garry return NULL; 71651d54847SJohn Garry 71751d54847SJohn Garry str[len - 1] = 0; /* remove line feed */ 71851d54847SJohn Garry 71951d54847SJohn Garry return str; 72051d54847SJohn Garry } 72151d54847SJohn Garry 7224bf7e81aSIan Rogers /** 7234bf7e81aSIan Rogers * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in 7244bf7e81aSIan Rogers * sysfs on some platforms like ARM or Intel hybrid. Looking for 7254bf7e81aSIan Rogers * possible the cpus file in sysfs files to identify whether this is a 7264bf7e81aSIan Rogers * core device. 7274bf7e81aSIan Rogers * @name: The PMU name such as "cpu_atom". 72814b22ae0SGanapatrao Kulkarni */ 7294bf7e81aSIan Rogers static int is_sysfs_pmu_core(const char *name) 73014b22ae0SGanapatrao Kulkarni { 73114b22ae0SGanapatrao Kulkarni char path[PATH_MAX]; 73214b22ae0SGanapatrao Kulkarni 733f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus")) 73414b22ae0SGanapatrao Kulkarni return 0; 735d9664582SAndi Kleen return file_available(path); 73614b22ae0SGanapatrao Kulkarni } 73714b22ae0SGanapatrao Kulkarni 73829be2fe0SIan Rogers char *perf_pmu__getcpuid(struct perf_pmu *pmu) 739d77ade9fSAndi Kleen { 740d77ade9fSAndi Kleen char *cpuid; 741d77ade9fSAndi Kleen static bool printed; 742d77ade9fSAndi Kleen 743d77ade9fSAndi Kleen cpuid = getenv("PERF_CPUID"); 744d77ade9fSAndi Kleen if (cpuid) 745d77ade9fSAndi Kleen cpuid = strdup(cpuid); 746d77ade9fSAndi Kleen if (!cpuid) 74754e32dc0SGanapatrao Kulkarni cpuid = get_cpuid_str(pmu); 748d77ade9fSAndi Kleen if (!cpuid) 749d77ade9fSAndi Kleen return NULL; 750d77ade9fSAndi Kleen 751d77ade9fSAndi Kleen if (!printed) { 752d77ade9fSAndi Kleen pr_debug("Using CPUID %s\n", cpuid); 753d77ade9fSAndi Kleen printed = true; 754d77ade9fSAndi Kleen } 755d77ade9fSAndi Kleen return cpuid; 756d77ade9fSAndi Kleen } 757d77ade9fSAndi Kleen 7581ba3752aSIan Rogers __weak const struct pmu_events_table *pmu_events_table__find(void) 759e126bef5SJohn Garry { 76096d2a746SIan Rogers return perf_pmu__find_events_table(NULL); 761e126bef5SJohn Garry } 762e126bef5SJohn Garry 763f8ea2c15SIan Rogers __weak const struct pmu_metrics_table *pmu_metrics_table__find(void) 764f8ea2c15SIan Rogers { 765f8ea2c15SIan Rogers return perf_pmu__find_metrics_table(NULL); 766f8ea2c15SIan Rogers } 767f8ea2c15SIan Rogers 768240e6fd0SIan Rogers /** 769240e6fd0SIan Rogers * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any 770240e6fd0SIan Rogers * trailing suffix? The Suffix must be in form 771240e6fd0SIan Rogers * tok_{digits}, or tok{digits}. 772240e6fd0SIan Rogers * @pmu_name: The pmu_name with possible suffix. 773240e6fd0SIan Rogers * @tok: The possible match to pmu_name without suffix. 774c07d5c92SJohn Garry */ 775240e6fd0SIan Rogers static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok) 776c47a5599SJin Yao { 777c07d5c92SJohn Garry const char *p; 778c47a5599SJin Yao 779c47a5599SJin Yao if (strncmp(pmu_name, tok, strlen(tok))) 780c47a5599SJin Yao return false; 781c47a5599SJin Yao 782c47a5599SJin Yao p = pmu_name + strlen(tok); 783c47a5599SJin Yao if (*p == 0) 784c47a5599SJin Yao return true; 785c47a5599SJin Yao 786c07d5c92SJohn Garry if (*p == '_') 787c47a5599SJin Yao ++p; 788c07d5c92SJohn Garry 789c07d5c92SJohn Garry /* Ensure we end in a number */ 790c07d5c92SJohn Garry while (1) { 791c07d5c92SJohn Garry if (!isdigit(*p)) 792c47a5599SJin Yao return false; 793c07d5c92SJohn Garry if (*(++p) == 0) 794c07d5c92SJohn Garry break; 795c07d5c92SJohn Garry } 796c47a5599SJin Yao 797c47a5599SJin Yao return true; 798c47a5599SJin Yao } 799c47a5599SJin Yao 800240e6fd0SIan Rogers /** 801240e6fd0SIan Rogers * pmu_uncore_alias_match - does name match the PMU name? 802240e6fd0SIan Rogers * @pmu_name: the json struct pmu_event name. This may lack a suffix (which 803240e6fd0SIan Rogers * matches) or be of the form "socket,pmuname" which will match 804240e6fd0SIan Rogers * "socketX_pmunameY". 805240e6fd0SIan Rogers * @name: a real full PMU name as from sysfs. 806240e6fd0SIan Rogers */ 807240e6fd0SIan Rogers static bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 808730670b1SJohn Garry { 809730670b1SJohn Garry char *tmp = NULL, *tok, *str; 810730670b1SJohn Garry bool res; 811730670b1SJohn Garry 812240e6fd0SIan Rogers if (strchr(pmu_name, ',') == NULL) 813240e6fd0SIan Rogers return perf_pmu__match_ignoring_suffix(name, pmu_name); 814240e6fd0SIan Rogers 815730670b1SJohn Garry str = strdup(pmu_name); 816730670b1SJohn Garry if (!str) 817730670b1SJohn Garry return false; 818730670b1SJohn Garry 819730670b1SJohn Garry /* 820730670b1SJohn Garry * uncore alias may be from different PMU with common prefix 821730670b1SJohn Garry */ 822730670b1SJohn Garry tok = strtok_r(str, ",", &tmp); 823730670b1SJohn Garry if (strncmp(pmu_name, tok, strlen(tok))) { 824730670b1SJohn Garry res = false; 825730670b1SJohn Garry goto out; 826730670b1SJohn Garry } 827730670b1SJohn Garry 828730670b1SJohn Garry /* 829730670b1SJohn Garry * Match more complex aliases where the alias name is a comma-delimited 830730670b1SJohn Garry * list of tokens, orderly contained in the matching PMU name. 831730670b1SJohn Garry * 832730670b1SJohn Garry * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 833730670b1SJohn Garry * match "socket" in "socketX_pmunameY" and then "pmuname" in 834730670b1SJohn Garry * "pmunameY". 835730670b1SJohn Garry */ 836c07d5c92SJohn Garry while (1) { 837c07d5c92SJohn Garry char *next_tok = strtok_r(NULL, ",", &tmp); 838c07d5c92SJohn Garry 839730670b1SJohn Garry name = strstr(name, tok); 840c07d5c92SJohn Garry if (!name || 841240e6fd0SIan Rogers (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) { 842730670b1SJohn Garry res = false; 843730670b1SJohn Garry goto out; 844730670b1SJohn Garry } 845c07d5c92SJohn Garry if (!next_tok) 846c07d5c92SJohn Garry break; 847c07d5c92SJohn Garry tok = next_tok; 848c07d5c92SJohn Garry name += strlen(tok); 849730670b1SJohn Garry } 850730670b1SJohn Garry 851730670b1SJohn Garry res = true; 852730670b1SJohn Garry out: 853730670b1SJohn Garry free(str); 854730670b1SJohn Garry return res; 855730670b1SJohn Garry } 856730670b1SJohn Garry 857660842e4SIan Rogers static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, 8581ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 859660842e4SIan Rogers void *vdata) 860660842e4SIan Rogers { 861f26d22f1SIan Rogers struct perf_pmu *pmu = vdata; 862660842e4SIan Rogers 863f26d22f1SIan Rogers perf_pmu__new_alias(pmu, -1, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe); 864660842e4SIan Rogers return 0; 865660842e4SIan Rogers } 866660842e4SIan Rogers 867933f82ffSSukadev Bhattiprolu /* 868d685819bSIan Rogers * From the pmu_events_table, find the events that correspond to the given 869d685819bSIan Rogers * PMU and add them to the list 'head'. 870933f82ffSSukadev Bhattiprolu */ 871838a8c5fSIan Rogers void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table) 872933f82ffSSukadev Bhattiprolu { 873f26d22f1SIan Rogers pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu); 874933f82ffSSukadev Bhattiprolu } 875933f82ffSSukadev Bhattiprolu 876838a8c5fSIan Rogers static void pmu_add_cpu_aliases(struct perf_pmu *pmu) 877e45ad701SJohn Garry { 878*7c52f10cSIan Rogers if (!pmu->events_table) 879e45ad701SJohn Garry return; 880e45ad701SJohn Garry 881*7c52f10cSIan Rogers pmu_add_cpu_aliases_table(pmu, pmu->events_table); 882e45ad701SJohn Garry } 883e45ad701SJohn Garry 88429be2fe0SIan Rogers static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, 8851ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 886f26d22f1SIan Rogers void *vdata) 8874513c719SJohn Garry { 888f26d22f1SIan Rogers struct perf_pmu *pmu = vdata; 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)) { 895f26d22f1SIan Rogers perf_pmu__new_alias(pmu, -1, 896edb217ffSIan Rogers pe->name, 897edb217ffSIan Rogers pe->desc, 898edb217ffSIan Rogers pe->event, 899edb217ffSIan 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 if (!pmu->id) 9094513c719SJohn Garry return; 9104513c719SJohn Garry 911f26d22f1SIan Rogers pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu); 9124513c719SJohn Garry } 9134513c719SJohn Garry 914c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 915dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 916dc0a6202SAdrian Hunter { 917dc0a6202SAdrian Hunter return NULL; 918dc0a6202SAdrian Hunter } 919dc0a6202SAdrian Hunter 92013d60ba0SKan Liang char * __weak 92113d60ba0SKan Liang pmu_find_real_name(const char *name) 92213d60ba0SKan Liang { 92313d60ba0SKan Liang return (char *)name; 92413d60ba0SKan Liang } 92513d60ba0SKan Liang 92613d60ba0SKan Liang char * __weak 92713d60ba0SKan Liang pmu_find_alias_name(const char *name __maybe_unused) 92813d60ba0SKan Liang { 92913d60ba0SKan Liang return NULL; 93013d60ba0SKan Liang } 93113d60ba0SKan Liang 9323a69672eSNamhyung Kim static int pmu_max_precise(int dirfd, struct perf_pmu *pmu) 93390a86bdeSJiri Olsa { 93490a86bdeSJiri Olsa int max_precise = -1; 93590a86bdeSJiri Olsa 9363a69672eSNamhyung Kim perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise); 93790a86bdeSJiri Olsa return max_precise; 93890a86bdeSJiri Olsa } 93990a86bdeSJiri Olsa 9401eaf496eSIan Rogers struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *lookup_name) 941cd82a32eSJiri Olsa { 942cd82a32eSJiri Olsa struct perf_pmu *pmu; 943cd82a32eSJiri Olsa __u32 type; 94413d60ba0SKan Liang char *name = pmu_find_real_name(lookup_name); 94513d60ba0SKan Liang char *alias_name; 94649afa7f6SJin Yao 947cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 948cd82a32eSJiri Olsa if (!pmu) 949cd82a32eSJiri Olsa return NULL; 950cd82a32eSJiri Olsa 951838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->format); 952838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->aliases); 953838a8c5fSIan Rogers INIT_LIST_HEAD(&pmu->caps); 954f63a536fSIan Rogers pmu->name = strdup(name); 955f63a536fSIan Rogers if (!pmu->name) 956f63a536fSIan Rogers goto err; 957838a8c5fSIan Rogers /* 958838a8c5fSIan Rogers * The pmu data we store & need consists of the pmu 959838a8c5fSIan Rogers * type value and format definitions. Load both right 960838a8c5fSIan Rogers * now. 961838a8c5fSIan Rogers */ 962838a8c5fSIan Rogers if (pmu_format(pmu, dirfd, name)) { 963838a8c5fSIan Rogers free(pmu); 964838a8c5fSIan Rogers return NULL; 965838a8c5fSIan Rogers } 966838a8c5fSIan Rogers /* 967838a8c5fSIan Rogers * Check the aliases first to avoid unnecessary work. 968838a8c5fSIan Rogers */ 969838a8c5fSIan Rogers if (pmu_aliases(pmu, dirfd, name)) { 970838a8c5fSIan Rogers free(pmu); 971838a8c5fSIan Rogers return NULL; 972838a8c5fSIan Rogers } 973d06593aaSIan Rogers pmu->is_core = is_pmu_core(name); 974d06593aaSIan Rogers pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core); 97513d60ba0SKan Liang 976f8ad6018SJames Clark /* Read type, and ensure that type value is successfully assigned (return 1) */ 9773a69672eSNamhyung Kim if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1) 978f8ad6018SJames Clark goto err; 979f8ad6018SJames Clark 98013d60ba0SKan Liang alias_name = pmu_find_alias_name(name); 98113d60ba0SKan Liang if (alias_name) { 98213d60ba0SKan Liang pmu->alias_name = strdup(alias_name); 98313d60ba0SKan Liang if (!pmu->alias_name) 98413d60ba0SKan Liang goto err; 98513d60ba0SKan Liang } 98613d60ba0SKan Liang 98754e32dc0SGanapatrao Kulkarni pmu->type = type; 9883a69672eSNamhyung Kim pmu->is_uncore = pmu_is_uncore(dirfd, name); 98951d54847SJohn Garry if (pmu->is_uncore) 99051d54847SJohn Garry pmu->id = pmu_id(name); 9913a69672eSNamhyung Kim pmu->max_precise = pmu_max_precise(dirfd, pmu); 992*7c52f10cSIan Rogers pmu->events_table = perf_pmu__find_events_table(pmu); 993838a8c5fSIan Rogers pmu_add_cpu_aliases(pmu); 994838a8c5fSIan Rogers pmu_add_sys_aliases(pmu); 9951eaf496eSIan Rogers list_add_tail(&pmu->list, pmus); 996dc0a6202SAdrian Hunter 997dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 998dc0a6202SAdrian Hunter 999cd82a32eSJiri Olsa return pmu; 100013d60ba0SKan Liang err: 1001efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 100213d60ba0SKan Liang free(pmu); 100313d60ba0SKan Liang return NULL; 1004cd82a32eSJiri Olsa } 1005cd82a32eSJiri Olsa 1006628eaa4eSIan Rogers /* Creates the PMU when sysfs scanning fails. */ 1007628eaa4eSIan Rogers struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus) 1008628eaa4eSIan Rogers { 1009628eaa4eSIan Rogers struct perf_pmu *pmu = zalloc(sizeof(*pmu)); 1010628eaa4eSIan Rogers 1011628eaa4eSIan Rogers if (!pmu) 1012628eaa4eSIan Rogers return NULL; 1013628eaa4eSIan Rogers 1014628eaa4eSIan Rogers pmu->name = strdup("cpu"); 1015628eaa4eSIan Rogers if (!pmu->name) { 1016628eaa4eSIan Rogers free(pmu); 1017628eaa4eSIan Rogers return NULL; 1018628eaa4eSIan Rogers } 1019628eaa4eSIan Rogers 1020628eaa4eSIan Rogers pmu->is_core = true; 1021628eaa4eSIan Rogers pmu->type = PERF_TYPE_RAW; 1022628eaa4eSIan Rogers pmu->cpus = cpu_map__online(); 1023628eaa4eSIan Rogers 1024628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->format); 1025628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->aliases); 1026628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->caps); 1027628eaa4eSIan Rogers list_add_tail(&pmu->list, core_pmus); 1028628eaa4eSIan Rogers return pmu; 1029628eaa4eSIan Rogers } 1030628eaa4eSIan Rogers 1031e552b7beSRob Herring void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1032e552b7beSRob Herring { 1033e552b7beSRob Herring struct perf_pmu_format *format; 1034e552b7beSRob Herring 103568c25043SIan Rogers if (pmu->formats_checked) 103668c25043SIan Rogers return; 103768c25043SIan Rogers 103868c25043SIan Rogers pmu->formats_checked = true; 103968c25043SIan Rogers 1040e552b7beSRob Herring /* fake pmu doesn't have format list */ 1041e552b7beSRob Herring if (pmu == &perf_pmu__fake) 1042e552b7beSRob Herring return; 1043e552b7beSRob Herring 104450402641SIan Rogers list_for_each_entry(format, &pmu->format, list) { 104550402641SIan Rogers perf_pmu_format__load(pmu, format); 1046e552b7beSRob Herring if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { 1047e552b7beSRob Herring pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" 1048e552b7beSRob Herring "which is not supported by this version of perf!\n", 1049e552b7beSRob Herring pmu->name, format->name, format->value); 1050e552b7beSRob Herring return; 1051e552b7beSRob Herring } 1052e552b7beSRob Herring } 105350402641SIan Rogers } 1054e552b7beSRob Herring 1055c6d616feSIan Rogers bool evsel__is_aux_event(const struct evsel *evsel) 1056e12ee9f7SAdrian Hunter { 1057e76026bdSArnaldo Carvalho de Melo struct perf_pmu *pmu = evsel__find_pmu(evsel); 1058e12ee9f7SAdrian Hunter 1059e12ee9f7SAdrian Hunter return pmu && pmu->auxtrace; 1060e12ee9f7SAdrian Hunter } 1061e12ee9f7SAdrian Hunter 10626593f019SJames Clark /* 10636593f019SJames Clark * Set @config_name to @val as long as the user hasn't already set or cleared it 10646593f019SJames Clark * by passing a config term on the command line. 10656593f019SJames Clark * 10666593f019SJames Clark * @val is the value to put into the bits specified by @config_name rather than 10676593f019SJames Clark * the bit pattern. It is shifted into position by this function, so to set 10686593f019SJames Clark * something to true, pass 1 for val rather than a pre shifted value. 10696593f019SJames Clark */ 10706593f019SJames Clark #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask)) 10716593f019SJames Clark void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel, 10726593f019SJames Clark const char *config_name, u64 val) 10736593f019SJames Clark { 10746593f019SJames Clark u64 user_bits = 0, bits; 10756593f019SJames Clark struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG); 10766593f019SJames Clark 10776593f019SJames Clark if (term) 10786593f019SJames Clark user_bits = term->val.cfg_chg; 10796593f019SJames Clark 1080da6a5afdSIan Rogers bits = perf_pmu__format_bits(pmu, config_name); 10816593f019SJames Clark 10826593f019SJames Clark /* Do nothing if the user changed the value */ 10836593f019SJames Clark if (bits & user_bits) 10846593f019SJames Clark return; 10856593f019SJames Clark 10866593f019SJames Clark /* Otherwise replace it */ 10876593f019SJames Clark evsel->core.attr.config &= ~bits; 10886593f019SJames Clark evsel->core.attr.config |= field_prep(bits, val); 10896593f019SJames Clark } 10906593f019SJames Clark 10915c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 109209ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 1093cd82a32eSJiri Olsa { 10945c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1095cd82a32eSJiri Olsa 1096cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 1097cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 1098cd82a32eSJiri Olsa return format; 1099cd82a32eSJiri Olsa 1100cd82a32eSJiri Olsa return NULL; 1101cd82a32eSJiri Olsa } 1102cd82a32eSJiri Olsa 1103da6a5afdSIan Rogers __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name) 110409ff6071SAdrian Hunter { 1105da6a5afdSIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 110609ff6071SAdrian Hunter __u64 bits = 0; 110709ff6071SAdrian Hunter int fbit; 110809ff6071SAdrian Hunter 110909ff6071SAdrian Hunter if (!format) 111009ff6071SAdrian Hunter return 0; 111109ff6071SAdrian Hunter 111209ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 111309ff6071SAdrian Hunter bits |= 1ULL << fbit; 111409ff6071SAdrian Hunter 111509ff6071SAdrian Hunter return bits; 111609ff6071SAdrian Hunter } 111709ff6071SAdrian Hunter 11187eb54733SIan Rogers int perf_pmu__format_type(struct perf_pmu *pmu, const char *name) 1119a1ac7de6SAdrian Hunter { 11207eb54733SIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 1121a1ac7de6SAdrian Hunter 1122a1ac7de6SAdrian Hunter if (!format) 1123a1ac7de6SAdrian Hunter return -1; 1124a1ac7de6SAdrian Hunter 112550402641SIan Rogers perf_pmu_format__load(pmu, format); 1126a1ac7de6SAdrian Hunter return format->value; 1127a1ac7de6SAdrian Hunter } 1128a1ac7de6SAdrian Hunter 1129cd82a32eSJiri Olsa /* 1130dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 11314d39c89fSIngo Molnar * and unformatted value (value parameter). 1132cd82a32eSJiri Olsa */ 1133dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1134dc0a6202SAdrian Hunter bool zero) 1135cd82a32eSJiri Olsa { 1136cd82a32eSJiri Olsa unsigned long fbit, vbit; 1137cd82a32eSJiri Olsa 1138cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1139cd82a32eSJiri Olsa 1140cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 1141cd82a32eSJiri Olsa continue; 1142cd82a32eSJiri Olsa 1143dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 1144dc0a6202SAdrian Hunter *v |= (1llu << fbit); 1145dc0a6202SAdrian Hunter else if (zero) 1146dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 1147cd82a32eSJiri Olsa } 1148cd82a32eSJiri Olsa } 1149cd82a32eSJiri Olsa 11500efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 11510efe6b67SAdrian Hunter { 11521b9caa10SJiri Olsa int w; 11530efe6b67SAdrian Hunter 11541b9caa10SJiri Olsa w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 11551b9caa10SJiri Olsa if (!w) 11561b9caa10SJiri Olsa return 0; 11571b9caa10SJiri Olsa if (w < 64) 11581b9caa10SJiri Olsa return (1ULL << w) - 1; 11591b9caa10SJiri Olsa return -1; 11600efe6b67SAdrian Hunter } 11610efe6b67SAdrian Hunter 1162cd82a32eSJiri Olsa /* 1163688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 1164688d4dfcSCody P Schafer * in the remaining terms. 1165688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 1166688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 1167688d4dfcSCody P Schafer * in a config string) later on in the term list. 1168688d4dfcSCody P Schafer */ 1169688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 1170688d4dfcSCody P Schafer struct list_head *head_terms, 1171688d4dfcSCody P Schafer __u64 *value) 1172688d4dfcSCody P Schafer { 1173688d4dfcSCody P Schafer struct parse_events_term *t; 1174688d4dfcSCody P Schafer 1175688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 11762a3d252dSIan Rogers if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 11772a3d252dSIan Rogers t->config && !strcmp(t->config, term->config)) { 1178688d4dfcSCody P Schafer t->used = true; 1179688d4dfcSCody P Schafer *value = t->val.num; 1180688d4dfcSCody P Schafer return 0; 1181688d4dfcSCody P Schafer } 1182688d4dfcSCody P Schafer } 1183688d4dfcSCody P Schafer 1184bb963e16SNamhyung Kim if (verbose > 0) 1185688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 1186688d4dfcSCody P Schafer 1187688d4dfcSCody P Schafer return -1; 1188688d4dfcSCody P Schafer } 1189688d4dfcSCody P Schafer 1190ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 1191e64b020bSJiri Olsa { 1192e64b020bSJiri Olsa struct perf_pmu_format *format; 119311db4e29SMasami Hiramatsu char *str = NULL; 119411db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1195f1417ceaSXin Gao unsigned int i = 0; 1196e64b020bSJiri Olsa 1197ffeb883eSHe Kuang if (!formats) 1198e64b020bSJiri Olsa return NULL; 1199e64b020bSJiri Olsa 1200e64b020bSJiri Olsa /* sysfs exported terms */ 1201ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 120211db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 120311db4e29SMasami Hiramatsu goto error; 1204e64b020bSJiri Olsa 1205ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 120611db4e29SMasami Hiramatsu error: 1207ffeb883eSHe Kuang strbuf_release(&buf); 1208e64b020bSJiri Olsa 1209e64b020bSJiri Olsa return str; 1210e64b020bSJiri Olsa } 1211e64b020bSJiri Olsa 1212688d4dfcSCody P Schafer /* 1213cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 121488aca8d9SCody P Schafer * user input data - term parameter. 1215cd82a32eSJiri Olsa */ 1216804fee5dSIan Rogers static int pmu_config_term(struct perf_pmu *pmu, 1217cd82a32eSJiri Olsa struct perf_event_attr *attr, 1218dc0a6202SAdrian Hunter struct parse_events_term *term, 1219688d4dfcSCody P Schafer struct list_head *head_terms, 1220e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1221cd82a32eSJiri Olsa { 12225c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1223cd82a32eSJiri Olsa __u64 *vp; 12240efe6b67SAdrian Hunter __u64 val, max_val; 1225cd82a32eSJiri Olsa 1226cd82a32eSJiri Olsa /* 1227688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 1228688d4dfcSCody P Schafer * skip it in normal eval. 1229688d4dfcSCody P Schafer */ 1230688d4dfcSCody P Schafer if (term->used) 1231688d4dfcSCody P Schafer return 0; 1232688d4dfcSCody P Schafer 1233688d4dfcSCody P Schafer /* 1234cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 1235cd82a32eSJiri Olsa * to be done for them. 1236cd82a32eSJiri Olsa */ 1237cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 1238cd82a32eSJiri Olsa return 0; 1239cd82a32eSJiri Olsa 1240804fee5dSIan Rogers format = pmu_find_format(&pmu->format, term->config); 1241688d4dfcSCody P Schafer if (!format) { 1242804fee5dSIan Rogers char *pmu_term = pmu_formats_string(&pmu->format); 12434ac22b48SIan Rogers char *unknown_term; 12444ac22b48SIan Rogers char *help_msg; 1245ffeb883eSHe Kuang 12464ac22b48SIan Rogers if (asprintf(&unknown_term, 12474ac22b48SIan Rogers "unknown term '%s' for pmu '%s'", 1248804fee5dSIan Rogers term->config, pmu->name) < 0) 12494ac22b48SIan Rogers unknown_term = NULL; 12504ac22b48SIan Rogers help_msg = parse_events_formats_error_string(pmu_term); 12514ac22b48SIan Rogers if (err) { 12526c191289SIan Rogers parse_events_error__handle(err, term->err_term, 12534ac22b48SIan Rogers unknown_term, 12544ac22b48SIan Rogers help_msg); 12554ac22b48SIan Rogers } else { 12564ac22b48SIan Rogers pr_debug("%s (%s)\n", unknown_term, help_msg); 12574ac22b48SIan Rogers free(unknown_term); 1258e64b020bSJiri Olsa } 12594ac22b48SIan Rogers free(pmu_term); 1260cd82a32eSJiri Olsa return -EINVAL; 1261688d4dfcSCody P Schafer } 126250402641SIan Rogers perf_pmu_format__load(pmu, format); 1263cd82a32eSJiri Olsa switch (format->value) { 1264cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 1265cd82a32eSJiri Olsa vp = &attr->config; 1266cd82a32eSJiri Olsa break; 1267cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 1268cd82a32eSJiri Olsa vp = &attr->config1; 1269cd82a32eSJiri Olsa break; 1270cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 1271cd82a32eSJiri Olsa vp = &attr->config2; 1272cd82a32eSJiri Olsa break; 1273204e7c49SRob Herring case PERF_PMU_FORMAT_VALUE_CONFIG3: 1274204e7c49SRob Herring vp = &attr->config3; 1275204e7c49SRob Herring break; 1276cd82a32eSJiri Olsa default: 1277cd82a32eSJiri Olsa return -EINVAL; 1278cd82a32eSJiri Olsa } 1279cd82a32eSJiri Olsa 128016fa7e82SJiri Olsa /* 1281688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 1282688d4dfcSCody P Schafer * using event parameters. 128316fa7e82SJiri Olsa */ 128499e7138eSJiri Olsa if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 128599e7138eSJiri Olsa if (term->no_value && 128699e7138eSJiri Olsa bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 128799e7138eSJiri Olsa if (err) { 12886c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1289448d732cSIan Rogers strdup("no value assigned for term"), 1290448d732cSIan Rogers NULL); 129199e7138eSJiri Olsa } 129299e7138eSJiri Olsa return -EINVAL; 129399e7138eSJiri Olsa } 129499e7138eSJiri Olsa 1295688d4dfcSCody P Schafer val = term->val.num; 129699e7138eSJiri Olsa } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1297688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 1298bb963e16SNamhyung Kim if (verbose > 0) { 1299688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 1300688d4dfcSCody P Schafer term->config, term->val.str); 1301e64b020bSJiri Olsa } 1302e64b020bSJiri Olsa if (err) { 13036c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1304448d732cSIan Rogers strdup("expected numeric value"), 1305448d732cSIan Rogers NULL); 1306e64b020bSJiri Olsa } 1307688d4dfcSCody P Schafer return -EINVAL; 1308688d4dfcSCody P Schafer } 1309688d4dfcSCody P Schafer 1310688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 1311688d4dfcSCody P Schafer return -EINVAL; 1312688d4dfcSCody P Schafer } else 1313688d4dfcSCody P Schafer return -EINVAL; 1314688d4dfcSCody P Schafer 13150efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 13160efe6b67SAdrian Hunter if (val > max_val) { 13170efe6b67SAdrian Hunter if (err) { 1318448d732cSIan Rogers char *err_str; 1319448d732cSIan Rogers 13206c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1321448d732cSIan Rogers asprintf(&err_str, 13220efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 1323448d732cSIan Rogers (unsigned long long)max_val) < 0 1324448d732cSIan Rogers ? strdup("value too big for format") 1325448d732cSIan Rogers : err_str, 1326448d732cSIan Rogers NULL); 13270efe6b67SAdrian Hunter return -EINVAL; 13280efe6b67SAdrian Hunter } 13290efe6b67SAdrian Hunter /* 13300efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 13310efe6b67SAdrian Hunter * silently truncated. 13320efe6b67SAdrian Hunter */ 13330efe6b67SAdrian Hunter } 13340efe6b67SAdrian Hunter 1335688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 1336cd82a32eSJiri Olsa return 0; 1337cd82a32eSJiri Olsa } 1338cd82a32eSJiri Olsa 1339804fee5dSIan Rogers int perf_pmu__config_terms(struct perf_pmu *pmu, 1340cff7f956SJiri Olsa struct perf_event_attr *attr, 1341dc0a6202SAdrian Hunter struct list_head *head_terms, 1342e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1343cd82a32eSJiri Olsa { 13446cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 1345cd82a32eSJiri Olsa 1346688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 1347804fee5dSIan Rogers if (pmu_config_term(pmu, attr, term, head_terms, zero, err)) 1348cd82a32eSJiri Olsa return -EINVAL; 1349688d4dfcSCody P Schafer } 1350cd82a32eSJiri Olsa 1351cd82a32eSJiri Olsa return 0; 1352cd82a32eSJiri Olsa } 1353cd82a32eSJiri Olsa 1354cd82a32eSJiri Olsa /* 1355cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 1356cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 1357cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 1358cd82a32eSJiri Olsa */ 1359cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1360e64b020bSJiri Olsa struct list_head *head_terms, 1361e64b020bSJiri Olsa struct parse_events_error *err) 1362cd82a32eSJiri Olsa { 1363dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 1364dc0a6202SAdrian Hunter 1365804fee5dSIan Rogers return perf_pmu__config_terms(pmu, attr, head_terms, zero, err); 1366cd82a32eSJiri Olsa } 1367cd82a32eSJiri Olsa 13685c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 13696cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 1370a6146d50SZheng Yan { 1371a6146d50SZheng Yan char *name; 1372a6146d50SZheng Yan 1373a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 1374a6146d50SZheng Yan return NULL; 1375a6146d50SZheng Yan 1376a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1377a6146d50SZheng Yan if (term->val.num != 1) 1378a6146d50SZheng Yan return NULL; 1379a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 1380a6146d50SZheng Yan return NULL; 1381a6146d50SZheng Yan name = term->config; 1382c3245d20SIan Rogers 1383a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1384a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 1385a6146d50SZheng Yan return NULL; 1386a6146d50SZheng Yan name = term->val.str; 1387a6146d50SZheng Yan } else { 1388a6146d50SZheng Yan return NULL; 1389a6146d50SZheng Yan } 1390a6146d50SZheng Yan 1391c3245d20SIan Rogers return perf_pmu__find_alias(pmu, name); 1392a6146d50SZheng Yan } 1393a6146d50SZheng Yan 1394410136f5SStephane Eranian 13951d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 13969d31cb93SIan Rogers struct perf_pmu_info *info, 13979d31cb93SIan Rogers struct parse_events_error *err, 13989d31cb93SIan Rogers int column) 1399410136f5SStephane Eranian { 1400410136f5SStephane Eranian /* 1401410136f5SStephane Eranian * Only one term in event definition can 14021d9e446bSJiri Olsa * define unit, scale and snapshot, fail 14031d9e446bSJiri Olsa * if there's more than one. 1404410136f5SStephane Eranian */ 14059d31cb93SIan Rogers if (info->unit && alias->unit[0]) { 14069d31cb93SIan Rogers parse_events_error__handle(err, column, 14079d31cb93SIan Rogers strdup("Attempt to set event's unit twice"), 14089d31cb93SIan Rogers NULL); 1409410136f5SStephane Eranian return -EINVAL; 14109d31cb93SIan Rogers } 14119d31cb93SIan Rogers if (info->scale && alias->scale) { 14129d31cb93SIan Rogers parse_events_error__handle(err, column, 14139d31cb93SIan Rogers strdup("Attempt to set event's scale twice"), 14149d31cb93SIan Rogers NULL); 14159d31cb93SIan Rogers return -EINVAL; 14169d31cb93SIan Rogers } 14179d31cb93SIan Rogers if (info->snapshot && alias->snapshot) { 14189d31cb93SIan Rogers parse_events_error__handle(err, column, 14199d31cb93SIan Rogers strdup("Attempt to set event snapshot twice"), 14209d31cb93SIan Rogers NULL); 14219d31cb93SIan Rogers return -EINVAL; 14229d31cb93SIan Rogers } 1423410136f5SStephane Eranian 1424b30a7d1fSArnaldo Carvalho de Melo if (alias->unit[0]) 14251d9e446bSJiri Olsa info->unit = alias->unit; 1426410136f5SStephane Eranian 1427410136f5SStephane Eranian if (alias->scale) 14281d9e446bSJiri Olsa info->scale = alias->scale; 14291d9e446bSJiri Olsa 14301d9e446bSJiri Olsa if (alias->snapshot) 14311d9e446bSJiri Olsa info->snapshot = alias->snapshot; 1432410136f5SStephane Eranian 1433410136f5SStephane Eranian return 0; 1434410136f5SStephane Eranian } 1435410136f5SStephane Eranian 1436a6146d50SZheng Yan /* 1437a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 1438a6146d50SZheng Yan * defined for the alias 1439a6146d50SZheng Yan */ 1440410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 14419d31cb93SIan Rogers struct perf_pmu_info *info, struct parse_events_error *err) 1442a6146d50SZheng Yan { 14436cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 14445c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1445a6146d50SZheng Yan int ret; 1446a6146d50SZheng Yan 1447044330c1SMatt Fleming info->per_pkg = false; 1448044330c1SMatt Fleming 14498a398897SStephane Eranian /* 14508a398897SStephane Eranian * Mark unit and scale as not set 14518a398897SStephane Eranian * (different from default values, see below) 14528a398897SStephane Eranian */ 145346441bdcSMatt Fleming info->unit = NULL; 145446441bdcSMatt Fleming info->scale = 0.0; 14551d9e446bSJiri Olsa info->snapshot = false; 1456410136f5SStephane Eranian 1457a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 1458a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 1459a6146d50SZheng Yan if (!alias) 1460a6146d50SZheng Yan continue; 1461a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 14629d31cb93SIan Rogers if (ret) { 14639d31cb93SIan Rogers parse_events_error__handle(err, term->err_term, 14649d31cb93SIan Rogers strdup("Failure to duplicate terms"), 14659d31cb93SIan Rogers NULL); 1466a6146d50SZheng Yan return ret; 14679d31cb93SIan Rogers } 1468410136f5SStephane Eranian 14699d31cb93SIan Rogers ret = check_info_data(alias, info, err, term->err_term); 1470410136f5SStephane Eranian if (ret) 1471410136f5SStephane Eranian return ret; 1472410136f5SStephane Eranian 1473044330c1SMatt Fleming if (alias->per_pkg) 1474044330c1SMatt Fleming info->per_pkg = true; 1475044330c1SMatt Fleming 1476e56fbc9dSArnaldo Carvalho de Melo list_del_init(&term->list); 14771dc92556SIan Rogers parse_events_term__delete(term); 1478a6146d50SZheng Yan } 14798a398897SStephane Eranian 14808a398897SStephane Eranian /* 14818a398897SStephane Eranian * if no unit or scale found in aliases, then 14828a398897SStephane Eranian * set defaults as for evsel 14838a398897SStephane Eranian * unit cannot left to NULL 14848a398897SStephane Eranian */ 148546441bdcSMatt Fleming if (info->unit == NULL) 148646441bdcSMatt Fleming info->unit = ""; 14878a398897SStephane Eranian 148846441bdcSMatt Fleming if (info->scale == 0.0) 148946441bdcSMatt Fleming info->scale = 1.0; 14908a398897SStephane Eranian 1491a6146d50SZheng Yan return 0; 1492a6146d50SZheng Yan } 1493a6146d50SZheng Yan 1494c3245d20SIan Rogers struct find_event_args { 1495c3245d20SIan Rogers const char *event; 1496c3245d20SIan Rogers void *state; 1497c3245d20SIan Rogers pmu_event_callback cb; 1498c3245d20SIan Rogers }; 1499c3245d20SIan Rogers 1500c3245d20SIan Rogers static int find_event_callback(void *state, struct pmu_event_info *info) 1501838a8c5fSIan Rogers { 1502c3245d20SIan Rogers struct find_event_args *args = state; 1503838a8c5fSIan Rogers 1504c3245d20SIan Rogers if (!strcmp(args->event, info->name)) 1505c3245d20SIan Rogers return args->cb(args->state, info); 1506838a8c5fSIan Rogers 1507c3245d20SIan Rogers return 0; 1508838a8c5fSIan Rogers } 1509c3245d20SIan Rogers 1510c3245d20SIan Rogers int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb) 1511c3245d20SIan Rogers { 1512c3245d20SIan Rogers struct find_event_args args = { 1513c3245d20SIan Rogers .event = event, 1514c3245d20SIan Rogers .state = state, 1515c3245d20SIan Rogers .cb = cb, 1516c3245d20SIan Rogers }; 1517c3245d20SIan Rogers 1518c3245d20SIan Rogers return perf_pmu__for_each_event(pmu, &args, find_event_callback); 1519c3245d20SIan Rogers } 1520c3245d20SIan Rogers 1521804fee5dSIan Rogers static void perf_pmu__del_formats(struct list_head *formats) 1522d26383dcSNamhyung Kim { 1523d26383dcSNamhyung Kim struct perf_pmu_format *fmt, *tmp; 1524d26383dcSNamhyung Kim 1525d26383dcSNamhyung Kim list_for_each_entry_safe(fmt, tmp, formats, list) { 1526d26383dcSNamhyung Kim list_del(&fmt->list); 1527efe98a7aSArnaldo Carvalho de Melo zfree(&fmt->name); 1528d26383dcSNamhyung Kim free(fmt); 1529d26383dcSNamhyung Kim } 1530d26383dcSNamhyung Kim } 1531d26383dcSNamhyung Kim 153207d2b820SIan Rogers bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name) 153307d2b820SIan Rogers { 153407d2b820SIan Rogers struct perf_pmu_format *format; 153507d2b820SIan Rogers 153607d2b820SIan Rogers list_for_each_entry(format, &pmu->format, list) { 153707d2b820SIan Rogers if (!strcmp(format->name, name)) 153807d2b820SIan Rogers return true; 153907d2b820SIan Rogers } 154007d2b820SIan Rogers return false; 154107d2b820SIan Rogers } 154207d2b820SIan Rogers 1543d504fae9SJohn Garry bool is_pmu_core(const char *name) 1544d504fae9SJohn Garry { 15456fbd67b0SThomas Richter return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name); 15464bf7e81aSIan Rogers } 15474bf7e81aSIan Rogers 15486fd1e519SIan Rogers bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu) 15496fd1e519SIan Rogers { 1550e20d1f2fSIan Rogers return pmu->is_core; 15516fd1e519SIan Rogers } 15526fd1e519SIan Rogers 155352c7b4d3SIan Rogers bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu) 155452c7b4d3SIan Rogers { 1555710dffc9SIan Rogers return !pmu->is_core || perf_pmus__num_core_pmus() == 1; 155652c7b4d3SIan Rogers } 155752c7b4d3SIan Rogers 15581eaf496eSIan Rogers bool perf_pmu__have_event(const struct perf_pmu *pmu, const char *name) 1559abe9544eSIan Rogers { 1560c3245d20SIan Rogers return perf_pmu__find_alias(pmu, name) != NULL; 15614cabc3d1SAndi Kleen } 1562c3245d20SIan Rogers 1563c3245d20SIan Rogers size_t perf_pmu__num_events(const struct perf_pmu *pmu) 1564c3245d20SIan Rogers { 1565c3245d20SIan Rogers struct list_head *list; 1566c3245d20SIan Rogers size_t nr = 0; 1567c3245d20SIan Rogers 1568c3245d20SIan Rogers list_for_each(list, &pmu->aliases) 1569c3245d20SIan Rogers nr++; 1570c3245d20SIan Rogers 1571c3245d20SIan Rogers return pmu->selectable ? nr + 1 : nr; 1572c3245d20SIan Rogers } 1573c3245d20SIan Rogers 1574c3245d20SIan Rogers static int sub_non_neg(int a, int b) 1575c3245d20SIan Rogers { 1576c3245d20SIan Rogers if (b > a) 1577c3245d20SIan Rogers return 0; 1578c3245d20SIan Rogers return a - b; 1579c3245d20SIan Rogers } 1580c3245d20SIan Rogers 1581c3245d20SIan Rogers static char *format_alias(char *buf, int len, const struct perf_pmu *pmu, 1582c3245d20SIan Rogers const struct perf_pmu_alias *alias) 1583c3245d20SIan Rogers { 1584c3245d20SIan Rogers struct parse_events_term *term; 1585c3245d20SIan Rogers int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1586c3245d20SIan Rogers 1587c3245d20SIan Rogers list_for_each_entry(term, &alias->terms, list) { 1588c3245d20SIan Rogers if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1589c3245d20SIan Rogers used += snprintf(buf + used, sub_non_neg(len, used), 1590c3245d20SIan Rogers ",%s=%s", term->config, 1591c3245d20SIan Rogers term->val.str); 1592c3245d20SIan Rogers } 1593c3245d20SIan Rogers 1594c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1595c3245d20SIan Rogers buf[used] = '/'; 1596c3245d20SIan Rogers used++; 1597c3245d20SIan Rogers } 1598c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1599c3245d20SIan Rogers buf[used] = '\0'; 1600c3245d20SIan Rogers used++; 1601c3245d20SIan Rogers } else 1602c3245d20SIan Rogers buf[len - 1] = '\0'; 1603c3245d20SIan Rogers 1604c3245d20SIan Rogers return buf; 1605c3245d20SIan Rogers } 1606c3245d20SIan Rogers 1607c3245d20SIan Rogers int perf_pmu__for_each_event(const struct perf_pmu *pmu, void *state, pmu_event_callback cb) 1608c3245d20SIan Rogers { 1609c3245d20SIan Rogers char buf[1024]; 1610c3245d20SIan Rogers struct perf_pmu_alias *event; 1611c3245d20SIan Rogers struct pmu_event_info info = { 1612c3245d20SIan Rogers .pmu = pmu, 1613c3245d20SIan Rogers }; 1614c3245d20SIan Rogers int ret = 0; 1615c3245d20SIan Rogers 1616c3245d20SIan Rogers list_for_each_entry(event, &pmu->aliases, list) { 1617c3245d20SIan Rogers size_t buf_used; 1618c3245d20SIan Rogers 1619c3245d20SIan Rogers info.pmu_name = event->pmu_name ?: pmu->name; 1620c3245d20SIan Rogers info.alias = NULL; 1621c3245d20SIan Rogers if (event->desc) { 1622c3245d20SIan Rogers info.name = event->name; 1623c3245d20SIan Rogers buf_used = 0; 1624c3245d20SIan Rogers } else { 1625c3245d20SIan Rogers info.name = format_alias(buf, sizeof(buf), pmu, event); 1626c3245d20SIan Rogers if (pmu->is_core) { 1627c3245d20SIan Rogers info.alias = info.name; 1628c3245d20SIan Rogers info.name = event->name; 1629c3245d20SIan Rogers } 1630c3245d20SIan Rogers buf_used = strlen(buf) + 1; 1631c3245d20SIan Rogers } 1632c3245d20SIan Rogers info.scale_unit = NULL; 1633c3245d20SIan Rogers if (strlen(event->unit) || event->scale != 1.0) { 1634c3245d20SIan Rogers info.scale_unit = buf + buf_used; 1635c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1636c3245d20SIan Rogers "%G%s", event->scale, event->unit) + 1; 1637c3245d20SIan Rogers } 1638c3245d20SIan Rogers info.desc = event->desc; 1639c3245d20SIan Rogers info.long_desc = event->long_desc; 1640c3245d20SIan Rogers info.encoding_desc = buf + buf_used; 1641c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1642c3245d20SIan Rogers "%s/%s/", info.pmu_name, event->str) + 1; 1643c3245d20SIan Rogers info.topic = event->topic; 1644c3245d20SIan Rogers info.str = event->str; 1645c3245d20SIan Rogers info.deprecated = event->deprecated; 1646c3245d20SIan Rogers ret = cb(state, &info); 1647c3245d20SIan Rogers if (ret) 1648c3245d20SIan Rogers return ret; 1649c3245d20SIan Rogers } 1650c3245d20SIan Rogers if (pmu->selectable) { 1651c3245d20SIan Rogers info.name = buf; 1652c3245d20SIan Rogers snprintf(buf, sizeof(buf), "%s//", pmu->name); 1653c3245d20SIan Rogers info.alias = NULL; 1654c3245d20SIan Rogers info.scale_unit = NULL; 1655c3245d20SIan Rogers info.desc = NULL; 1656c3245d20SIan Rogers info.long_desc = NULL; 1657c3245d20SIan Rogers info.encoding_desc = NULL; 1658c3245d20SIan Rogers info.topic = NULL; 1659c3245d20SIan Rogers info.pmu_name = pmu->name; 1660c3245d20SIan Rogers info.deprecated = false; 1661c3245d20SIan Rogers ret = cb(state, &info); 1662c3245d20SIan Rogers } 1663c3245d20SIan Rogers return ret; 16644cabc3d1SAndi Kleen } 16657d4bdab5SAdrian Hunter 1666e3edd6cfSIan Rogers bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name) 1667e3edd6cfSIan Rogers { 1668e3edd6cfSIan Rogers return !strcmp(pmu->name, pmu_name) || 1669e3edd6cfSIan Rogers (pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)); 1670e3edd6cfSIan Rogers } 1671e3edd6cfSIan Rogers 1672251aa040SIan Rogers bool perf_pmu__is_software(const struct perf_pmu *pmu) 1673251aa040SIan Rogers { 1674251aa040SIan Rogers if (pmu->is_core || pmu->is_uncore || pmu->auxtrace) 1675251aa040SIan Rogers return false; 1676251aa040SIan Rogers switch (pmu->type) { 1677251aa040SIan Rogers case PERF_TYPE_HARDWARE: return false; 1678251aa040SIan Rogers case PERF_TYPE_SOFTWARE: return true; 1679251aa040SIan Rogers case PERF_TYPE_TRACEPOINT: return true; 1680251aa040SIan Rogers case PERF_TYPE_HW_CACHE: return false; 1681251aa040SIan Rogers case PERF_TYPE_RAW: return false; 1682251aa040SIan Rogers case PERF_TYPE_BREAKPOINT: return true; 1683251aa040SIan Rogers default: break; 1684251aa040SIan Rogers } 1685251aa040SIan Rogers return !strcmp(pmu->name, "kprobe") || !strcmp(pmu->name, "uprobe"); 1686251aa040SIan Rogers } 1687251aa040SIan Rogers 1688d50a79cdSJames Clark FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 16897d4bdab5SAdrian Hunter { 16907d4bdab5SAdrian Hunter char path[PATH_MAX]; 16917d4bdab5SAdrian Hunter 1692f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) || 1693f8ad6018SJames Clark !file_available(path)) 16947d4bdab5SAdrian Hunter return NULL; 16957d4bdab5SAdrian Hunter 16967d4bdab5SAdrian Hunter return fopen(path, "r"); 16977d4bdab5SAdrian Hunter } 16987d4bdab5SAdrian Hunter 16993a69672eSNamhyung Kim FILE *perf_pmu__open_file_at(struct perf_pmu *pmu, int dirfd, const char *name) 17003a69672eSNamhyung Kim { 17013a69672eSNamhyung Kim int fd; 17023a69672eSNamhyung Kim 17033a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY); 17043a69672eSNamhyung Kim if (fd < 0) 17053a69672eSNamhyung Kim return NULL; 17063a69672eSNamhyung Kim 17073a69672eSNamhyung Kim return fdopen(fd, "r"); 17083a69672eSNamhyung Kim } 17093a69672eSNamhyung Kim 17107d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 17117d4bdab5SAdrian Hunter ...) 17127d4bdab5SAdrian Hunter { 17137d4bdab5SAdrian Hunter va_list args; 17147d4bdab5SAdrian Hunter FILE *file; 17157d4bdab5SAdrian Hunter int ret = EOF; 17167d4bdab5SAdrian Hunter 17177d4bdab5SAdrian Hunter va_start(args, fmt); 17187d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 17197d4bdab5SAdrian Hunter if (file) { 17207d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 17217d4bdab5SAdrian Hunter fclose(file); 17227d4bdab5SAdrian Hunter } 17237d4bdab5SAdrian Hunter va_end(args); 17247d4bdab5SAdrian Hunter return ret; 17257d4bdab5SAdrian Hunter } 17269fbc61f8SKan Liang 17273a69672eSNamhyung Kim int perf_pmu__scan_file_at(struct perf_pmu *pmu, int dirfd, const char *name, 17283a69672eSNamhyung Kim const char *fmt, ...) 17293a69672eSNamhyung Kim { 17303a69672eSNamhyung Kim va_list args; 17313a69672eSNamhyung Kim FILE *file; 17323a69672eSNamhyung Kim int ret = EOF; 17333a69672eSNamhyung Kim 17343a69672eSNamhyung Kim va_start(args, fmt); 17353a69672eSNamhyung Kim file = perf_pmu__open_file_at(pmu, dirfd, name); 17363a69672eSNamhyung Kim if (file) { 17373a69672eSNamhyung Kim ret = vfscanf(file, fmt, args); 17383a69672eSNamhyung Kim fclose(file); 17393a69672eSNamhyung Kim } 17403a69672eSNamhyung Kim va_end(args); 17413a69672eSNamhyung Kim return ret; 17423a69672eSNamhyung Kim } 17433a69672eSNamhyung Kim 1744c2b6a896SGerman Gomez bool perf_pmu__file_exists(struct perf_pmu *pmu, const char *name) 1745c2b6a896SGerman Gomez { 1746c2b6a896SGerman Gomez char path[PATH_MAX]; 1747c2b6a896SGerman Gomez 1748c2b6a896SGerman Gomez if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name)) 1749c2b6a896SGerman Gomez return false; 1750c2b6a896SGerman Gomez 1751c2b6a896SGerman Gomez return file_available(path); 1752c2b6a896SGerman Gomez } 1753c2b6a896SGerman Gomez 17549fbc61f8SKan Liang static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 17559fbc61f8SKan Liang { 17569fbc61f8SKan Liang struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 17579fbc61f8SKan Liang 17589fbc61f8SKan Liang if (!caps) 17599fbc61f8SKan Liang return -ENOMEM; 17609fbc61f8SKan Liang 17619fbc61f8SKan Liang caps->name = strdup(name); 17629fbc61f8SKan Liang if (!caps->name) 17639fbc61f8SKan Liang goto free_caps; 17649fbc61f8SKan Liang caps->value = strndup(value, strlen(value) - 1); 17659fbc61f8SKan Liang if (!caps->value) 17669fbc61f8SKan Liang goto free_name; 17679fbc61f8SKan Liang list_add_tail(&caps->list, list); 17689fbc61f8SKan Liang return 0; 17699fbc61f8SKan Liang 17709fbc61f8SKan Liang free_name: 177157f14b5aSArnaldo Carvalho de Melo zfree(&caps->name); 17729fbc61f8SKan Liang free_caps: 17739fbc61f8SKan Liang free(caps); 17749fbc61f8SKan Liang 17759fbc61f8SKan Liang return -ENOMEM; 17769fbc61f8SKan Liang } 17779fbc61f8SKan Liang 1778eec11310SNamhyung Kim static void perf_pmu__del_caps(struct perf_pmu *pmu) 1779eec11310SNamhyung Kim { 1780eec11310SNamhyung Kim struct perf_pmu_caps *caps, *tmp; 1781eec11310SNamhyung Kim 1782eec11310SNamhyung Kim list_for_each_entry_safe(caps, tmp, &pmu->caps, list) { 1783eec11310SNamhyung Kim list_del(&caps->list); 1784efe98a7aSArnaldo Carvalho de Melo zfree(&caps->name); 1785efe98a7aSArnaldo Carvalho de Melo zfree(&caps->value); 1786eec11310SNamhyung Kim free(caps); 1787eec11310SNamhyung Kim } 1788eec11310SNamhyung Kim } 1789eec11310SNamhyung Kim 17909fbc61f8SKan Liang /* 17919fbc61f8SKan Liang * Reading/parsing the given pmu capabilities, which should be located at: 17929fbc61f8SKan Liang * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 17939fbc61f8SKan Liang * Return the number of capabilities 17949fbc61f8SKan Liang */ 17959fbc61f8SKan Liang int perf_pmu__caps_parse(struct perf_pmu *pmu) 17969fbc61f8SKan Liang { 17979fbc61f8SKan Liang struct stat st; 17989fbc61f8SKan Liang char caps_path[PATH_MAX]; 17999fbc61f8SKan Liang DIR *caps_dir; 18009fbc61f8SKan Liang struct dirent *evt_ent; 1801b39094d3SNamhyung Kim int caps_fd; 18023339ec44SRavi Bangoria 18033339ec44SRavi Bangoria if (pmu->caps_initialized) 18043339ec44SRavi Bangoria return pmu->nr_caps; 18053339ec44SRavi Bangoria 18063339ec44SRavi Bangoria pmu->nr_caps = 0; 18079fbc61f8SKan Liang 1808f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps")) 18099fbc61f8SKan Liang return -1; 18109fbc61f8SKan Liang 18113339ec44SRavi Bangoria if (stat(caps_path, &st) < 0) { 18123339ec44SRavi Bangoria pmu->caps_initialized = true; 18139fbc61f8SKan Liang return 0; /* no error if caps does not exist */ 18143339ec44SRavi Bangoria } 18159fbc61f8SKan Liang 18169fbc61f8SKan Liang caps_dir = opendir(caps_path); 18179fbc61f8SKan Liang if (!caps_dir) 18189fbc61f8SKan Liang return -EINVAL; 18199fbc61f8SKan Liang 1820b39094d3SNamhyung Kim caps_fd = dirfd(caps_dir); 1821b39094d3SNamhyung Kim 18229fbc61f8SKan Liang while ((evt_ent = readdir(caps_dir)) != NULL) { 18239fbc61f8SKan Liang char *name = evt_ent->d_name; 18249fbc61f8SKan Liang char value[128]; 18259fbc61f8SKan Liang FILE *file; 1826b39094d3SNamhyung Kim int fd; 18279fbc61f8SKan Liang 18289fbc61f8SKan Liang if (!strcmp(name, ".") || !strcmp(name, "..")) 18299fbc61f8SKan Liang continue; 18309fbc61f8SKan Liang 1831b39094d3SNamhyung Kim fd = openat(caps_fd, name, O_RDONLY); 18320ea8920eSIan Rogers if (fd == -1) 18339fbc61f8SKan Liang continue; 18340ea8920eSIan Rogers file = fdopen(fd, "r"); 18350ea8920eSIan Rogers if (!file) { 18360ea8920eSIan Rogers close(fd); 18370ea8920eSIan Rogers continue; 18380ea8920eSIan Rogers } 18399fbc61f8SKan Liang 18409fbc61f8SKan Liang if (!fgets(value, sizeof(value), file) || 18419fbc61f8SKan Liang (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 18429fbc61f8SKan Liang fclose(file); 18439fbc61f8SKan Liang continue; 18449fbc61f8SKan Liang } 18459fbc61f8SKan Liang 18463339ec44SRavi Bangoria pmu->nr_caps++; 18479fbc61f8SKan Liang fclose(file); 18489fbc61f8SKan Liang } 18499fbc61f8SKan Liang 18509fbc61f8SKan Liang closedir(caps_dir); 18519fbc61f8SKan Liang 18523339ec44SRavi Bangoria pmu->caps_initialized = true; 18533339ec44SRavi Bangoria return pmu->nr_caps; 18549fbc61f8SKan Liang } 1855e4064776SJin Yao 1856b9f01032SIan Rogers static void perf_pmu__compute_config_masks(struct perf_pmu *pmu) 1857e4064776SJin Yao { 1858e4064776SJin Yao struct perf_pmu_format *format; 1859b9f01032SIan Rogers 1860b9f01032SIan Rogers if (pmu->config_masks_computed) 1861b9f01032SIan Rogers return; 1862e4064776SJin Yao 1863e4064776SJin Yao list_for_each_entry(format, &pmu->format, list) { 1864b9f01032SIan Rogers unsigned int i; 1865b9f01032SIan Rogers __u64 *mask; 1866b9f01032SIan Rogers 1867b9f01032SIan Rogers if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) 1868e4064776SJin Yao continue; 1869e4064776SJin Yao 1870b9f01032SIan Rogers pmu->config_masks_present = true; 1871b9f01032SIan Rogers mask = &pmu->config_masks[format->value]; 1872b9f01032SIan Rogers 1873e4064776SJin Yao for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 1874b9f01032SIan Rogers *mask |= 1ULL << i; 1875e4064776SJin Yao } 1876b9f01032SIan Rogers pmu->config_masks_computed = true; 1877b9f01032SIan Rogers } 1878b9f01032SIan Rogers 1879b9f01032SIan Rogers void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 1880b9f01032SIan Rogers const char *name, int config_num, 1881b9f01032SIan Rogers const char *config_name) 1882b9f01032SIan Rogers { 1883b9f01032SIan Rogers __u64 bits; 1884b9f01032SIan Rogers char buf[100]; 1885b9f01032SIan Rogers 1886b9f01032SIan Rogers perf_pmu__compute_config_masks(pmu); 1887e4064776SJin Yao 1888e4064776SJin Yao /* 1889e4064776SJin Yao * Kernel doesn't export any valid format bits. 1890e4064776SJin Yao */ 1891b9f01032SIan Rogers if (!pmu->config_masks_present) 1892e4064776SJin Yao return; 1893e4064776SJin Yao 1894b9f01032SIan Rogers bits = config & ~pmu->config_masks[config_num]; 1895e4064776SJin Yao if (bits == 0) 1896e4064776SJin Yao return; 1897e4064776SJin Yao 1898e4064776SJin Yao bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 1899e4064776SJin Yao 1900b9f01032SIan Rogers pr_warning("WARNING: event '%s' not valid (bits %s of %s " 1901e4064776SJin Yao "'%llx' not supported by kernel)!\n", 1902b9f01032SIan Rogers name ?: "N/A", buf, config_name, config); 1903e4064776SJin Yao } 1904c5a26ea4SJin Yao 1905c47a5599SJin Yao int perf_pmu__match(char *pattern, char *name, char *tok) 1906c47a5599SJin Yao { 190713d60ba0SKan Liang if (!name) 190813d60ba0SKan Liang return -1; 190913d60ba0SKan Liang 1910c47a5599SJin Yao if (fnmatch(pattern, name, 0)) 1911c47a5599SJin Yao return -1; 1912c47a5599SJin Yao 1913240e6fd0SIan Rogers if (tok && !perf_pmu__match_ignoring_suffix(name, tok)) 1914c47a5599SJin Yao return -1; 1915c47a5599SJin Yao 1916c47a5599SJin Yao return 0; 1917c47a5599SJin Yao } 19181d3351e6SJin Yao 1919acef233bSJing Zhang double __weak perf_pmu__cpu_slots_per_cycle(void) 1920acef233bSJing Zhang { 1921acef233bSJing Zhang return NAN; 1922acef233bSJing Zhang } 1923f8ad6018SJames Clark 1924f8ad6018SJames Clark int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size) 1925f8ad6018SJames Clark { 1926f8ad6018SJames Clark const char *sysfs = sysfs__mountpoint(); 1927f8ad6018SJames Clark 1928f8ad6018SJames Clark if (!sysfs) 1929f8ad6018SJames Clark return 0; 1930f8ad6018SJames Clark return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs); 1931f8ad6018SJames Clark } 1932f8ad6018SJames Clark 1933e293a5e8SNamhyung Kim int perf_pmu__event_source_devices_fd(void) 1934e293a5e8SNamhyung Kim { 1935e293a5e8SNamhyung Kim char path[PATH_MAX]; 1936e293a5e8SNamhyung Kim const char *sysfs = sysfs__mountpoint(); 1937e293a5e8SNamhyung Kim 1938e293a5e8SNamhyung Kim if (!sysfs) 1939e293a5e8SNamhyung Kim return -1; 1940e293a5e8SNamhyung Kim 1941e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs); 1942e293a5e8SNamhyung Kim return open(path, O_DIRECTORY); 1943e293a5e8SNamhyung Kim } 1944e293a5e8SNamhyung Kim 1945f8ad6018SJames Clark /* 1946f8ad6018SJames Clark * Fill 'buf' with the path to a file or folder in 'pmu_name' in 1947f8ad6018SJames Clark * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format" 1948f8ad6018SJames Clark * then pathname will be filled with 1949f8ad6018SJames Clark * "/sys/bus/event_source/devices/cs_etm/format" 1950f8ad6018SJames Clark * 1951e1a3aad3SIan Rogers * Return 0 if the sysfs mountpoint couldn't be found, if no characters were 1952e1a3aad3SIan Rogers * written or if the buffer size is exceeded. 1953f8ad6018SJames Clark */ 1954f8ad6018SJames Clark int perf_pmu__pathname_scnprintf(char *buf, size_t size, 1955f8ad6018SJames Clark const char *pmu_name, const char *filename) 1956f8ad6018SJames Clark { 1957e1a3aad3SIan Rogers size_t len; 1958f8ad6018SJames Clark 1959e1a3aad3SIan Rogers len = perf_pmu__event_source_devices_scnprintf(buf, size); 1960e1a3aad3SIan Rogers if (!len || (len + strlen(pmu_name) + strlen(filename) + 1) >= size) 1961f8ad6018SJames Clark return 0; 1962e1a3aad3SIan Rogers 1963e1a3aad3SIan Rogers return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename); 1964f8ad6018SJames Clark } 1965eec11310SNamhyung Kim 1966e293a5e8SNamhyung Kim int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags) 1967e293a5e8SNamhyung Kim { 1968e293a5e8SNamhyung Kim char path[PATH_MAX]; 1969e293a5e8SNamhyung Kim 1970e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename); 1971e293a5e8SNamhyung Kim return openat(dirfd, path, flags); 1972e293a5e8SNamhyung Kim } 1973e293a5e8SNamhyung Kim 19741eaf496eSIan Rogers void perf_pmu__delete(struct perf_pmu *pmu) 1975eec11310SNamhyung Kim { 1976eec11310SNamhyung Kim perf_pmu__del_formats(&pmu->format); 1977eec11310SNamhyung Kim perf_pmu__del_aliases(pmu); 1978eec11310SNamhyung Kim perf_pmu__del_caps(pmu); 1979eec11310SNamhyung Kim 1980eec11310SNamhyung Kim perf_cpu_map__put(pmu->cpus); 1981eec11310SNamhyung Kim 1982efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->default_config); 1983efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 1984efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->alias_name); 1985eec11310SNamhyung Kim free(pmu); 1986eec11310SNamhyung Kim } 19879d5da30eSJames Clark 19889d5da30eSJames Clark struct perf_pmu *pmu__find_core_pmu(void) 19899d5da30eSJames Clark { 19909d5da30eSJames Clark struct perf_pmu *pmu = NULL; 19919d5da30eSJames Clark 19929d5da30eSJames Clark while ((pmu = perf_pmus__scan_core(pmu))) { 19939d5da30eSJames Clark /* 19949d5da30eSJames Clark * The cpumap should cover all CPUs. Otherwise, some CPUs may 19959d5da30eSJames Clark * not support some events or have different event IDs. 19969d5da30eSJames Clark */ 19979d5da30eSJames Clark if (RC_CHK_ACCESS(pmu->cpus)->nr != cpu__max_cpu().cpu) 19989d5da30eSJames Clark return NULL; 19999d5da30eSJames Clark 20009d5da30eSJames Clark return pmu; 20019d5da30eSJames Clark } 20029d5da30eSJames Clark return NULL; 20039d5da30eSJames Clark } 2004