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" 312879ff36SJing Zhang #include <regex.h> 32cd82a32eSJiri Olsa 33c091ee90SIan Rogers struct perf_pmu perf_pmu__fake = { 34c091ee90SIan Rogers .name = "fake", 35c091ee90SIan Rogers }; 36e46fc8d9SArnaldo Carvalho de Melo 37c3245d20SIan Rogers #define UNIT_MAX_LEN 31 /* max length for event unit name */ 38c3245d20SIan Rogers 39d9c5f5f9SIan Rogers enum event_source { 40d9c5f5f9SIan Rogers /* An event loaded from /sys/devices/<pmu>/events. */ 41d9c5f5f9SIan Rogers EVENT_SRC_SYSFS, 42d9c5f5f9SIan Rogers /* An event loaded from a CPUID matched json file. */ 43d9c5f5f9SIan Rogers EVENT_SRC_CPU_JSON, 44d9c5f5f9SIan Rogers /* 45d9c5f5f9SIan Rogers * An event loaded from a /sys/devices/<pmu>/identifier matched json 46d9c5f5f9SIan Rogers * file. 47d9c5f5f9SIan Rogers */ 48d9c5f5f9SIan Rogers EVENT_SRC_SYS_JSON, 49d9c5f5f9SIan Rogers }; 50d9c5f5f9SIan Rogers 51c3245d20SIan Rogers /** 52c3245d20SIan Rogers * struct perf_pmu_alias - An event either read from sysfs or builtin in 53c3245d20SIan Rogers * pmu-events.c, created by parsing the pmu-events json files. 54c3245d20SIan Rogers */ 55c3245d20SIan Rogers struct perf_pmu_alias { 56c3245d20SIan Rogers /** @name: Name of the event like "mem-loads". */ 57c3245d20SIan Rogers char *name; 58c3245d20SIan Rogers /** @desc: Optional short description of the event. */ 59c3245d20SIan Rogers char *desc; 60c3245d20SIan Rogers /** @long_desc: Optional long description. */ 61c3245d20SIan Rogers char *long_desc; 62c3245d20SIan Rogers /** 63c3245d20SIan Rogers * @topic: Optional topic such as cache or pipeline, particularly for 64c3245d20SIan Rogers * json events. 65c3245d20SIan Rogers */ 66c3245d20SIan Rogers char *topic; 67c3245d20SIan Rogers /** @terms: Owned list of the original parsed parameters. */ 680d3f0e6fSIan Rogers struct parse_events_terms terms; 69c3245d20SIan Rogers /** @list: List element of struct perf_pmu aliases. */ 70c3245d20SIan Rogers struct list_head list; 717b723dbbSIan Rogers /** 727b723dbbSIan Rogers * @pmu_name: The name copied from the json struct pmu_event. This can 737b723dbbSIan Rogers * differ from the PMU name as it won't have suffixes. 747b723dbbSIan Rogers */ 757b723dbbSIan Rogers char *pmu_name; 76c3245d20SIan Rogers /** @unit: Units for the event, such as bytes or cache lines. */ 77c3245d20SIan Rogers char unit[UNIT_MAX_LEN+1]; 78c3245d20SIan Rogers /** @scale: Value to scale read counter values by. */ 79c3245d20SIan Rogers double scale; 80c3245d20SIan Rogers /** 81c3245d20SIan Rogers * @per_pkg: Does the file 82c3245d20SIan Rogers * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.per-pkg or 83c3245d20SIan Rogers * equivalent json value exist and have the value 1. 84c3245d20SIan Rogers */ 85c3245d20SIan Rogers bool per_pkg; 86c3245d20SIan Rogers /** 87c3245d20SIan Rogers * @snapshot: Does the file 88c3245d20SIan Rogers * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.snapshot 89c3245d20SIan Rogers * exist and have the value 1. 90c3245d20SIan Rogers */ 91c3245d20SIan Rogers bool snapshot; 92c3245d20SIan Rogers /** 93c3245d20SIan Rogers * @deprecated: Is the event hidden and so not shown in perf list by 94c3245d20SIan Rogers * default. 95c3245d20SIan Rogers */ 96c3245d20SIan Rogers bool deprecated; 977b723dbbSIan Rogers /** @from_sysfs: Was the alias from sysfs or a json event? */ 987b723dbbSIan Rogers bool from_sysfs; 997b723dbbSIan Rogers /** @info_loaded: Have the scale, unit and other values been read from disk? */ 1007b723dbbSIan Rogers bool info_loaded; 101c3245d20SIan Rogers }; 102c3245d20SIan Rogers 103fe13d43dSIan Rogers /** 104fe13d43dSIan Rogers * struct perf_pmu_format - Values from a format file read from 105fe13d43dSIan Rogers * <sysfs>/devices/cpu/format/ held in struct perf_pmu. 106fe13d43dSIan Rogers * 107fe13d43dSIan Rogers * For example, the contents of <sysfs>/devices/cpu/format/event may be 108fe13d43dSIan Rogers * "config:0-7" and will be represented here as name="event", 109fe13d43dSIan Rogers * value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set. 110fe13d43dSIan Rogers */ 111ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 11250402641SIan Rogers /** @list: Element on list within struct perf_pmu. */ 11350402641SIan Rogers struct list_head list; 11450402641SIan Rogers /** @bits: Which config bits are set by this format value. */ 11550402641SIan Rogers DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 116fe13d43dSIan Rogers /** @name: The modifier/file name. */ 117ab1bf653SArnaldo Carvalho de Melo char *name; 118fe13d43dSIan Rogers /** 119fe13d43dSIan Rogers * @value : Which config value the format relates to. Supported values 120fe13d43dSIan Rogers * are from PERF_PMU_FORMAT_VALUE_CONFIG to 121fe13d43dSIan Rogers * PERF_PMU_FORMAT_VALUE_CONFIG_END. 122fe13d43dSIan Rogers */ 12350402641SIan Rogers u16 value; 12450402641SIan Rogers /** @loaded: Has the contents been loaded/parsed. */ 12550402641SIan Rogers bool loaded; 126ab1bf653SArnaldo Carvalho de Melo }; 127ab1bf653SArnaldo Carvalho de Melo 1288d4b6d37SIan Rogers static int pmu_aliases_parse(struct perf_pmu *pmu); 1298d4b6d37SIan Rogers 13050402641SIan Rogers static struct perf_pmu_format *perf_pmu__new_format(struct list_head *list, char *name) 13150402641SIan Rogers { 13250402641SIan Rogers struct perf_pmu_format *format; 13350402641SIan Rogers 13450402641SIan Rogers format = zalloc(sizeof(*format)); 13550402641SIan Rogers if (!format) 13650402641SIan Rogers return NULL; 13750402641SIan Rogers 13850402641SIan Rogers format->name = strdup(name); 13950402641SIan Rogers if (!format->name) { 14050402641SIan Rogers free(format); 14150402641SIan Rogers return NULL; 14250402641SIan Rogers } 14350402641SIan Rogers list_add_tail(&format->list, list); 14450402641SIan Rogers return format; 14550402641SIan Rogers } 14650402641SIan Rogers 14750402641SIan Rogers /* Called at the end of parsing a format. */ 14850402641SIan Rogers void perf_pmu_format__set_value(void *vformat, int config, unsigned long *bits) 14950402641SIan Rogers { 15050402641SIan Rogers struct perf_pmu_format *format = vformat; 15150402641SIan Rogers 15250402641SIan Rogers format->value = config; 15350402641SIan Rogers memcpy(format->bits, bits, sizeof(format->bits)); 15450402641SIan Rogers } 15550402641SIan Rogers 15650402641SIan Rogers static void __perf_pmu_format__load(struct perf_pmu_format *format, FILE *file) 15750402641SIan Rogers { 15850402641SIan Rogers void *scanner; 15950402641SIan Rogers int ret; 16050402641SIan Rogers 16150402641SIan Rogers ret = perf_pmu_lex_init(&scanner); 16250402641SIan Rogers if (ret) 16350402641SIan Rogers return; 16450402641SIan Rogers 16550402641SIan Rogers perf_pmu_set_in(file, scanner); 16650402641SIan Rogers ret = perf_pmu_parse(format, scanner); 16750402641SIan Rogers perf_pmu_lex_destroy(scanner); 16850402641SIan Rogers format->loaded = true; 16950402641SIan Rogers } 17050402641SIan Rogers 17163883cb0SIan Rogers static void perf_pmu_format__load(const struct perf_pmu *pmu, struct perf_pmu_format *format) 17250402641SIan Rogers { 17350402641SIan Rogers char path[PATH_MAX]; 17450402641SIan Rogers FILE *file = NULL; 17550402641SIan Rogers 17650402641SIan Rogers if (format->loaded) 17750402641SIan Rogers return; 17850402641SIan Rogers 17950402641SIan Rogers if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, "format")) 18050402641SIan Rogers return; 18150402641SIan Rogers 18250402641SIan Rogers assert(strlen(path) + strlen(format->name) + 2 < sizeof(path)); 18350402641SIan Rogers strcat(path, "/"); 18450402641SIan Rogers strcat(path, format->name); 18550402641SIan Rogers 18650402641SIan Rogers file = fopen(path, "r"); 18750402641SIan Rogers if (!file) 18850402641SIan Rogers return; 18950402641SIan Rogers __perf_pmu_format__load(format, file); 19050402641SIan Rogers fclose(file); 19150402641SIan Rogers } 19250402641SIan Rogers 193cd82a32eSJiri Olsa /* 194cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 195cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 196cd82a32eSJiri Olsa */ 197aa1551f2SIan Rogers static int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load) 198cd82a32eSJiri Olsa { 199cd82a32eSJiri Olsa struct dirent *evt_ent; 200cd82a32eSJiri Olsa DIR *format_dir; 201cd82a32eSJiri Olsa int ret = 0; 202cd82a32eSJiri Olsa 203e293a5e8SNamhyung Kim format_dir = fdopendir(dirfd); 204cd82a32eSJiri Olsa if (!format_dir) 205cd82a32eSJiri Olsa return -EINVAL; 206cd82a32eSJiri Olsa 20750402641SIan Rogers while ((evt_ent = readdir(format_dir)) != NULL) { 20850402641SIan Rogers struct perf_pmu_format *format; 209cd82a32eSJiri Olsa char *name = evt_ent->d_name; 210cd82a32eSJiri Olsa 211cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 212cd82a32eSJiri Olsa continue; 213cd82a32eSJiri Olsa 21450402641SIan Rogers format = perf_pmu__new_format(&pmu->format, name); 21550402641SIan Rogers if (!format) { 21650402641SIan Rogers ret = -ENOMEM; 217cd82a32eSJiri Olsa break; 21850402641SIan Rogers } 219cd82a32eSJiri Olsa 22050402641SIan Rogers if (eager_load) { 22150402641SIan Rogers FILE *file; 22250402641SIan Rogers int fd = openat(dirfd, name, O_RDONLY); 22350402641SIan Rogers 22450402641SIan Rogers if (fd < 0) { 22550402641SIan Rogers ret = -errno; 22650402641SIan Rogers break; 22750402641SIan Rogers } 2283d88aec0SIan Rogers file = fdopen(fd, "r"); 2293d88aec0SIan Rogers if (!file) { 2303d88aec0SIan Rogers close(fd); 2313d88aec0SIan Rogers break; 2323d88aec0SIan Rogers } 23350402641SIan Rogers __perf_pmu_format__load(format, file); 2343d88aec0SIan Rogers fclose(file); 2353d88aec0SIan Rogers } 236cd82a32eSJiri Olsa } 237cd82a32eSJiri Olsa 238cd82a32eSJiri Olsa closedir(format_dir); 239cd82a32eSJiri Olsa return ret; 240cd82a32eSJiri Olsa } 241cd82a32eSJiri Olsa 242cd82a32eSJiri Olsa /* 243cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 244cd82a32eSJiri Olsa * located at: 245cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 246cd82a32eSJiri Olsa */ 247aa1551f2SIan Rogers static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name, bool eager_load) 248cd82a32eSJiri Olsa { 249e293a5e8SNamhyung Kim int fd; 250cd82a32eSJiri Olsa 251e293a5e8SNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "format", O_DIRECTORY); 252e293a5e8SNamhyung Kim if (fd < 0) 253d9664582SAndi Kleen return 0; 254cd82a32eSJiri Olsa 255e293a5e8SNamhyung Kim /* it'll close the fd */ 256aa1551f2SIan Rogers if (perf_pmu__format_parse(pmu, fd, eager_load)) 257cd82a32eSJiri Olsa return -1; 258cd82a32eSJiri Olsa 259cd82a32eSJiri Olsa return 0; 260cd82a32eSJiri Olsa } 261cd82a32eSJiri Olsa 262a55ab7c4SJin Yao int perf_pmu__convert_scale(const char *scale, char **end, double *sval) 263d02fc6bcSAndi Kleen { 264d02fc6bcSAndi Kleen char *lc; 265d02fc6bcSAndi Kleen int ret = 0; 266d02fc6bcSAndi Kleen 267d02fc6bcSAndi Kleen /* 268d02fc6bcSAndi Kleen * save current locale 269d02fc6bcSAndi Kleen */ 270d02fc6bcSAndi Kleen lc = setlocale(LC_NUMERIC, NULL); 271d02fc6bcSAndi Kleen 272d02fc6bcSAndi Kleen /* 273d02fc6bcSAndi Kleen * The lc string may be allocated in static storage, 274d02fc6bcSAndi Kleen * so get a dynamic copy to make it survive setlocale 275d02fc6bcSAndi Kleen * call below. 276d02fc6bcSAndi Kleen */ 277d02fc6bcSAndi Kleen lc = strdup(lc); 278d02fc6bcSAndi Kleen if (!lc) { 279d02fc6bcSAndi Kleen ret = -ENOMEM; 280d02fc6bcSAndi Kleen goto out; 281d02fc6bcSAndi Kleen } 282d02fc6bcSAndi Kleen 283d02fc6bcSAndi Kleen /* 284d02fc6bcSAndi Kleen * force to C locale to ensure kernel 285d02fc6bcSAndi Kleen * scale string is converted correctly. 286d02fc6bcSAndi Kleen * kernel uses default C locale. 287d02fc6bcSAndi Kleen */ 288d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, "C"); 289d02fc6bcSAndi Kleen 290d02fc6bcSAndi Kleen *sval = strtod(scale, end); 291d02fc6bcSAndi Kleen 292d02fc6bcSAndi Kleen out: 293d02fc6bcSAndi Kleen /* restore locale */ 294d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, lc); 295d02fc6bcSAndi Kleen free(lc); 296d02fc6bcSAndi Kleen return ret; 297d02fc6bcSAndi Kleen } 298d02fc6bcSAndi Kleen 2997b723dbbSIan Rogers static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 300410136f5SStephane Eranian { 301410136f5SStephane Eranian struct stat st; 302410136f5SStephane Eranian ssize_t sret; 3037b723dbbSIan Rogers size_t len; 304410136f5SStephane Eranian char scale[128]; 305410136f5SStephane Eranian int fd, ret = -1; 306410136f5SStephane Eranian char path[PATH_MAX]; 307410136f5SStephane Eranian 3087b723dbbSIan Rogers len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 3097b723dbbSIan Rogers if (!len) 3107b723dbbSIan Rogers return 0; 31148a3adcfSWyes Karny scnprintf(path + len, sizeof(path) - len, "%s/events/%s.scale", pmu->name, alias->name); 312410136f5SStephane Eranian 3137b723dbbSIan Rogers fd = open(path, O_RDONLY); 314410136f5SStephane Eranian if (fd == -1) 315410136f5SStephane Eranian return -1; 316410136f5SStephane Eranian 317410136f5SStephane Eranian if (fstat(fd, &st) < 0) 318410136f5SStephane Eranian goto error; 319410136f5SStephane Eranian 320410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 321410136f5SStephane Eranian if (sret < 0) 322410136f5SStephane Eranian goto error; 323410136f5SStephane Eranian 3249ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 3259ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 3269ecae065SMadhavan Srinivasan else 327410136f5SStephane Eranian scale[sret] = '\0'; 3289ecae065SMadhavan Srinivasan 329a55ab7c4SJin Yao ret = perf_pmu__convert_scale(scale, NULL, &alias->scale); 330410136f5SStephane Eranian error: 331410136f5SStephane Eranian close(fd); 332410136f5SStephane Eranian return ret; 333410136f5SStephane Eranian } 334410136f5SStephane Eranian 3357b723dbbSIan Rogers static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 336410136f5SStephane Eranian { 337410136f5SStephane Eranian char path[PATH_MAX]; 3387b723dbbSIan Rogers size_t len; 339410136f5SStephane Eranian ssize_t sret; 340410136f5SStephane Eranian int fd; 341410136f5SStephane Eranian 342410136f5SStephane Eranian 3437b723dbbSIan Rogers len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 3447b723dbbSIan Rogers if (!len) 3457b723dbbSIan Rogers return 0; 34648a3adcfSWyes Karny scnprintf(path + len, sizeof(path) - len, "%s/events/%s.unit", pmu->name, alias->name); 3477b723dbbSIan Rogers 3487b723dbbSIan Rogers fd = open(path, O_RDONLY); 349410136f5SStephane Eranian if (fd == -1) 350410136f5SStephane Eranian return -1; 351410136f5SStephane Eranian 352410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 353410136f5SStephane Eranian if (sret < 0) 354410136f5SStephane Eranian goto error; 355410136f5SStephane Eranian 356410136f5SStephane Eranian close(fd); 357410136f5SStephane Eranian 3589ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 3599ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 3609ecae065SMadhavan Srinivasan else 361410136f5SStephane Eranian alias->unit[sret] = '\0'; 362410136f5SStephane Eranian 363410136f5SStephane Eranian return 0; 364410136f5SStephane Eranian error: 365410136f5SStephane Eranian close(fd); 366410136f5SStephane Eranian alias->unit[0] = '\0'; 367410136f5SStephane Eranian return -1; 368410136f5SStephane Eranian } 369410136f5SStephane Eranian 370044330c1SMatt Fleming static int 3717b723dbbSIan Rogers perf_pmu__parse_per_pkg(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 372044330c1SMatt Fleming { 373044330c1SMatt Fleming char path[PATH_MAX]; 3747b723dbbSIan Rogers size_t len; 375044330c1SMatt Fleming int fd; 376044330c1SMatt Fleming 3777b723dbbSIan Rogers len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 3787b723dbbSIan Rogers if (!len) 3797b723dbbSIan Rogers return 0; 38048a3adcfSWyes Karny scnprintf(path + len, sizeof(path) - len, "%s/events/%s.per-pkg", pmu->name, alias->name); 381044330c1SMatt Fleming 3827b723dbbSIan Rogers fd = open(path, O_RDONLY); 383044330c1SMatt Fleming if (fd == -1) 384044330c1SMatt Fleming return -1; 385044330c1SMatt Fleming 386044330c1SMatt Fleming close(fd); 387044330c1SMatt Fleming 388044330c1SMatt Fleming alias->per_pkg = true; 389044330c1SMatt Fleming return 0; 390044330c1SMatt Fleming } 391044330c1SMatt Fleming 3927b723dbbSIan Rogers static int perf_pmu__parse_snapshot(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 3931d9e446bSJiri Olsa { 3941d9e446bSJiri Olsa char path[PATH_MAX]; 3957b723dbbSIan Rogers size_t len; 3961d9e446bSJiri Olsa int fd; 3971d9e446bSJiri Olsa 3987b723dbbSIan Rogers len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 3997b723dbbSIan Rogers if (!len) 4007b723dbbSIan Rogers return 0; 40148a3adcfSWyes Karny scnprintf(path + len, sizeof(path) - len, "%s/events/%s.snapshot", pmu->name, alias->name); 4021d9e446bSJiri Olsa 4037b723dbbSIan Rogers fd = open(path, O_RDONLY); 4041d9e446bSJiri Olsa if (fd == -1) 4051d9e446bSJiri Olsa return -1; 4061d9e446bSJiri Olsa 4071d9e446bSJiri Olsa alias->snapshot = true; 4081d9e446bSJiri Olsa close(fd); 4091d9e446bSJiri Olsa return 0; 4101d9e446bSJiri Olsa } 4111d9e446bSJiri Olsa 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); 41932705de7SJin Yao zfree(&newalias->pmu_name); 4200d3f0e6fSIan Rogers parse_events_terms__exit(&newalias->terms); 4216dde6429SThomas Richter free(newalias); 4226dde6429SThomas Richter } 4236dde6429SThomas Richter 424eec11310SNamhyung Kim static void perf_pmu__del_aliases(struct perf_pmu *pmu) 425eec11310SNamhyung Kim { 426eec11310SNamhyung Kim struct perf_pmu_alias *alias, *tmp; 427eec11310SNamhyung Kim 428eec11310SNamhyung Kim list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) { 429eec11310SNamhyung Kim list_del(&alias->list); 430eec11310SNamhyung Kim perf_pmu_free_alias(alias); 431eec11310SNamhyung Kim } 432eec11310SNamhyung Kim } 433eec11310SNamhyung Kim 4348d4b6d37SIan Rogers static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu, 4358d4b6d37SIan Rogers const char *name, 4368d4b6d37SIan Rogers bool load) 4376dde6429SThomas Richter { 438f63a536fSIan Rogers struct perf_pmu_alias *alias; 4396dde6429SThomas Richter 4407b6dd7a9SIan Rogers if (load && !pmu->sysfs_aliases_loaded) { 4417b6dd7a9SIan Rogers bool has_sysfs_event; 4427b6dd7a9SIan Rogers char event_file_name[FILENAME_MAX + 8]; 4437b6dd7a9SIan Rogers 4447b6dd7a9SIan Rogers /* 4457b6dd7a9SIan Rogers * Test if alias/event 'name' exists in the PMU's sysfs/events 4467b6dd7a9SIan Rogers * directory. If not skip parsing the sysfs aliases. Sysfs event 4477b6dd7a9SIan Rogers * name must be all lower or all upper case. 4487b6dd7a9SIan Rogers */ 4497b6dd7a9SIan Rogers scnprintf(event_file_name, sizeof(event_file_name), "events/%s", name); 4507b6dd7a9SIan Rogers for (size_t i = 7, n = 7 + strlen(name); i < n; i++) 4517b6dd7a9SIan Rogers event_file_name[i] = tolower(event_file_name[i]); 4527b6dd7a9SIan Rogers 4537b6dd7a9SIan Rogers has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name); 4547b6dd7a9SIan Rogers if (!has_sysfs_event) { 4557b6dd7a9SIan Rogers for (size_t i = 7, n = 7 + strlen(name); i < n; i++) 4567b6dd7a9SIan Rogers event_file_name[i] = toupper(event_file_name[i]); 4577b6dd7a9SIan Rogers 4587b6dd7a9SIan Rogers has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name); 4597b6dd7a9SIan Rogers } 4607b6dd7a9SIan Rogers if (has_sysfs_event) 4618d4b6d37SIan Rogers pmu_aliases_parse(pmu); 4628d4b6d37SIan Rogers 4637b6dd7a9SIan Rogers } 464f63a536fSIan Rogers list_for_each_entry(alias, &pmu->aliases, list) { 465f63a536fSIan Rogers if (!strcasecmp(alias->name, name)) 466f63a536fSIan Rogers return alias; 46732705de7SJin Yao } 468f63a536fSIan Rogers return NULL; 469f63a536fSIan Rogers } 470f63a536fSIan Rogers 471f63a536fSIan Rogers static bool assign_str(const char *name, const char *field, char **old_str, 472f63a536fSIan Rogers const char *new_str) 473f63a536fSIan Rogers { 474f63a536fSIan Rogers if (!*old_str && new_str) { 475f63a536fSIan Rogers *old_str = strdup(new_str); 4766dde6429SThomas Richter return true; 4776dde6429SThomas Richter } 478f63a536fSIan Rogers 479f63a536fSIan Rogers if (!new_str || !strcasecmp(*old_str, new_str)) 480f63a536fSIan Rogers return false; /* Nothing to update. */ 481f63a536fSIan Rogers 482f63a536fSIan Rogers pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n", 483f63a536fSIan Rogers name, field, *old_str, new_str); 484f63a536fSIan Rogers zfree(old_str); 485f63a536fSIan Rogers *old_str = strdup(new_str); 486f63a536fSIan Rogers return true; 4876dde6429SThomas Richter } 488f63a536fSIan Rogers 4897b723dbbSIan Rogers static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 4907b723dbbSIan Rogers { 4917b723dbbSIan Rogers if (!alias->from_sysfs || alias->info_loaded) 4927b723dbbSIan Rogers return; 4937b723dbbSIan Rogers 4947b723dbbSIan Rogers /* 4957b723dbbSIan Rogers * load unit name and scale if available 4967b723dbbSIan Rogers */ 4977b723dbbSIan Rogers perf_pmu__parse_unit(pmu, alias); 4987b723dbbSIan Rogers perf_pmu__parse_scale(pmu, alias); 4997b723dbbSIan Rogers perf_pmu__parse_per_pkg(pmu, alias); 5007b723dbbSIan Rogers perf_pmu__parse_snapshot(pmu, alias); 5017b723dbbSIan Rogers } 5027b723dbbSIan Rogers 5037b723dbbSIan Rogers struct update_alias_data { 5047b723dbbSIan Rogers struct perf_pmu *pmu; 5057b723dbbSIan Rogers struct perf_pmu_alias *alias; 5067b723dbbSIan Rogers }; 5077b723dbbSIan Rogers 508f63a536fSIan Rogers static int update_alias(const struct pmu_event *pe, 509f63a536fSIan Rogers const struct pmu_events_table *table __maybe_unused, 510f63a536fSIan Rogers void *vdata) 511f63a536fSIan Rogers { 5127b723dbbSIan Rogers struct update_alias_data *data = vdata; 513f63a536fSIan Rogers int ret = 0; 514f63a536fSIan Rogers 5157b723dbbSIan Rogers read_alias_info(data->pmu, data->alias); 5167b723dbbSIan Rogers assign_str(pe->name, "desc", &data->alias->desc, pe->desc); 5177b723dbbSIan Rogers assign_str(pe->name, "long_desc", &data->alias->long_desc, pe->long_desc); 5187b723dbbSIan Rogers assign_str(pe->name, "topic", &data->alias->topic, pe->topic); 5197b723dbbSIan Rogers data->alias->per_pkg = pe->perpkg; 52030f0b435SIan Rogers if (pe->event) { 5210d3f0e6fSIan Rogers parse_events_terms__exit(&data->alias->terms); 5227b723dbbSIan Rogers ret = parse_events_terms(&data->alias->terms, pe->event, /*input=*/NULL); 523f63a536fSIan Rogers } 524f63a536fSIan Rogers if (!ret && pe->unit) { 525f63a536fSIan Rogers char *unit; 526f63a536fSIan Rogers 5277b723dbbSIan Rogers ret = perf_pmu__convert_scale(pe->unit, &unit, &data->alias->scale); 528f63a536fSIan Rogers if (!ret) 5297b723dbbSIan Rogers snprintf(data->alias->unit, sizeof(data->alias->unit), "%s", unit); 530f63a536fSIan Rogers } 531f63a536fSIan Rogers return ret; 5326dde6429SThomas Richter } 5336dde6429SThomas Richter 5347b723dbbSIan Rogers static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, 535edb217ffSIan Rogers const char *desc, const char *val, FILE *val_fd, 536d9c5f5f9SIan Rogers const struct pmu_event *pe, enum event_source src) 537a6146d50SZheng Yan { 5385c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 539a6146d50SZheng Yan int ret; 540330f40a0SIan Rogers const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL; 541bd680861SIan Rogers bool deprecated = false, perpkg = false; 542eab35953SJin Yao 5438d4b6d37SIan Rogers if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) { 544f63a536fSIan Rogers /* Alias was already created/loaded. */ 545f63a536fSIan Rogers return 0; 546f63a536fSIan Rogers } 547f63a536fSIan Rogers 548eab35953SJin Yao if (pe) { 549330f40a0SIan Rogers long_desc = pe->long_desc; 550330f40a0SIan Rogers topic = pe->topic; 551330f40a0SIan Rogers unit = pe->unit; 552bd680861SIan Rogers perpkg = pe->perpkg; 5539ed8b7dcSIan Rogers deprecated = pe->deprecated; 55439aa4ff6SIan Rogers if (pe->pmu && strcmp(pe->pmu, "default_core")) 555330f40a0SIan Rogers pmu_name = pe->pmu; 556eab35953SJin Yao } 557a6146d50SZheng Yan 558eaaebb01SIan Rogers alias = zalloc(sizeof(*alias)); 559a6146d50SZheng Yan if (!alias) 560a6146d50SZheng Yan return -ENOMEM; 561a6146d50SZheng Yan 5620d3f0e6fSIan Rogers parse_events_terms__init(&alias->terms); 563410136f5SStephane Eranian alias->scale = 1.0; 564410136f5SStephane Eranian alias->unit[0] = '\0'; 565bd680861SIan Rogers alias->per_pkg = perpkg; 56684530920SStephane Eranian alias->snapshot = false; 5679ed8b7dcSIan Rogers alias->deprecated = deprecated; 568410136f5SStephane Eranian 569edb217ffSIan Rogers ret = parse_events_terms(&alias->terms, val, val_fd); 570a6146d50SZheng Yan if (ret) { 57170c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 572a6146d50SZheng Yan free(alias); 573a6146d50SZheng Yan return ret; 574a6146d50SZheng Yan } 575a6146d50SZheng Yan 576a6146d50SZheng Yan alias->name = strdup(name); 57708e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 578c8d6828aSSukadev Bhattiprolu alias->long_desc = long_desc ? strdup(long_desc) : 579c8d6828aSSukadev Bhattiprolu desc ? strdup(desc) : NULL; 580dd5f1036SAndi Kleen alias->topic = topic ? strdup(topic) : NULL; 581f63a536fSIan Rogers alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; 582fedb2b51SAndi Kleen if (unit) { 583f63a536fSIan Rogers if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) { 584f63a536fSIan Rogers perf_pmu_free_alias(alias); 585fedb2b51SAndi Kleen return -1; 586f63a536fSIan Rogers } 587fedb2b51SAndi Kleen snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 588fedb2b51SAndi Kleen } 589d9c5f5f9SIan Rogers switch (src) { 590d9c5f5f9SIan Rogers default: 591d9c5f5f9SIan Rogers case EVENT_SRC_SYSFS: 592d9c5f5f9SIan Rogers alias->from_sysfs = true; 593d9c5f5f9SIan Rogers if (pmu->events_table) { 594f63a536fSIan Rogers /* Update an event from sysfs with json data. */ 5957b723dbbSIan Rogers struct update_alias_data data = { 5967b723dbbSIan Rogers .pmu = pmu, 5977b723dbbSIan Rogers .alias = alias, 5987b723dbbSIan Rogers }; 599e6ff1eedSIan Rogers if (pmu_events_table__find_event(pmu->events_table, pmu, name, 6007b723dbbSIan Rogers update_alias, &data) == 0) 601d9c5f5f9SIan Rogers pmu->cpu_json_aliases++; 6027c52f10cSIan Rogers } 603e6ff1eedSIan Rogers pmu->sysfs_aliases++; 604d9c5f5f9SIan Rogers break; 605d9c5f5f9SIan Rogers case EVENT_SRC_CPU_JSON: 606d9c5f5f9SIan Rogers pmu->cpu_json_aliases++; 607d9c5f5f9SIan Rogers break; 608d9c5f5f9SIan Rogers case EVENT_SRC_SYS_JSON: 609d9c5f5f9SIan Rogers pmu->sys_json_aliases++; 610d9c5f5f9SIan Rogers break; 611d9c5f5f9SIan Rogers 612d9c5f5f9SIan Rogers } 613f26d22f1SIan Rogers list_add_tail(&alias->list, &pmu->aliases); 614a6146d50SZheng Yan return 0; 615a6146d50SZheng Yan } 616a6146d50SZheng Yan 6173a42f4c7SIan Rogers static inline bool pmu_alias_info_file(const char *name) 61846441bdcSMatt Fleming { 61946441bdcSMatt Fleming size_t len; 62046441bdcSMatt Fleming 62146441bdcSMatt Fleming len = strlen(name); 62246441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 62346441bdcSMatt Fleming return true; 62446441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 62546441bdcSMatt Fleming return true; 626044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 627044330c1SMatt Fleming return true; 6281d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 6291d9e446bSJiri Olsa return true; 63046441bdcSMatt Fleming 63146441bdcSMatt Fleming return false; 63246441bdcSMatt Fleming } 63346441bdcSMatt Fleming 634a6146d50SZheng Yan /* 6358d4b6d37SIan Rogers * Reading the pmu event aliases definition, which should be located at: 6368d4b6d37SIan Rogers * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 637a6146d50SZheng Yan */ 63818eb2ca8SIan Rogers static int __pmu_aliases_parse(struct perf_pmu *pmu, int events_dir_fd) 639a6146d50SZheng Yan { 640a6146d50SZheng Yan struct dirent *evt_ent; 641a6146d50SZheng Yan DIR *event_dir; 642a6146d50SZheng Yan 64318eb2ca8SIan Rogers event_dir = fdopendir(events_dir_fd); 64418eb2ca8SIan Rogers if (!event_dir) 645a6146d50SZheng Yan return -EINVAL; 646a6146d50SZheng Yan 647940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 648a6146d50SZheng Yan char *name = evt_ent->d_name; 64918eb2ca8SIan Rogers int fd; 650a6146d50SZheng Yan FILE *file; 651a6146d50SZheng Yan 652a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 653a6146d50SZheng Yan continue; 654a6146d50SZheng Yan 655410136f5SStephane Eranian /* 65646441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 657410136f5SStephane Eranian */ 65846441bdcSMatt Fleming if (pmu_alias_info_file(name)) 659410136f5SStephane Eranian continue; 660410136f5SStephane Eranian 66118eb2ca8SIan Rogers fd = openat(events_dir_fd, name, O_RDONLY); 6620ea8920eSIan Rogers if (fd == -1) { 6630ea8920eSIan Rogers pr_debug("Cannot open %s\n", name); 6640ea8920eSIan Rogers continue; 6650ea8920eSIan Rogers } 666e293a5e8SNamhyung Kim file = fdopen(fd, "r"); 667940db6dcSAndi Kleen if (!file) { 6680ea8920eSIan Rogers close(fd); 669940db6dcSAndi Kleen continue; 670940db6dcSAndi Kleen } 671410136f5SStephane Eranian 6727b723dbbSIan Rogers if (perf_pmu__new_alias(pmu, name, /*desc=*/ NULL, 673d9c5f5f9SIan Rogers /*val=*/ NULL, file, /*pe=*/ NULL, 674d9c5f5f9SIan Rogers EVENT_SRC_SYSFS) < 0) 675940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 676a6146d50SZheng Yan fclose(file); 677a6146d50SZheng Yan } 678a6146d50SZheng Yan 679a6146d50SZheng Yan closedir(event_dir); 6808d4b6d37SIan Rogers pmu->sysfs_aliases_loaded = true; 681a6146d50SZheng Yan return 0; 682a6146d50SZheng Yan } 683a6146d50SZheng Yan 68418eb2ca8SIan Rogers static int pmu_aliases_parse(struct perf_pmu *pmu) 68518eb2ca8SIan Rogers { 68618eb2ca8SIan Rogers char path[PATH_MAX]; 68718eb2ca8SIan Rogers size_t len; 68818eb2ca8SIan Rogers int events_dir_fd, ret; 68918eb2ca8SIan Rogers 69018eb2ca8SIan Rogers if (pmu->sysfs_aliases_loaded) 69118eb2ca8SIan Rogers return 0; 69218eb2ca8SIan Rogers 69318eb2ca8SIan Rogers len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 69418eb2ca8SIan Rogers if (!len) 69518eb2ca8SIan Rogers return 0; 69618eb2ca8SIan Rogers scnprintf(path + len, sizeof(path) - len, "%s/events", pmu->name); 69718eb2ca8SIan Rogers 69818eb2ca8SIan Rogers events_dir_fd = open(path, O_DIRECTORY); 69918eb2ca8SIan Rogers if (events_dir_fd == -1) { 70018eb2ca8SIan Rogers pmu->sysfs_aliases_loaded = true; 70118eb2ca8SIan Rogers return 0; 70218eb2ca8SIan Rogers } 70318eb2ca8SIan Rogers ret = __pmu_aliases_parse(pmu, events_dir_fd); 70418eb2ca8SIan Rogers close(events_dir_fd); 70518eb2ca8SIan Rogers return ret; 70618eb2ca8SIan Rogers } 70718eb2ca8SIan Rogers 70818eb2ca8SIan Rogers static int pmu_aliases_parse_eager(struct perf_pmu *pmu, int sysfs_fd) 70918eb2ca8SIan Rogers { 71018eb2ca8SIan Rogers char path[FILENAME_MAX + 7]; 71118eb2ca8SIan Rogers int ret, events_dir_fd; 71218eb2ca8SIan Rogers 71318eb2ca8SIan Rogers scnprintf(path, sizeof(path), "%s/events", pmu->name); 71418eb2ca8SIan Rogers events_dir_fd = openat(sysfs_fd, path, O_DIRECTORY, 0); 71518eb2ca8SIan Rogers if (events_dir_fd == -1) { 71618eb2ca8SIan Rogers pmu->sysfs_aliases_loaded = true; 71718eb2ca8SIan Rogers return 0; 71818eb2ca8SIan Rogers } 71918eb2ca8SIan Rogers ret = __pmu_aliases_parse(pmu, events_dir_fd); 72018eb2ca8SIan Rogers close(events_dir_fd); 72118eb2ca8SIan Rogers return ret; 72218eb2ca8SIan Rogers } 72318eb2ca8SIan Rogers 724f5144ecaSIan Rogers static int pmu_alias_terms(struct perf_pmu_alias *alias, int err_loc, struct list_head *terms) 725a6146d50SZheng Yan { 7267c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 7270d3f0e6fSIan Rogers struct parse_events_terms clone_terms; 728a6146d50SZheng Yan 7290d3f0e6fSIan Rogers parse_events_terms__init(&clone_terms); 7300d3f0e6fSIan Rogers list_for_each_entry(term, &alias->terms.terms, list) { 7310d3f0e6fSIan Rogers int ret = parse_events_term__clone(&cloned, term); 7320d3f0e6fSIan Rogers 733a6146d50SZheng Yan if (ret) { 7340d3f0e6fSIan Rogers parse_events_terms__exit(&clone_terms); 735a6146d50SZheng Yan return ret; 736a6146d50SZheng Yan } 737c2f1ceadSAndi Kleen /* 738c2f1ceadSAndi Kleen * Weak terms don't override command line options, 739c2f1ceadSAndi Kleen * which we don't want for implicit terms in aliases. 740c2f1ceadSAndi Kleen */ 741c2f1ceadSAndi Kleen cloned->weak = true; 742f5144ecaSIan Rogers cloned->err_term = cloned->err_val = err_loc; 7430d3f0e6fSIan Rogers list_add_tail(&cloned->list, &clone_terms.terms); 744a6146d50SZheng Yan } 7450d3f0e6fSIan Rogers list_splice_init(&clone_terms.terms, terms); 7460d3f0e6fSIan Rogers parse_events_terms__exit(&clone_terms); 747a6146d50SZheng Yan return 0; 748a6146d50SZheng Yan } 749a6146d50SZheng Yan 75066ec1191SMark Rutland /* 75166ec1191SMark Rutland * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 75266ec1191SMark Rutland * may have a "cpus" file. 75366ec1191SMark Rutland */ 754d06593aaSIan Rogers static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core) 7557ae92e74SYan, Zheng { 756f854839bSJiri Olsa struct perf_cpu_map *cpus; 7577e3fcffeSMark Rutland const char *templates[] = { 758d50a79cdSJames Clark "cpumask", 759d50a79cdSJames Clark "cpus", 7607e3fcffeSMark Rutland NULL 7617e3fcffeSMark Rutland }; 7627e3fcffeSMark Rutland const char **template; 763d50a79cdSJames Clark char pmu_name[PATH_MAX]; 764d50a79cdSJames Clark struct perf_pmu pmu = {.name = pmu_name}; 765d50a79cdSJames Clark FILE *file; 7667ae92e74SYan, Zheng 767d50a79cdSJames Clark strlcpy(pmu_name, name, sizeof(pmu_name)); 7687e3fcffeSMark Rutland for (template = templates; *template; template++) { 7693a69672eSNamhyung Kim file = perf_pmu__open_file_at(&pmu, dirfd, *template); 770d50a79cdSJames Clark if (!file) 771d50a79cdSJames Clark continue; 772d50a79cdSJames Clark cpus = perf_cpu_map__read(file); 7733a69672eSNamhyung Kim fclose(file); 77466ec1191SMark Rutland if (cpus) 77566ec1191SMark Rutland return cpus; 7767e3fcffeSMark Rutland } 7777ae92e74SYan, Zheng 778d06593aaSIan Rogers /* Nothing found, for core PMUs assume this means all CPUs. */ 779d06593aaSIan Rogers return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL; 78066ec1191SMark Rutland } 7817ae92e74SYan, Zheng 7823a69672eSNamhyung Kim static bool pmu_is_uncore(int dirfd, const char *name) 78366ec1191SMark Rutland { 7843a69672eSNamhyung Kim int fd; 7857ae92e74SYan, Zheng 7863a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH); 7873a69672eSNamhyung Kim if (fd < 0) 7883a69672eSNamhyung Kim return false; 7893a69672eSNamhyung Kim 7903a69672eSNamhyung Kim close(fd); 7913a69672eSNamhyung Kim return true; 7927ae92e74SYan, Zheng } 7937ae92e74SYan, Zheng 79451d54847SJohn Garry static char *pmu_id(const char *name) 79551d54847SJohn Garry { 79651d54847SJohn Garry char path[PATH_MAX], *str; 79751d54847SJohn Garry size_t len; 79851d54847SJohn Garry 7995f2c8efaSJames Clark perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier"); 80051d54847SJohn Garry 8015f2c8efaSJames Clark if (filename__read_str(path, &str, &len) < 0) 80251d54847SJohn Garry return NULL; 80351d54847SJohn Garry 80451d54847SJohn Garry str[len - 1] = 0; /* remove line feed */ 80551d54847SJohn Garry 80651d54847SJohn Garry return str; 80751d54847SJohn Garry } 80851d54847SJohn Garry 8094bf7e81aSIan Rogers /** 8104bf7e81aSIan Rogers * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in 8114bf7e81aSIan Rogers * sysfs on some platforms like ARM or Intel hybrid. Looking for 8124bf7e81aSIan Rogers * possible the cpus file in sysfs files to identify whether this is a 8134bf7e81aSIan Rogers * core device. 8144bf7e81aSIan Rogers * @name: The PMU name such as "cpu_atom". 81514b22ae0SGanapatrao Kulkarni */ 8164bf7e81aSIan Rogers static int is_sysfs_pmu_core(const char *name) 81714b22ae0SGanapatrao Kulkarni { 81814b22ae0SGanapatrao Kulkarni char path[PATH_MAX]; 81914b22ae0SGanapatrao Kulkarni 820f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus")) 82114b22ae0SGanapatrao Kulkarni return 0; 822d9664582SAndi Kleen return file_available(path); 82314b22ae0SGanapatrao Kulkarni } 82414b22ae0SGanapatrao Kulkarni 82529be2fe0SIan Rogers char *perf_pmu__getcpuid(struct perf_pmu *pmu) 826d77ade9fSAndi Kleen { 827d77ade9fSAndi Kleen char *cpuid; 828d77ade9fSAndi Kleen static bool printed; 829d77ade9fSAndi Kleen 830d77ade9fSAndi Kleen cpuid = getenv("PERF_CPUID"); 831d77ade9fSAndi Kleen if (cpuid) 832d77ade9fSAndi Kleen cpuid = strdup(cpuid); 833d77ade9fSAndi Kleen if (!cpuid) 83454e32dc0SGanapatrao Kulkarni cpuid = get_cpuid_str(pmu); 835d77ade9fSAndi Kleen if (!cpuid) 836d77ade9fSAndi Kleen return NULL; 837d77ade9fSAndi Kleen 838d77ade9fSAndi Kleen if (!printed) { 839d77ade9fSAndi Kleen pr_debug("Using CPUID %s\n", cpuid); 840d77ade9fSAndi Kleen printed = true; 841d77ade9fSAndi Kleen } 842d77ade9fSAndi Kleen return cpuid; 843d77ade9fSAndi Kleen } 844d77ade9fSAndi Kleen 845f8ea2c15SIan Rogers __weak const struct pmu_metrics_table *pmu_metrics_table__find(void) 846f8ea2c15SIan Rogers { 847f8ea2c15SIan Rogers return perf_pmu__find_metrics_table(NULL); 848f8ea2c15SIan Rogers } 849f8ea2c15SIan Rogers 850240e6fd0SIan Rogers /** 851240e6fd0SIan Rogers * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any 852240e6fd0SIan Rogers * trailing suffix? The Suffix must be in form 853240e6fd0SIan Rogers * tok_{digits}, or tok{digits}. 854240e6fd0SIan Rogers * @pmu_name: The pmu_name with possible suffix. 855240e6fd0SIan Rogers * @tok: The possible match to pmu_name without suffix. 856c07d5c92SJohn Garry */ 857240e6fd0SIan Rogers static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok) 858c47a5599SJin Yao { 8593241d46fSIan Rogers const char *p, *suffix; 8603241d46fSIan Rogers bool has_hex = false; 861c47a5599SJin Yao 862c47a5599SJin Yao if (strncmp(pmu_name, tok, strlen(tok))) 863c47a5599SJin Yao return false; 864c47a5599SJin Yao 8653241d46fSIan Rogers suffix = p = pmu_name + strlen(tok); 866c47a5599SJin Yao if (*p == 0) 867c47a5599SJin Yao return true; 868c47a5599SJin Yao 8693241d46fSIan Rogers if (*p == '_') { 870c47a5599SJin Yao ++p; 8713241d46fSIan Rogers ++suffix; 8723241d46fSIan Rogers } 873c07d5c92SJohn Garry 874c07d5c92SJohn Garry /* Ensure we end in a number */ 875c07d5c92SJohn Garry while (1) { 8763241d46fSIan Rogers if (!isxdigit(*p)) 877c47a5599SJin Yao return false; 8783241d46fSIan Rogers if (!has_hex) 8793241d46fSIan Rogers has_hex = !isdigit(*p); 880c07d5c92SJohn Garry if (*(++p) == 0) 881c07d5c92SJohn Garry break; 882c07d5c92SJohn Garry } 883c47a5599SJin Yao 8843241d46fSIan Rogers if (has_hex) 8853241d46fSIan Rogers return (p - suffix) > 2; 8863241d46fSIan Rogers 887c47a5599SJin Yao return true; 888c47a5599SJin Yao } 889c47a5599SJin Yao 890240e6fd0SIan Rogers /** 891240e6fd0SIan Rogers * pmu_uncore_alias_match - does name match the PMU name? 892240e6fd0SIan Rogers * @pmu_name: the json struct pmu_event name. This may lack a suffix (which 893240e6fd0SIan Rogers * matches) or be of the form "socket,pmuname" which will match 894240e6fd0SIan Rogers * "socketX_pmunameY". 895240e6fd0SIan Rogers * @name: a real full PMU name as from sysfs. 896240e6fd0SIan Rogers */ 897240e6fd0SIan Rogers static bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 898730670b1SJohn Garry { 899730670b1SJohn Garry char *tmp = NULL, *tok, *str; 900730670b1SJohn Garry bool res; 901730670b1SJohn Garry 902240e6fd0SIan Rogers if (strchr(pmu_name, ',') == NULL) 903240e6fd0SIan Rogers return perf_pmu__match_ignoring_suffix(name, pmu_name); 904240e6fd0SIan Rogers 905730670b1SJohn Garry str = strdup(pmu_name); 906730670b1SJohn Garry if (!str) 907730670b1SJohn Garry return false; 908730670b1SJohn Garry 909730670b1SJohn Garry /* 910730670b1SJohn Garry * uncore alias may be from different PMU with common prefix 911730670b1SJohn Garry */ 912730670b1SJohn Garry tok = strtok_r(str, ",", &tmp); 913730670b1SJohn Garry if (strncmp(pmu_name, tok, strlen(tok))) { 914730670b1SJohn Garry res = false; 915730670b1SJohn Garry goto out; 916730670b1SJohn Garry } 917730670b1SJohn Garry 918730670b1SJohn Garry /* 919730670b1SJohn Garry * Match more complex aliases where the alias name is a comma-delimited 920730670b1SJohn Garry * list of tokens, orderly contained in the matching PMU name. 921730670b1SJohn Garry * 922730670b1SJohn Garry * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 923730670b1SJohn Garry * match "socket" in "socketX_pmunameY" and then "pmuname" in 924730670b1SJohn Garry * "pmunameY". 925730670b1SJohn Garry */ 926c07d5c92SJohn Garry while (1) { 927c07d5c92SJohn Garry char *next_tok = strtok_r(NULL, ",", &tmp); 928c07d5c92SJohn Garry 929730670b1SJohn Garry name = strstr(name, tok); 930c07d5c92SJohn Garry if (!name || 931240e6fd0SIan Rogers (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) { 932730670b1SJohn Garry res = false; 933730670b1SJohn Garry goto out; 934730670b1SJohn Garry } 935c07d5c92SJohn Garry if (!next_tok) 936c07d5c92SJohn Garry break; 937c07d5c92SJohn Garry tok = next_tok; 938c07d5c92SJohn Garry name += strlen(tok); 939730670b1SJohn Garry } 940730670b1SJohn Garry 941730670b1SJohn Garry res = true; 942730670b1SJohn Garry out: 943730670b1SJohn Garry free(str); 944730670b1SJohn Garry return res; 945730670b1SJohn Garry } 946730670b1SJohn Garry 9472879ff36SJing Zhang bool pmu_uncore_identifier_match(const char *compat, const char *id) 9482879ff36SJing Zhang { 9492879ff36SJing Zhang regex_t re; 9502879ff36SJing Zhang regmatch_t pmatch[1]; 9512879ff36SJing Zhang int match; 9522879ff36SJing Zhang 9532879ff36SJing Zhang if (regcomp(&re, compat, REG_EXTENDED) != 0) { 9542879ff36SJing Zhang /* Warn unable to generate match particular string. */ 9552879ff36SJing Zhang pr_info("Invalid regular expression %s\n", compat); 9562879ff36SJing Zhang return false; 9572879ff36SJing Zhang } 9582879ff36SJing Zhang 9592879ff36SJing Zhang match = !regexec(&re, id, 1, pmatch, 0); 9602879ff36SJing Zhang if (match) { 9612879ff36SJing Zhang /* Ensure a full match. */ 9622879ff36SJing Zhang match = pmatch[0].rm_so == 0 && (size_t)pmatch[0].rm_eo == strlen(id); 9632879ff36SJing Zhang } 9642879ff36SJing Zhang regfree(&re); 9652879ff36SJing Zhang 9662879ff36SJing Zhang return match; 9672879ff36SJing Zhang } 9682879ff36SJing Zhang 969660842e4SIan Rogers static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, 9701ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 971660842e4SIan Rogers void *vdata) 972660842e4SIan Rogers { 973f26d22f1SIan Rogers struct perf_pmu *pmu = vdata; 974660842e4SIan Rogers 975d9c5f5f9SIan Rogers perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, 976d9c5f5f9SIan Rogers pe, EVENT_SRC_CPU_JSON); 977660842e4SIan Rogers return 0; 978660842e4SIan Rogers } 979660842e4SIan Rogers 980933f82ffSSukadev Bhattiprolu /* 981d685819bSIan Rogers * From the pmu_events_table, find the events that correspond to the given 982d685819bSIan Rogers * PMU and add them to the list 'head'. 983933f82ffSSukadev Bhattiprolu */ 984838a8c5fSIan Rogers void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table) 985933f82ffSSukadev Bhattiprolu { 986f26d22f1SIan Rogers pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu); 987933f82ffSSukadev Bhattiprolu } 988933f82ffSSukadev Bhattiprolu 989838a8c5fSIan Rogers static void pmu_add_cpu_aliases(struct perf_pmu *pmu) 990e45ad701SJohn Garry { 9917c52f10cSIan Rogers if (!pmu->events_table) 992e45ad701SJohn Garry return; 993e45ad701SJohn Garry 994e6ff1eedSIan Rogers if (pmu->cpu_aliases_added) 995e6ff1eedSIan Rogers return; 996e6ff1eedSIan Rogers 9977c52f10cSIan Rogers pmu_add_cpu_aliases_table(pmu, pmu->events_table); 998e6ff1eedSIan Rogers pmu->cpu_aliases_added = true; 999e45ad701SJohn Garry } 1000e45ad701SJohn Garry 100129be2fe0SIan Rogers static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, 10021ba3752aSIan Rogers const struct pmu_events_table *table __maybe_unused, 1003f26d22f1SIan Rogers void *vdata) 10044513c719SJohn Garry { 1005f26d22f1SIan Rogers struct perf_pmu *pmu = vdata; 10064513c719SJohn Garry 10074513c719SJohn Garry if (!pe->compat || !pe->pmu) 10084513c719SJohn Garry return 0; 10094513c719SJohn Garry 10102879ff36SJing Zhang if (pmu_uncore_alias_match(pe->pmu, pmu->name) && 10112879ff36SJing Zhang pmu_uncore_identifier_match(pe->compat, pmu->id)) { 10127b723dbbSIan Rogers perf_pmu__new_alias(pmu, 1013edb217ffSIan Rogers pe->name, 1014edb217ffSIan Rogers pe->desc, 1015edb217ffSIan Rogers pe->event, 1016edb217ffSIan Rogers /*val_fd=*/ NULL, 1017d9c5f5f9SIan Rogers pe, 1018d9c5f5f9SIan Rogers EVENT_SRC_SYS_JSON); 10194513c719SJohn Garry } 10204513c719SJohn Garry 10214513c719SJohn Garry return 0; 10224513c719SJohn Garry } 10234513c719SJohn Garry 1024838a8c5fSIan Rogers void pmu_add_sys_aliases(struct perf_pmu *pmu) 10254513c719SJohn Garry { 10264513c719SJohn Garry if (!pmu->id) 10274513c719SJohn Garry return; 10284513c719SJohn Garry 1029f26d22f1SIan Rogers pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu); 10304513c719SJohn Garry } 10314513c719SJohn Garry 1032b1f05622SIan Rogers static char *pmu_find_alias_name(struct perf_pmu *pmu, int dirfd) 103313d60ba0SKan Liang { 1034b1f05622SIan Rogers FILE *file = perf_pmu__open_file_at(pmu, dirfd, "alias"); 1035b1f05622SIan Rogers char *line = NULL; 1036b1f05622SIan Rogers size_t line_len = 0; 1037b1f05622SIan Rogers ssize_t ret; 103813d60ba0SKan Liang 1039b1f05622SIan Rogers if (!file) 104013d60ba0SKan Liang return NULL; 1041b1f05622SIan Rogers 1042b1f05622SIan Rogers ret = getline(&line, &line_len, file); 1043b1f05622SIan Rogers if (ret < 0) { 1044b1f05622SIan Rogers fclose(file); 1045b1f05622SIan Rogers return NULL; 1046b1f05622SIan Rogers } 1047b1f05622SIan Rogers /* Remove trailing newline. */ 1048b1f05622SIan Rogers if (ret > 0 && line[ret - 1] == '\n') 1049b1f05622SIan Rogers line[--ret] = '\0'; 1050b1f05622SIan Rogers 1051b1f05622SIan Rogers fclose(file); 1052b1f05622SIan Rogers return line; 105313d60ba0SKan Liang } 105413d60ba0SKan Liang 10553a69672eSNamhyung Kim static int pmu_max_precise(int dirfd, struct perf_pmu *pmu) 105690a86bdeSJiri Olsa { 105790a86bdeSJiri Olsa int max_precise = -1; 105890a86bdeSJiri Olsa 10593a69672eSNamhyung Kim perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise); 106090a86bdeSJiri Olsa return max_precise; 106190a86bdeSJiri Olsa } 106290a86bdeSJiri Olsa 1063aa613601SIan Rogers void __weak 1064bb65acdcSKan Liang perf_pmu__arch_init(struct perf_pmu *pmu) 1065aa613601SIan Rogers { 1066bb65acdcSKan Liang if (pmu->is_core) 1067bb65acdcSKan Liang pmu->mem_events = perf_mem_events; 1068aa613601SIan Rogers } 1069aa613601SIan Rogers 1070aa1551f2SIan Rogers struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *name, 1071aa1551f2SIan Rogers bool eager_load) 1072cd82a32eSJiri Olsa { 1073cd82a32eSJiri Olsa struct perf_pmu *pmu; 1074cd82a32eSJiri Olsa __u32 type; 107549afa7f6SJin Yao 1076cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 1077cd82a32eSJiri Olsa if (!pmu) 1078cd82a32eSJiri Olsa return NULL; 1079cd82a32eSJiri Olsa 1080f63a536fSIan Rogers pmu->name = strdup(name); 1081f63a536fSIan Rogers if (!pmu->name) 1082f63a536fSIan Rogers goto err; 108388ed9184SIan Rogers 108488ed9184SIan Rogers /* 108588ed9184SIan Rogers * Read type early to fail fast if a lookup name isn't a PMU. Ensure 108688ed9184SIan Rogers * that type value is successfully assigned (return 1). 108788ed9184SIan Rogers */ 108888ed9184SIan Rogers if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1) 108988ed9184SIan Rogers goto err; 109088ed9184SIan Rogers 109188ed9184SIan Rogers INIT_LIST_HEAD(&pmu->format); 109288ed9184SIan Rogers INIT_LIST_HEAD(&pmu->aliases); 109388ed9184SIan Rogers INIT_LIST_HEAD(&pmu->caps); 109488ed9184SIan Rogers 1095838a8c5fSIan Rogers /* 1096838a8c5fSIan Rogers * The pmu data we store & need consists of the pmu 1097838a8c5fSIan Rogers * type value and format definitions. Load both right 1098838a8c5fSIan Rogers * now. 1099838a8c5fSIan Rogers */ 1100aa1551f2SIan Rogers if (pmu_format(pmu, dirfd, name, eager_load)) 1101ef5de161SChristophe JAILLET goto err; 1102ef5de161SChristophe JAILLET 1103d06593aaSIan Rogers pmu->is_core = is_pmu_core(name); 1104d06593aaSIan Rogers pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core); 110513d60ba0SKan Liang 110654e32dc0SGanapatrao Kulkarni pmu->type = type; 11073a69672eSNamhyung Kim pmu->is_uncore = pmu_is_uncore(dirfd, name); 110851d54847SJohn Garry if (pmu->is_uncore) 110951d54847SJohn Garry pmu->id = pmu_id(name); 11103a69672eSNamhyung Kim pmu->max_precise = pmu_max_precise(dirfd, pmu); 1111b1f05622SIan Rogers pmu->alias_name = pmu_find_alias_name(pmu, dirfd); 11127c52f10cSIan Rogers pmu->events_table = perf_pmu__find_events_table(pmu); 1113d9c5f5f9SIan Rogers /* 1114d9c5f5f9SIan Rogers * Load the sys json events/aliases when loading the PMU as each event 1115d9c5f5f9SIan Rogers * may have a different compat regular expression. We therefore can't 1116d9c5f5f9SIan Rogers * know the number of sys json events/aliases without computing the 1117d9c5f5f9SIan Rogers * regular expressions for them all. 1118d9c5f5f9SIan Rogers */ 1119838a8c5fSIan Rogers pmu_add_sys_aliases(pmu); 11201eaf496eSIan Rogers list_add_tail(&pmu->list, pmus); 1121dc0a6202SAdrian Hunter 1122aa613601SIan Rogers perf_pmu__arch_init(pmu); 1123dc0a6202SAdrian Hunter 112418eb2ca8SIan Rogers if (eager_load) 112518eb2ca8SIan Rogers pmu_aliases_parse_eager(pmu, dirfd); 112618eb2ca8SIan Rogers 1127cd82a32eSJiri Olsa return pmu; 112813d60ba0SKan Liang err: 1129efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 113013d60ba0SKan Liang free(pmu); 113113d60ba0SKan Liang return NULL; 1132cd82a32eSJiri Olsa } 1133cd82a32eSJiri Olsa 1134628eaa4eSIan Rogers /* Creates the PMU when sysfs scanning fails. */ 1135628eaa4eSIan Rogers struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus) 1136628eaa4eSIan Rogers { 1137628eaa4eSIan Rogers struct perf_pmu *pmu = zalloc(sizeof(*pmu)); 1138628eaa4eSIan Rogers 1139628eaa4eSIan Rogers if (!pmu) 1140628eaa4eSIan Rogers return NULL; 1141628eaa4eSIan Rogers 1142628eaa4eSIan Rogers pmu->name = strdup("cpu"); 1143628eaa4eSIan Rogers if (!pmu->name) { 1144628eaa4eSIan Rogers free(pmu); 1145628eaa4eSIan Rogers return NULL; 1146628eaa4eSIan Rogers } 1147628eaa4eSIan Rogers 1148628eaa4eSIan Rogers pmu->is_core = true; 1149628eaa4eSIan Rogers pmu->type = PERF_TYPE_RAW; 1150628eaa4eSIan Rogers pmu->cpus = cpu_map__online(); 1151628eaa4eSIan Rogers 1152628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->format); 1153628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->aliases); 1154628eaa4eSIan Rogers INIT_LIST_HEAD(&pmu->caps); 1155628eaa4eSIan Rogers list_add_tail(&pmu->list, core_pmus); 1156628eaa4eSIan Rogers return pmu; 1157628eaa4eSIan Rogers } 1158628eaa4eSIan Rogers 1159e552b7beSRob Herring void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1160e552b7beSRob Herring { 1161e552b7beSRob Herring struct perf_pmu_format *format; 1162e552b7beSRob Herring 116368c25043SIan Rogers if (pmu->formats_checked) 116468c25043SIan Rogers return; 116568c25043SIan Rogers 116668c25043SIan Rogers pmu->formats_checked = true; 116768c25043SIan Rogers 1168e552b7beSRob Herring /* fake pmu doesn't have format list */ 1169e552b7beSRob Herring if (pmu == &perf_pmu__fake) 1170e552b7beSRob Herring return; 1171e552b7beSRob Herring 117250402641SIan Rogers list_for_each_entry(format, &pmu->format, list) { 117350402641SIan Rogers perf_pmu_format__load(pmu, format); 1174e552b7beSRob Herring if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { 1175e552b7beSRob Herring pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" 1176e552b7beSRob Herring "which is not supported by this version of perf!\n", 1177e552b7beSRob Herring pmu->name, format->name, format->value); 1178e552b7beSRob Herring return; 1179e552b7beSRob Herring } 1180e552b7beSRob Herring } 118150402641SIan Rogers } 1182e552b7beSRob Herring 1183c6d616feSIan Rogers bool evsel__is_aux_event(const struct evsel *evsel) 1184e12ee9f7SAdrian Hunter { 1185e76026bdSArnaldo Carvalho de Melo struct perf_pmu *pmu = evsel__find_pmu(evsel); 1186e12ee9f7SAdrian Hunter 1187e12ee9f7SAdrian Hunter return pmu && pmu->auxtrace; 1188e12ee9f7SAdrian Hunter } 1189e12ee9f7SAdrian Hunter 11906593f019SJames Clark /* 11916593f019SJames Clark * Set @config_name to @val as long as the user hasn't already set or cleared it 11926593f019SJames Clark * by passing a config term on the command line. 11936593f019SJames Clark * 11946593f019SJames Clark * @val is the value to put into the bits specified by @config_name rather than 11956593f019SJames Clark * the bit pattern. It is shifted into position by this function, so to set 11966593f019SJames Clark * something to true, pass 1 for val rather than a pre shifted value. 11976593f019SJames Clark */ 11986593f019SJames Clark #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask)) 11996593f019SJames Clark void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel, 12006593f019SJames Clark const char *config_name, u64 val) 12016593f019SJames Clark { 12026593f019SJames Clark u64 user_bits = 0, bits; 12036593f019SJames Clark struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG); 12046593f019SJames Clark 12056593f019SJames Clark if (term) 12066593f019SJames Clark user_bits = term->val.cfg_chg; 12076593f019SJames Clark 1208da6a5afdSIan Rogers bits = perf_pmu__format_bits(pmu, config_name); 12096593f019SJames Clark 12106593f019SJames Clark /* Do nothing if the user changed the value */ 12116593f019SJames Clark if (bits & user_bits) 12126593f019SJames Clark return; 12136593f019SJames Clark 12146593f019SJames Clark /* Otherwise replace it */ 12156593f019SJames Clark evsel->core.attr.config &= ~bits; 12166593f019SJames Clark evsel->core.attr.config |= field_prep(bits, val); 12176593f019SJames Clark } 12186593f019SJames Clark 12195c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 122063883cb0SIan Rogers pmu_find_format(const struct list_head *formats, const char *name) 1221cd82a32eSJiri Olsa { 12225c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1223cd82a32eSJiri Olsa 1224cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 1225cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 1226cd82a32eSJiri Olsa return format; 1227cd82a32eSJiri Olsa 1228cd82a32eSJiri Olsa return NULL; 1229cd82a32eSJiri Olsa } 1230cd82a32eSJiri Olsa 1231da6a5afdSIan Rogers __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name) 123209ff6071SAdrian Hunter { 1233da6a5afdSIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 123409ff6071SAdrian Hunter __u64 bits = 0; 123509ff6071SAdrian Hunter int fbit; 123609ff6071SAdrian Hunter 123709ff6071SAdrian Hunter if (!format) 123809ff6071SAdrian Hunter return 0; 123909ff6071SAdrian Hunter 124009ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 124109ff6071SAdrian Hunter bits |= 1ULL << fbit; 124209ff6071SAdrian Hunter 124309ff6071SAdrian Hunter return bits; 124409ff6071SAdrian Hunter } 124509ff6071SAdrian Hunter 12467eb54733SIan Rogers int perf_pmu__format_type(struct perf_pmu *pmu, const char *name) 1247a1ac7de6SAdrian Hunter { 12487eb54733SIan Rogers struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 1249a1ac7de6SAdrian Hunter 1250a1ac7de6SAdrian Hunter if (!format) 1251a1ac7de6SAdrian Hunter return -1; 1252a1ac7de6SAdrian Hunter 125350402641SIan Rogers perf_pmu_format__load(pmu, format); 1254a1ac7de6SAdrian Hunter return format->value; 1255a1ac7de6SAdrian Hunter } 1256a1ac7de6SAdrian Hunter 1257cd82a32eSJiri Olsa /* 1258dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 12594d39c89fSIngo Molnar * and unformatted value (value parameter). 1260cd82a32eSJiri Olsa */ 1261dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1262dc0a6202SAdrian Hunter bool zero) 1263cd82a32eSJiri Olsa { 1264cd82a32eSJiri Olsa unsigned long fbit, vbit; 1265cd82a32eSJiri Olsa 1266cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1267cd82a32eSJiri Olsa 1268cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 1269cd82a32eSJiri Olsa continue; 1270cd82a32eSJiri Olsa 1271dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 1272dc0a6202SAdrian Hunter *v |= (1llu << fbit); 1273dc0a6202SAdrian Hunter else if (zero) 1274dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 1275cd82a32eSJiri Olsa } 1276cd82a32eSJiri Olsa } 1277cd82a32eSJiri Olsa 12780efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 12790efe6b67SAdrian Hunter { 12801b9caa10SJiri Olsa int w; 12810efe6b67SAdrian Hunter 12821b9caa10SJiri Olsa w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 12831b9caa10SJiri Olsa if (!w) 12841b9caa10SJiri Olsa return 0; 12851b9caa10SJiri Olsa if (w < 64) 12861b9caa10SJiri Olsa return (1ULL << w) - 1; 12871b9caa10SJiri Olsa return -1; 12880efe6b67SAdrian Hunter } 12890efe6b67SAdrian Hunter 1290cd82a32eSJiri Olsa /* 1291688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 1292688d4dfcSCody P Schafer * in the remaining terms. 1293688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 1294688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 1295688d4dfcSCody P Schafer * in a config string) later on in the term list. 1296688d4dfcSCody P Schafer */ 1297688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 12980d3f0e6fSIan Rogers struct parse_events_terms *head_terms, 1299688d4dfcSCody P Schafer __u64 *value) 1300688d4dfcSCody P Schafer { 1301688d4dfcSCody P Schafer struct parse_events_term *t; 1302688d4dfcSCody P Schafer 13030d3f0e6fSIan Rogers list_for_each_entry(t, &head_terms->terms, list) { 13042a3d252dSIan Rogers if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 13052a3d252dSIan Rogers t->config && !strcmp(t->config, term->config)) { 1306688d4dfcSCody P Schafer t->used = true; 1307688d4dfcSCody P Schafer *value = t->val.num; 1308688d4dfcSCody P Schafer return 0; 1309688d4dfcSCody P Schafer } 1310688d4dfcSCody P Schafer } 1311688d4dfcSCody P Schafer 1312bb963e16SNamhyung Kim if (verbose > 0) 1313688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 1314688d4dfcSCody P Schafer 1315688d4dfcSCody P Schafer return -1; 1316688d4dfcSCody P Schafer } 1317688d4dfcSCody P Schafer 131863883cb0SIan Rogers static char *pmu_formats_string(const struct list_head *formats) 1319e64b020bSJiri Olsa { 1320e64b020bSJiri Olsa struct perf_pmu_format *format; 132111db4e29SMasami Hiramatsu char *str = NULL; 132211db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1323f1417ceaSXin Gao unsigned int i = 0; 1324e64b020bSJiri Olsa 1325ffeb883eSHe Kuang if (!formats) 1326e64b020bSJiri Olsa return NULL; 1327e64b020bSJiri Olsa 1328e64b020bSJiri Olsa /* sysfs exported terms */ 1329ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 133011db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 133111db4e29SMasami Hiramatsu goto error; 1332e64b020bSJiri Olsa 1333ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 133411db4e29SMasami Hiramatsu error: 1335ffeb883eSHe Kuang strbuf_release(&buf); 1336e64b020bSJiri Olsa 1337e64b020bSJiri Olsa return str; 1338e64b020bSJiri Olsa } 1339e64b020bSJiri Olsa 1340688d4dfcSCody P Schafer /* 1341cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 134288aca8d9SCody P Schafer * user input data - term parameter. 1343cd82a32eSJiri Olsa */ 134463883cb0SIan Rogers static int pmu_config_term(const struct perf_pmu *pmu, 1345cd82a32eSJiri Olsa struct perf_event_attr *attr, 1346dc0a6202SAdrian Hunter struct parse_events_term *term, 13470d3f0e6fSIan Rogers struct parse_events_terms *head_terms, 1348e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1349cd82a32eSJiri Olsa { 13505c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1351cd82a32eSJiri Olsa __u64 *vp; 13520efe6b67SAdrian Hunter __u64 val, max_val; 1353cd82a32eSJiri Olsa 1354cd82a32eSJiri Olsa /* 1355688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 1356688d4dfcSCody P Schafer * skip it in normal eval. 1357688d4dfcSCody P Schafer */ 1358688d4dfcSCody P Schafer if (term->used) 1359688d4dfcSCody P Schafer return 0; 1360688d4dfcSCody P Schafer 1361688d4dfcSCody P Schafer /* 1362cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 1363cd82a32eSJiri Olsa * to be done for them. 1364cd82a32eSJiri Olsa */ 1365cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 1366cd82a32eSJiri Olsa return 0; 1367cd82a32eSJiri Olsa 1368804fee5dSIan Rogers format = pmu_find_format(&pmu->format, term->config); 1369688d4dfcSCody P Schafer if (!format) { 1370804fee5dSIan Rogers char *pmu_term = pmu_formats_string(&pmu->format); 13714ac22b48SIan Rogers char *unknown_term; 13724ac22b48SIan Rogers char *help_msg; 1373ffeb883eSHe Kuang 13744ac22b48SIan Rogers if (asprintf(&unknown_term, 13754ac22b48SIan Rogers "unknown term '%s' for pmu '%s'", 1376804fee5dSIan Rogers term->config, pmu->name) < 0) 13774ac22b48SIan Rogers unknown_term = NULL; 13784ac22b48SIan Rogers help_msg = parse_events_formats_error_string(pmu_term); 13794ac22b48SIan Rogers if (err) { 13806c191289SIan Rogers parse_events_error__handle(err, term->err_term, 13814ac22b48SIan Rogers unknown_term, 13824ac22b48SIan Rogers help_msg); 13834ac22b48SIan Rogers } else { 13844ac22b48SIan Rogers pr_debug("%s (%s)\n", unknown_term, help_msg); 13854ac22b48SIan Rogers free(unknown_term); 1386e64b020bSJiri Olsa } 13874ac22b48SIan Rogers free(pmu_term); 1388cd82a32eSJiri Olsa return -EINVAL; 1389688d4dfcSCody P Schafer } 139050402641SIan Rogers perf_pmu_format__load(pmu, format); 1391cd82a32eSJiri Olsa switch (format->value) { 1392cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 1393cd82a32eSJiri Olsa vp = &attr->config; 1394cd82a32eSJiri Olsa break; 1395cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 1396cd82a32eSJiri Olsa vp = &attr->config1; 1397cd82a32eSJiri Olsa break; 1398cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 1399cd82a32eSJiri Olsa vp = &attr->config2; 1400cd82a32eSJiri Olsa break; 1401204e7c49SRob Herring case PERF_PMU_FORMAT_VALUE_CONFIG3: 1402204e7c49SRob Herring vp = &attr->config3; 1403204e7c49SRob Herring break; 1404cd82a32eSJiri Olsa default: 1405cd82a32eSJiri Olsa return -EINVAL; 1406cd82a32eSJiri Olsa } 1407cd82a32eSJiri Olsa 140816fa7e82SJiri Olsa /* 1409688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 1410688d4dfcSCody P Schafer * using event parameters. 141116fa7e82SJiri Olsa */ 141299e7138eSJiri Olsa if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 141399e7138eSJiri Olsa if (term->no_value && 141499e7138eSJiri Olsa bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 141599e7138eSJiri Olsa if (err) { 14166c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1417448d732cSIan Rogers strdup("no value assigned for term"), 1418448d732cSIan Rogers NULL); 141999e7138eSJiri Olsa } 142099e7138eSJiri Olsa return -EINVAL; 142199e7138eSJiri Olsa } 142299e7138eSJiri Olsa 1423688d4dfcSCody P Schafer val = term->val.num; 142499e7138eSJiri Olsa } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1425688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 1426bb963e16SNamhyung Kim if (verbose > 0) { 1427688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 1428688d4dfcSCody P Schafer term->config, term->val.str); 1429e64b020bSJiri Olsa } 1430e64b020bSJiri Olsa if (err) { 14316c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1432448d732cSIan Rogers strdup("expected numeric value"), 1433448d732cSIan Rogers NULL); 1434e64b020bSJiri Olsa } 1435688d4dfcSCody P Schafer return -EINVAL; 1436688d4dfcSCody P Schafer } 1437688d4dfcSCody P Schafer 1438688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 1439688d4dfcSCody P Schafer return -EINVAL; 1440688d4dfcSCody P Schafer } else 1441688d4dfcSCody P Schafer return -EINVAL; 1442688d4dfcSCody P Schafer 14430efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 14440efe6b67SAdrian Hunter if (val > max_val) { 14450efe6b67SAdrian Hunter if (err) { 1446448d732cSIan Rogers char *err_str; 1447448d732cSIan Rogers 14486c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1449448d732cSIan Rogers asprintf(&err_str, 1450f5144ecaSIan Rogers "value too big for format (%s), maximum is %llu", 1451f5144ecaSIan Rogers format->name, (unsigned long long)max_val) < 0 1452448d732cSIan Rogers ? strdup("value too big for format") 1453448d732cSIan Rogers : err_str, 1454448d732cSIan Rogers NULL); 14550efe6b67SAdrian Hunter return -EINVAL; 14560efe6b67SAdrian Hunter } 14570efe6b67SAdrian Hunter /* 14580efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 14590efe6b67SAdrian Hunter * silently truncated. 14600efe6b67SAdrian Hunter */ 14610efe6b67SAdrian Hunter } 14620efe6b67SAdrian Hunter 1463688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 1464cd82a32eSJiri Olsa return 0; 1465cd82a32eSJiri Olsa } 1466cd82a32eSJiri Olsa 146763883cb0SIan Rogers int perf_pmu__config_terms(const struct perf_pmu *pmu, 1468cff7f956SJiri Olsa struct perf_event_attr *attr, 14690d3f0e6fSIan Rogers struct parse_events_terms *terms, 1470e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1471cd82a32eSJiri Olsa { 14726cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 1473cd82a32eSJiri Olsa 14740d3f0e6fSIan Rogers list_for_each_entry(term, &terms->terms, list) { 14750d3f0e6fSIan Rogers if (pmu_config_term(pmu, attr, term, terms, zero, err)) 1476cd82a32eSJiri Olsa return -EINVAL; 1477688d4dfcSCody P Schafer } 1478cd82a32eSJiri Olsa 1479cd82a32eSJiri Olsa return 0; 1480cd82a32eSJiri Olsa } 1481cd82a32eSJiri Olsa 1482cd82a32eSJiri Olsa /* 1483cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 1484cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 1485cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 1486cd82a32eSJiri Olsa */ 1487cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 14880d3f0e6fSIan Rogers struct parse_events_terms *head_terms, 1489e64b020bSJiri Olsa struct parse_events_error *err) 1490cd82a32eSJiri Olsa { 14910197da7aSIan Rogers bool zero = !!pmu->perf_event_attr_init_default; 1492dc0a6202SAdrian Hunter 1493804fee5dSIan Rogers return perf_pmu__config_terms(pmu, attr, head_terms, zero, err); 1494cd82a32eSJiri Olsa } 1495cd82a32eSJiri Olsa 14965c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 14976cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 1498a6146d50SZheng Yan { 1499e6ff1eedSIan Rogers struct perf_pmu_alias *alias; 1500970ef02eSIan Rogers const char *name; 1501a6146d50SZheng Yan 1502a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 1503a6146d50SZheng Yan return NULL; 1504a6146d50SZheng Yan 1505a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 150664199ae4SIan Rogers if (!term->no_value) 1507a6146d50SZheng Yan return NULL; 1508a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 1509a6146d50SZheng Yan return NULL; 1510a6146d50SZheng Yan name = term->config; 1511c3245d20SIan Rogers 1512a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1513a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 1514a6146d50SZheng Yan return NULL; 1515a6146d50SZheng Yan name = term->val.str; 1516a6146d50SZheng Yan } else { 1517a6146d50SZheng Yan return NULL; 1518a6146d50SZheng Yan } 1519a6146d50SZheng Yan 15208d4b6d37SIan Rogers alias = perf_pmu__find_alias(pmu, name, /*load=*/ true); 1521e6ff1eedSIan Rogers if (alias || pmu->cpu_aliases_added) 1522e6ff1eedSIan Rogers return alias; 1523e6ff1eedSIan Rogers 1524e6ff1eedSIan Rogers /* Alias doesn't exist, try to get it from the json events. */ 1525e6ff1eedSIan Rogers if (pmu->events_table && 1526e6ff1eedSIan Rogers pmu_events_table__find_event(pmu->events_table, pmu, name, 1527e6ff1eedSIan Rogers pmu_add_cpu_aliases_map_callback, 1528e6ff1eedSIan Rogers pmu) == 0) { 15298d4b6d37SIan Rogers alias = perf_pmu__find_alias(pmu, name, /*load=*/ false); 1530e6ff1eedSIan Rogers } 1531e6ff1eedSIan Rogers return alias; 1532a6146d50SZheng Yan } 1533a6146d50SZheng Yan 1534410136f5SStephane Eranian 15357b723dbbSIan Rogers static int check_info_data(struct perf_pmu *pmu, 15367b723dbbSIan Rogers struct perf_pmu_alias *alias, 15379d31cb93SIan Rogers struct perf_pmu_info *info, 15389d31cb93SIan Rogers struct parse_events_error *err, 15399d31cb93SIan Rogers int column) 1540410136f5SStephane Eranian { 15417b723dbbSIan Rogers read_alias_info(pmu, alias); 1542410136f5SStephane Eranian /* 1543410136f5SStephane Eranian * Only one term in event definition can 15441d9e446bSJiri Olsa * define unit, scale and snapshot, fail 15451d9e446bSJiri Olsa * if there's more than one. 1546410136f5SStephane Eranian */ 15479d31cb93SIan Rogers if (info->unit && alias->unit[0]) { 15489d31cb93SIan Rogers parse_events_error__handle(err, column, 15499d31cb93SIan Rogers strdup("Attempt to set event's unit twice"), 15509d31cb93SIan Rogers NULL); 1551410136f5SStephane Eranian return -EINVAL; 15529d31cb93SIan Rogers } 15539d31cb93SIan Rogers if (info->scale && alias->scale) { 15549d31cb93SIan Rogers parse_events_error__handle(err, column, 15559d31cb93SIan Rogers strdup("Attempt to set event's scale twice"), 15569d31cb93SIan Rogers NULL); 15579d31cb93SIan Rogers return -EINVAL; 15589d31cb93SIan Rogers } 15599d31cb93SIan Rogers if (info->snapshot && alias->snapshot) { 15609d31cb93SIan Rogers parse_events_error__handle(err, column, 15619d31cb93SIan Rogers strdup("Attempt to set event snapshot twice"), 15629d31cb93SIan Rogers NULL); 15639d31cb93SIan Rogers return -EINVAL; 15649d31cb93SIan Rogers } 1565410136f5SStephane Eranian 1566b30a7d1fSArnaldo Carvalho de Melo if (alias->unit[0]) 15671d9e446bSJiri Olsa info->unit = alias->unit; 1568410136f5SStephane Eranian 1569410136f5SStephane Eranian if (alias->scale) 15701d9e446bSJiri Olsa info->scale = alias->scale; 15711d9e446bSJiri Olsa 15721d9e446bSJiri Olsa if (alias->snapshot) 15731d9e446bSJiri Olsa info->snapshot = alias->snapshot; 1574410136f5SStephane Eranian 1575410136f5SStephane Eranian return 0; 1576410136f5SStephane Eranian } 1577410136f5SStephane Eranian 1578a6146d50SZheng Yan /* 1579a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 1580a6146d50SZheng Yan * defined for the alias 1581a6146d50SZheng Yan */ 15820d3f0e6fSIan Rogers int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms, 1583a24d9d9dSIan Rogers struct perf_pmu_info *info, bool *rewrote_terms, 1584a24d9d9dSIan Rogers struct parse_events_error *err) 1585a6146d50SZheng Yan { 15866cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 15875c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1588a6146d50SZheng Yan int ret; 1589a6146d50SZheng Yan 1590a24d9d9dSIan Rogers *rewrote_terms = false; 1591044330c1SMatt Fleming info->per_pkg = false; 1592044330c1SMatt Fleming 15938a398897SStephane Eranian /* 15948a398897SStephane Eranian * Mark unit and scale as not set 15958a398897SStephane Eranian * (different from default values, see below) 15968a398897SStephane Eranian */ 159746441bdcSMatt Fleming info->unit = NULL; 159846441bdcSMatt Fleming info->scale = 0.0; 15991d9e446bSJiri Olsa info->snapshot = false; 1600410136f5SStephane Eranian 16010d3f0e6fSIan Rogers list_for_each_entry_safe(term, h, &head_terms->terms, list) { 1602a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 1603a6146d50SZheng Yan if (!alias) 1604a6146d50SZheng Yan continue; 1605f5144ecaSIan Rogers ret = pmu_alias_terms(alias, term->err_term, &term->list); 16069d31cb93SIan Rogers if (ret) { 16079d31cb93SIan Rogers parse_events_error__handle(err, term->err_term, 16089d31cb93SIan Rogers strdup("Failure to duplicate terms"), 16099d31cb93SIan Rogers NULL); 1610a6146d50SZheng Yan return ret; 16119d31cb93SIan Rogers } 1612a24d9d9dSIan Rogers *rewrote_terms = true; 16137b723dbbSIan Rogers ret = check_info_data(pmu, alias, info, err, term->err_term); 1614410136f5SStephane Eranian if (ret) 1615410136f5SStephane Eranian return ret; 1616410136f5SStephane Eranian 1617044330c1SMatt Fleming if (alias->per_pkg) 1618044330c1SMatt Fleming info->per_pkg = true; 1619044330c1SMatt Fleming 1620e56fbc9dSArnaldo Carvalho de Melo list_del_init(&term->list); 16211dc92556SIan Rogers parse_events_term__delete(term); 1622a6146d50SZheng Yan } 16238a398897SStephane Eranian 16248a398897SStephane Eranian /* 16258a398897SStephane Eranian * if no unit or scale found in aliases, then 16268a398897SStephane Eranian * set defaults as for evsel 16278a398897SStephane Eranian * unit cannot left to NULL 16288a398897SStephane Eranian */ 162946441bdcSMatt Fleming if (info->unit == NULL) 163046441bdcSMatt Fleming info->unit = ""; 16318a398897SStephane Eranian 163246441bdcSMatt Fleming if (info->scale == 0.0) 163346441bdcSMatt Fleming info->scale = 1.0; 16348a398897SStephane Eranian 1635a6146d50SZheng Yan return 0; 1636a6146d50SZheng Yan } 1637a6146d50SZheng Yan 1638c3245d20SIan Rogers struct find_event_args { 1639c3245d20SIan Rogers const char *event; 1640c3245d20SIan Rogers void *state; 1641c3245d20SIan Rogers pmu_event_callback cb; 1642c3245d20SIan Rogers }; 1643c3245d20SIan Rogers 1644c3245d20SIan Rogers static int find_event_callback(void *state, struct pmu_event_info *info) 1645838a8c5fSIan Rogers { 1646c3245d20SIan Rogers struct find_event_args *args = state; 1647838a8c5fSIan Rogers 1648c3245d20SIan Rogers if (!strcmp(args->event, info->name)) 1649c3245d20SIan Rogers return args->cb(args->state, info); 1650838a8c5fSIan Rogers 1651c3245d20SIan Rogers return 0; 1652838a8c5fSIan Rogers } 1653c3245d20SIan Rogers 1654c3245d20SIan Rogers int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb) 1655c3245d20SIan Rogers { 1656c3245d20SIan Rogers struct find_event_args args = { 1657c3245d20SIan Rogers .event = event, 1658c3245d20SIan Rogers .state = state, 1659c3245d20SIan Rogers .cb = cb, 1660c3245d20SIan Rogers }; 1661c3245d20SIan Rogers 1662cd4e1efbSIan Rogers /* Sub-optimal, but function is only used by tests. */ 1663cd4e1efbSIan Rogers return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false, 1664cd4e1efbSIan Rogers &args, find_event_callback); 1665c3245d20SIan Rogers } 1666c3245d20SIan Rogers 1667804fee5dSIan Rogers static void perf_pmu__del_formats(struct list_head *formats) 1668d26383dcSNamhyung Kim { 1669d26383dcSNamhyung Kim struct perf_pmu_format *fmt, *tmp; 1670d26383dcSNamhyung Kim 1671d26383dcSNamhyung Kim list_for_each_entry_safe(fmt, tmp, formats, list) { 1672d26383dcSNamhyung Kim list_del(&fmt->list); 1673efe98a7aSArnaldo Carvalho de Melo zfree(&fmt->name); 1674d26383dcSNamhyung Kim free(fmt); 1675d26383dcSNamhyung Kim } 1676d26383dcSNamhyung Kim } 1677d26383dcSNamhyung Kim 167807d2b820SIan Rogers bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name) 167907d2b820SIan Rogers { 168007d2b820SIan Rogers struct perf_pmu_format *format; 168107d2b820SIan Rogers 168207d2b820SIan Rogers list_for_each_entry(format, &pmu->format, list) { 168307d2b820SIan Rogers if (!strcmp(format->name, name)) 168407d2b820SIan Rogers return true; 168507d2b820SIan Rogers } 168607d2b820SIan Rogers return false; 168707d2b820SIan Rogers } 168807d2b820SIan Rogers 16894ccf3bb7SIan Rogers int perf_pmu__for_each_format(struct perf_pmu *pmu, void *state, pmu_format_callback cb) 16904ccf3bb7SIan Rogers { 16914ccf3bb7SIan Rogers static const char *const terms[] = { 16924ccf3bb7SIan Rogers "config=0..0xffffffffffffffff", 16934ccf3bb7SIan Rogers "config1=0..0xffffffffffffffff", 16944ccf3bb7SIan Rogers "config2=0..0xffffffffffffffff", 16954ccf3bb7SIan Rogers "config3=0..0xffffffffffffffff", 16964ccf3bb7SIan Rogers "name=string", 16974ccf3bb7SIan Rogers "period=number", 16984ccf3bb7SIan Rogers "freq=number", 16994ccf3bb7SIan Rogers "branch_type=(u|k|hv|any|...)", 17004ccf3bb7SIan Rogers "time", 17014ccf3bb7SIan Rogers "call-graph=(fp|dwarf|lbr)", 17024ccf3bb7SIan Rogers "stack-size=number", 17034ccf3bb7SIan Rogers "max-stack=number", 17044ccf3bb7SIan Rogers "nr=number", 17054ccf3bb7SIan Rogers "inherit", 17064ccf3bb7SIan Rogers "no-inherit", 17074ccf3bb7SIan Rogers "overwrite", 17084ccf3bb7SIan Rogers "no-overwrite", 17094ccf3bb7SIan Rogers "percore", 17104ccf3bb7SIan Rogers "aux-output", 17114ccf3bb7SIan Rogers "aux-sample-size=number", 17124ccf3bb7SIan Rogers }; 17134ccf3bb7SIan Rogers struct perf_pmu_format *format; 17144ccf3bb7SIan Rogers int ret; 17154ccf3bb7SIan Rogers 17164ccf3bb7SIan Rogers /* 17174ccf3bb7SIan Rogers * max-events and driver-config are missing above as are the internal 17184ccf3bb7SIan Rogers * types user, metric-id, raw, legacy cache and hardware. Assert against 17194ccf3bb7SIan Rogers * the enum parse_events__term_type so they are kept in sync. 17204ccf3bb7SIan Rogers */ 17214ccf3bb7SIan Rogers _Static_assert(ARRAY_SIZE(terms) == __PARSE_EVENTS__TERM_TYPE_NR - 6, 17224ccf3bb7SIan Rogers "perf_pmu__for_each_format()'s terms must be kept in sync with enum parse_events__term_type"); 17234ccf3bb7SIan Rogers list_for_each_entry(format, &pmu->format, list) { 17244ccf3bb7SIan Rogers perf_pmu_format__load(pmu, format); 17254ccf3bb7SIan Rogers ret = cb(state, format->name, (int)format->value, format->bits); 17264ccf3bb7SIan Rogers if (ret) 17274ccf3bb7SIan Rogers return ret; 17284ccf3bb7SIan Rogers } 17294ccf3bb7SIan Rogers if (!pmu->is_core) 17304ccf3bb7SIan Rogers return 0; 17314ccf3bb7SIan Rogers 17324ccf3bb7SIan Rogers for (size_t i = 0; i < ARRAY_SIZE(terms); i++) { 17334ccf3bb7SIan Rogers int config = PERF_PMU_FORMAT_VALUE_CONFIG; 17344ccf3bb7SIan Rogers 17354ccf3bb7SIan Rogers if (i < PERF_PMU_FORMAT_VALUE_CONFIG_END) 17364ccf3bb7SIan Rogers config = i; 17374ccf3bb7SIan Rogers 17384ccf3bb7SIan Rogers ret = cb(state, terms[i], config, /*bits=*/NULL); 17394ccf3bb7SIan Rogers if (ret) 17404ccf3bb7SIan Rogers return ret; 17414ccf3bb7SIan Rogers } 17424ccf3bb7SIan Rogers return 0; 17434ccf3bb7SIan Rogers } 17444ccf3bb7SIan Rogers 1745d504fae9SJohn Garry bool is_pmu_core(const char *name) 1746d504fae9SJohn Garry { 17476fbd67b0SThomas Richter return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name); 17484bf7e81aSIan Rogers } 17494bf7e81aSIan Rogers 17506fd1e519SIan Rogers bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu) 17516fd1e519SIan Rogers { 1752e20d1f2fSIan Rogers return pmu->is_core; 17536fd1e519SIan Rogers } 17546fd1e519SIan Rogers 175552c7b4d3SIan Rogers bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu) 175652c7b4d3SIan Rogers { 1757710dffc9SIan Rogers return !pmu->is_core || perf_pmus__num_core_pmus() == 1; 175852c7b4d3SIan Rogers } 175952c7b4d3SIan Rogers 1760e6ff1eedSIan Rogers bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name) 1761abe9544eSIan Rogers { 1762a24d9d9dSIan Rogers if (!name) 1763a24d9d9dSIan Rogers return false; 17648d4b6d37SIan Rogers if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL) 1765e6ff1eedSIan Rogers return true; 1766e6ff1eedSIan Rogers if (pmu->cpu_aliases_added || !pmu->events_table) 1767e6ff1eedSIan Rogers return false; 1768e6ff1eedSIan Rogers return pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0; 17694cabc3d1SAndi Kleen } 1770c3245d20SIan Rogers 1771e6ff1eedSIan Rogers size_t perf_pmu__num_events(struct perf_pmu *pmu) 1772c3245d20SIan Rogers { 17738d4b6d37SIan Rogers size_t nr; 17748d4b6d37SIan Rogers 17758d4b6d37SIan Rogers pmu_aliases_parse(pmu); 1776d9c5f5f9SIan Rogers nr = pmu->sysfs_aliases + pmu->sys_json_aliases;; 1777c3245d20SIan Rogers 1778e6ff1eedSIan Rogers if (pmu->cpu_aliases_added) 1779d9c5f5f9SIan Rogers nr += pmu->cpu_json_aliases; 1780e6ff1eedSIan Rogers else if (pmu->events_table) 1781d9c5f5f9SIan Rogers nr += pmu_events_table__num_events(pmu->events_table, pmu) - pmu->cpu_json_aliases; 1782d9c5f5f9SIan Rogers else 1783d9c5f5f9SIan Rogers assert(pmu->cpu_json_aliases == 0); 1784c3245d20SIan Rogers 1785c3245d20SIan Rogers return pmu->selectable ? nr + 1 : nr; 1786c3245d20SIan Rogers } 1787c3245d20SIan Rogers 1788c3245d20SIan Rogers static int sub_non_neg(int a, int b) 1789c3245d20SIan Rogers { 1790c3245d20SIan Rogers if (b > a) 1791c3245d20SIan Rogers return 0; 1792c3245d20SIan Rogers return a - b; 1793c3245d20SIan Rogers } 1794c3245d20SIan Rogers 1795c3245d20SIan Rogers static char *format_alias(char *buf, int len, const struct perf_pmu *pmu, 1796cd4e1efbSIan Rogers const struct perf_pmu_alias *alias, bool skip_duplicate_pmus) 1797c3245d20SIan Rogers { 1798c3245d20SIan Rogers struct parse_events_term *term; 17993241d46fSIan Rogers size_t pmu_name_len = skip_duplicate_pmus 18003241d46fSIan Rogers ? pmu_name_len_no_suffix(pmu->name) 18013241d46fSIan Rogers : strlen(pmu->name); 18023241d46fSIan Rogers int used = snprintf(buf, len, "%.*s/%s", (int)pmu_name_len, pmu->name, alias->name); 1803c3245d20SIan Rogers 18040d3f0e6fSIan Rogers list_for_each_entry(term, &alias->terms.terms, list) { 1805c3245d20SIan Rogers if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1806c3245d20SIan Rogers used += snprintf(buf + used, sub_non_neg(len, used), 1807c3245d20SIan Rogers ",%s=%s", term->config, 1808c3245d20SIan Rogers term->val.str); 1809c3245d20SIan Rogers } 1810c3245d20SIan Rogers 1811c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1812c3245d20SIan Rogers buf[used] = '/'; 1813c3245d20SIan Rogers used++; 1814c3245d20SIan Rogers } 1815c3245d20SIan Rogers if (sub_non_neg(len, used) > 0) { 1816c3245d20SIan Rogers buf[used] = '\0'; 1817c3245d20SIan Rogers used++; 1818c3245d20SIan Rogers } else 1819c3245d20SIan Rogers buf[len - 1] = '\0'; 1820c3245d20SIan Rogers 1821c3245d20SIan Rogers return buf; 1822c3245d20SIan Rogers } 1823c3245d20SIan Rogers 1824cd4e1efbSIan Rogers int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus, 1825cd4e1efbSIan Rogers void *state, pmu_event_callback cb) 1826c3245d20SIan Rogers { 1827c3245d20SIan Rogers char buf[1024]; 1828c3245d20SIan Rogers struct perf_pmu_alias *event; 1829c3245d20SIan Rogers struct pmu_event_info info = { 1830c3245d20SIan Rogers .pmu = pmu, 1831c3245d20SIan Rogers }; 1832c3245d20SIan Rogers int ret = 0; 183330f0b435SIan Rogers struct strbuf sb; 1834c3245d20SIan Rogers 183530f0b435SIan Rogers strbuf_init(&sb, /*hint=*/ 0); 18367b6dd7a9SIan Rogers pmu_aliases_parse(pmu); 1837e6ff1eedSIan Rogers pmu_add_cpu_aliases(pmu); 1838c3245d20SIan Rogers list_for_each_entry(event, &pmu->aliases, list) { 18393241d46fSIan Rogers size_t buf_used, pmu_name_len; 1840c3245d20SIan Rogers 1841c3245d20SIan Rogers info.pmu_name = event->pmu_name ?: pmu->name; 18424ccf3bb7SIan Rogers pmu_name_len = skip_duplicate_pmus 18433241d46fSIan Rogers ? pmu_name_len_no_suffix(info.pmu_name) 18443241d46fSIan Rogers : strlen(info.pmu_name); 1845c3245d20SIan Rogers info.alias = NULL; 1846c3245d20SIan Rogers if (event->desc) { 1847c3245d20SIan Rogers info.name = event->name; 1848c3245d20SIan Rogers buf_used = 0; 1849c3245d20SIan Rogers } else { 1850cd4e1efbSIan Rogers info.name = format_alias(buf, sizeof(buf), pmu, event, 1851cd4e1efbSIan Rogers skip_duplicate_pmus); 1852c3245d20SIan Rogers if (pmu->is_core) { 1853c3245d20SIan Rogers info.alias = info.name; 1854c3245d20SIan Rogers info.name = event->name; 1855c3245d20SIan Rogers } 1856c3245d20SIan Rogers buf_used = strlen(buf) + 1; 1857c3245d20SIan Rogers } 1858c3245d20SIan Rogers info.scale_unit = NULL; 1859c3245d20SIan Rogers if (strlen(event->unit) || event->scale != 1.0) { 1860c3245d20SIan Rogers info.scale_unit = buf + buf_used; 1861c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1862c3245d20SIan Rogers "%G%s", event->scale, event->unit) + 1; 1863c3245d20SIan Rogers } 1864c3245d20SIan Rogers info.desc = event->desc; 1865c3245d20SIan Rogers info.long_desc = event->long_desc; 1866c3245d20SIan Rogers info.encoding_desc = buf + buf_used; 18670d3f0e6fSIan Rogers parse_events_terms__to_strbuf(&event->terms, &sb); 1868c3245d20SIan Rogers buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 18693241d46fSIan Rogers "%.*s/%s/", (int)pmu_name_len, info.pmu_name, sb.buf) + 1; 1870c3245d20SIan Rogers info.topic = event->topic; 187130f0b435SIan Rogers info.str = sb.buf; 1872c3245d20SIan Rogers info.deprecated = event->deprecated; 1873c3245d20SIan Rogers ret = cb(state, &info); 1874c3245d20SIan Rogers if (ret) 187530f0b435SIan Rogers goto out; 187630f0b435SIan Rogers strbuf_setlen(&sb, /*len=*/ 0); 1877c3245d20SIan Rogers } 1878c3245d20SIan Rogers if (pmu->selectable) { 1879c3245d20SIan Rogers info.name = buf; 1880c3245d20SIan Rogers snprintf(buf, sizeof(buf), "%s//", pmu->name); 1881c3245d20SIan Rogers info.alias = NULL; 1882c3245d20SIan Rogers info.scale_unit = NULL; 1883c3245d20SIan Rogers info.desc = NULL; 1884c3245d20SIan Rogers info.long_desc = NULL; 1885c3245d20SIan Rogers info.encoding_desc = NULL; 1886c3245d20SIan Rogers info.topic = NULL; 1887c3245d20SIan Rogers info.pmu_name = pmu->name; 1888c3245d20SIan Rogers info.deprecated = false; 1889c3245d20SIan Rogers ret = cb(state, &info); 1890c3245d20SIan Rogers } 189130f0b435SIan Rogers out: 189230f0b435SIan Rogers strbuf_release(&sb); 1893c3245d20SIan Rogers return ret; 18944cabc3d1SAndi Kleen } 18957d4bdab5SAdrian Hunter 1896e3edd6cfSIan Rogers bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name) 1897e3edd6cfSIan Rogers { 1898e3edd6cfSIan Rogers return !strcmp(pmu->name, pmu_name) || 1899d2045f87SIan Rogers (pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)) || 1900d2045f87SIan Rogers /* 1901d2045f87SIan Rogers * jevents and tests use default_core as a marker for any core 1902d2045f87SIan Rogers * PMU as the PMU name varies across architectures. 1903d2045f87SIan Rogers */ 1904d2045f87SIan Rogers (pmu->is_core && !strcmp(pmu_name, "default_core")); 1905e3edd6cfSIan Rogers } 1906e3edd6cfSIan Rogers 1907251aa040SIan Rogers bool perf_pmu__is_software(const struct perf_pmu *pmu) 1908251aa040SIan Rogers { 190924852ef2SIan Rogers const char *known_sw_pmus[] = { 191024852ef2SIan Rogers "kprobe", 191124852ef2SIan Rogers "msr", 191224852ef2SIan Rogers "uprobe", 191324852ef2SIan Rogers }; 191424852ef2SIan Rogers 1915251aa040SIan Rogers if (pmu->is_core || pmu->is_uncore || pmu->auxtrace) 1916251aa040SIan Rogers return false; 1917251aa040SIan Rogers switch (pmu->type) { 1918251aa040SIan Rogers case PERF_TYPE_HARDWARE: return false; 1919251aa040SIan Rogers case PERF_TYPE_SOFTWARE: return true; 1920251aa040SIan Rogers case PERF_TYPE_TRACEPOINT: return true; 1921251aa040SIan Rogers case PERF_TYPE_HW_CACHE: return false; 1922251aa040SIan Rogers case PERF_TYPE_RAW: return false; 1923251aa040SIan Rogers case PERF_TYPE_BREAKPOINT: return true; 1924251aa040SIan Rogers default: break; 1925251aa040SIan Rogers } 192624852ef2SIan Rogers for (size_t i = 0; i < ARRAY_SIZE(known_sw_pmus); i++) { 192724852ef2SIan Rogers if (!strcmp(pmu->name, known_sw_pmus[i])) 192824852ef2SIan Rogers return true; 192924852ef2SIan Rogers } 193024852ef2SIan Rogers return false; 1931251aa040SIan Rogers } 1932251aa040SIan Rogers 19333a42f4c7SIan Rogers FILE *perf_pmu__open_file(const struct perf_pmu *pmu, const char *name) 19347d4bdab5SAdrian Hunter { 19357d4bdab5SAdrian Hunter char path[PATH_MAX]; 19367d4bdab5SAdrian Hunter 1937f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) || 1938f8ad6018SJames Clark !file_available(path)) 19397d4bdab5SAdrian Hunter return NULL; 19407d4bdab5SAdrian Hunter 19417d4bdab5SAdrian Hunter return fopen(path, "r"); 19427d4bdab5SAdrian Hunter } 19437d4bdab5SAdrian Hunter 19443a42f4c7SIan Rogers FILE *perf_pmu__open_file_at(const struct perf_pmu *pmu, int dirfd, const char *name) 19453a69672eSNamhyung Kim { 19463a69672eSNamhyung Kim int fd; 19473a69672eSNamhyung Kim 19483a69672eSNamhyung Kim fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY); 19493a69672eSNamhyung Kim if (fd < 0) 19503a69672eSNamhyung Kim return NULL; 19513a69672eSNamhyung Kim 19523a69672eSNamhyung Kim return fdopen(fd, "r"); 19533a69672eSNamhyung Kim } 19543a69672eSNamhyung Kim 19553a42f4c7SIan Rogers int perf_pmu__scan_file(const struct perf_pmu *pmu, const char *name, const char *fmt, 19567d4bdab5SAdrian Hunter ...) 19577d4bdab5SAdrian Hunter { 19587d4bdab5SAdrian Hunter va_list args; 19597d4bdab5SAdrian Hunter FILE *file; 19607d4bdab5SAdrian Hunter int ret = EOF; 19617d4bdab5SAdrian Hunter 19627d4bdab5SAdrian Hunter va_start(args, fmt); 19637d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 19647d4bdab5SAdrian Hunter if (file) { 19657d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 19667d4bdab5SAdrian Hunter fclose(file); 19677d4bdab5SAdrian Hunter } 19687d4bdab5SAdrian Hunter va_end(args); 19697d4bdab5SAdrian Hunter return ret; 19707d4bdab5SAdrian Hunter } 19719fbc61f8SKan Liang 19723a42f4c7SIan Rogers int perf_pmu__scan_file_at(const struct perf_pmu *pmu, int dirfd, const char *name, 19733a69672eSNamhyung Kim const char *fmt, ...) 19743a69672eSNamhyung Kim { 19753a69672eSNamhyung Kim va_list args; 19763a69672eSNamhyung Kim FILE *file; 19773a69672eSNamhyung Kim int ret = EOF; 19783a69672eSNamhyung Kim 19793a69672eSNamhyung Kim va_start(args, fmt); 19803a69672eSNamhyung Kim file = perf_pmu__open_file_at(pmu, dirfd, name); 19813a69672eSNamhyung Kim if (file) { 19823a69672eSNamhyung Kim ret = vfscanf(file, fmt, args); 19833a69672eSNamhyung Kim fclose(file); 19843a69672eSNamhyung Kim } 19853a69672eSNamhyung Kim va_end(args); 19863a69672eSNamhyung Kim return ret; 19873a69672eSNamhyung Kim } 19883a69672eSNamhyung Kim 19893a42f4c7SIan Rogers bool perf_pmu__file_exists(const struct perf_pmu *pmu, const char *name) 1990c2b6a896SGerman Gomez { 1991c2b6a896SGerman Gomez char path[PATH_MAX]; 1992c2b6a896SGerman Gomez 1993c2b6a896SGerman Gomez if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name)) 1994c2b6a896SGerman Gomez return false; 1995c2b6a896SGerman Gomez 1996c2b6a896SGerman Gomez return file_available(path); 1997c2b6a896SGerman Gomez } 1998c2b6a896SGerman Gomez 19999fbc61f8SKan Liang static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 20009fbc61f8SKan Liang { 20019fbc61f8SKan Liang struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 20029fbc61f8SKan Liang 20039fbc61f8SKan Liang if (!caps) 20049fbc61f8SKan Liang return -ENOMEM; 20059fbc61f8SKan Liang 20069fbc61f8SKan Liang caps->name = strdup(name); 20079fbc61f8SKan Liang if (!caps->name) 20089fbc61f8SKan Liang goto free_caps; 20099fbc61f8SKan Liang caps->value = strndup(value, strlen(value) - 1); 20109fbc61f8SKan Liang if (!caps->value) 20119fbc61f8SKan Liang goto free_name; 20129fbc61f8SKan Liang list_add_tail(&caps->list, list); 20139fbc61f8SKan Liang return 0; 20149fbc61f8SKan Liang 20159fbc61f8SKan Liang free_name: 201657f14b5aSArnaldo Carvalho de Melo zfree(&caps->name); 20179fbc61f8SKan Liang free_caps: 20189fbc61f8SKan Liang free(caps); 20199fbc61f8SKan Liang 20209fbc61f8SKan Liang return -ENOMEM; 20219fbc61f8SKan Liang } 20229fbc61f8SKan Liang 2023eec11310SNamhyung Kim static void perf_pmu__del_caps(struct perf_pmu *pmu) 2024eec11310SNamhyung Kim { 2025eec11310SNamhyung Kim struct perf_pmu_caps *caps, *tmp; 2026eec11310SNamhyung Kim 2027eec11310SNamhyung Kim list_for_each_entry_safe(caps, tmp, &pmu->caps, list) { 2028eec11310SNamhyung Kim list_del(&caps->list); 2029efe98a7aSArnaldo Carvalho de Melo zfree(&caps->name); 2030efe98a7aSArnaldo Carvalho de Melo zfree(&caps->value); 2031eec11310SNamhyung Kim free(caps); 2032eec11310SNamhyung Kim } 2033eec11310SNamhyung Kim } 2034eec11310SNamhyung Kim 20359fbc61f8SKan Liang /* 20369fbc61f8SKan Liang * Reading/parsing the given pmu capabilities, which should be located at: 20379fbc61f8SKan Liang * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 20389fbc61f8SKan Liang * Return the number of capabilities 20399fbc61f8SKan Liang */ 20409fbc61f8SKan Liang int perf_pmu__caps_parse(struct perf_pmu *pmu) 20419fbc61f8SKan Liang { 20429fbc61f8SKan Liang struct stat st; 20439fbc61f8SKan Liang char caps_path[PATH_MAX]; 20449fbc61f8SKan Liang DIR *caps_dir; 20459fbc61f8SKan Liang struct dirent *evt_ent; 2046b39094d3SNamhyung Kim int caps_fd; 20473339ec44SRavi Bangoria 20483339ec44SRavi Bangoria if (pmu->caps_initialized) 20493339ec44SRavi Bangoria return pmu->nr_caps; 20503339ec44SRavi Bangoria 20513339ec44SRavi Bangoria pmu->nr_caps = 0; 20529fbc61f8SKan Liang 2053f8ad6018SJames Clark if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps")) 20549fbc61f8SKan Liang return -1; 20559fbc61f8SKan Liang 20563339ec44SRavi Bangoria if (stat(caps_path, &st) < 0) { 20573339ec44SRavi Bangoria pmu->caps_initialized = true; 20589fbc61f8SKan Liang return 0; /* no error if caps does not exist */ 20593339ec44SRavi Bangoria } 20609fbc61f8SKan Liang 20619fbc61f8SKan Liang caps_dir = opendir(caps_path); 20629fbc61f8SKan Liang if (!caps_dir) 20639fbc61f8SKan Liang return -EINVAL; 20649fbc61f8SKan Liang 2065b39094d3SNamhyung Kim caps_fd = dirfd(caps_dir); 2066b39094d3SNamhyung Kim 20679fbc61f8SKan Liang while ((evt_ent = readdir(caps_dir)) != NULL) { 20689fbc61f8SKan Liang char *name = evt_ent->d_name; 20699fbc61f8SKan Liang char value[128]; 20709fbc61f8SKan Liang FILE *file; 2071b39094d3SNamhyung Kim int fd; 20729fbc61f8SKan Liang 20739fbc61f8SKan Liang if (!strcmp(name, ".") || !strcmp(name, "..")) 20749fbc61f8SKan Liang continue; 20759fbc61f8SKan Liang 2076b39094d3SNamhyung Kim fd = openat(caps_fd, name, O_RDONLY); 20770ea8920eSIan Rogers if (fd == -1) 20789fbc61f8SKan Liang continue; 20790ea8920eSIan Rogers file = fdopen(fd, "r"); 20800ea8920eSIan Rogers if (!file) { 20810ea8920eSIan Rogers close(fd); 20820ea8920eSIan Rogers continue; 20830ea8920eSIan Rogers } 20849fbc61f8SKan Liang 20859fbc61f8SKan Liang if (!fgets(value, sizeof(value), file) || 20869fbc61f8SKan Liang (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 20879fbc61f8SKan Liang fclose(file); 20889fbc61f8SKan Liang continue; 20899fbc61f8SKan Liang } 20909fbc61f8SKan Liang 20913339ec44SRavi Bangoria pmu->nr_caps++; 20929fbc61f8SKan Liang fclose(file); 20939fbc61f8SKan Liang } 20949fbc61f8SKan Liang 20959fbc61f8SKan Liang closedir(caps_dir); 20969fbc61f8SKan Liang 20973339ec44SRavi Bangoria pmu->caps_initialized = true; 20983339ec44SRavi Bangoria return pmu->nr_caps; 20999fbc61f8SKan Liang } 2100e4064776SJin Yao 2101b9f01032SIan Rogers static void perf_pmu__compute_config_masks(struct perf_pmu *pmu) 2102e4064776SJin Yao { 2103e4064776SJin Yao struct perf_pmu_format *format; 2104b9f01032SIan Rogers 2105b9f01032SIan Rogers if (pmu->config_masks_computed) 2106b9f01032SIan Rogers return; 2107e4064776SJin Yao 2108e4064776SJin Yao list_for_each_entry(format, &pmu->format, list) { 2109b9f01032SIan Rogers unsigned int i; 2110b9f01032SIan Rogers __u64 *mask; 2111b9f01032SIan Rogers 2112b9f01032SIan Rogers if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) 2113e4064776SJin Yao continue; 2114e4064776SJin Yao 2115b9f01032SIan Rogers pmu->config_masks_present = true; 2116b9f01032SIan Rogers mask = &pmu->config_masks[format->value]; 2117b9f01032SIan Rogers 2118e4064776SJin Yao for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 2119b9f01032SIan Rogers *mask |= 1ULL << i; 2120e4064776SJin Yao } 2121b9f01032SIan Rogers pmu->config_masks_computed = true; 2122b9f01032SIan Rogers } 2123b9f01032SIan Rogers 2124b9f01032SIan Rogers void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 2125b9f01032SIan Rogers const char *name, int config_num, 2126b9f01032SIan Rogers const char *config_name) 2127b9f01032SIan Rogers { 2128b9f01032SIan Rogers __u64 bits; 2129b9f01032SIan Rogers char buf[100]; 2130b9f01032SIan Rogers 2131b9f01032SIan Rogers perf_pmu__compute_config_masks(pmu); 2132e4064776SJin Yao 2133e4064776SJin Yao /* 2134e4064776SJin Yao * Kernel doesn't export any valid format bits. 2135e4064776SJin Yao */ 2136b9f01032SIan Rogers if (!pmu->config_masks_present) 2137e4064776SJin Yao return; 2138e4064776SJin Yao 2139b9f01032SIan Rogers bits = config & ~pmu->config_masks[config_num]; 2140e4064776SJin Yao if (bits == 0) 2141e4064776SJin Yao return; 2142e4064776SJin Yao 2143e4064776SJin Yao bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 2144e4064776SJin Yao 2145b9f01032SIan Rogers pr_warning("WARNING: event '%s' not valid (bits %s of %s " 2146e4064776SJin Yao "'%llx' not supported by kernel)!\n", 2147b9f01032SIan Rogers name ?: "N/A", buf, config_name, config); 2148e4064776SJin Yao } 2149c5a26ea4SJin Yao 2150f91fa2aeSIan Rogers bool perf_pmu__match(const struct perf_pmu *pmu, const char *tok) 2151c47a5599SJin Yao { 2152f91fa2aeSIan Rogers const char *name = pmu->name; 2153*3e0bf9fdSJames Clark bool need_fnmatch = strisglob(tok); 2154f91fa2aeSIan Rogers 2155f91fa2aeSIan Rogers if (!strncmp(tok, "uncore_", 7)) 2156f91fa2aeSIan Rogers tok += 7; 2157f91fa2aeSIan Rogers if (!strncmp(name, "uncore_", 7)) 2158f91fa2aeSIan Rogers name += 7; 2159f91fa2aeSIan Rogers 2160f91fa2aeSIan Rogers if (perf_pmu__match_ignoring_suffix(name, tok) || 2161f91fa2aeSIan Rogers (need_fnmatch && !fnmatch(tok, name, 0))) 2162f91fa2aeSIan Rogers return true; 2163f91fa2aeSIan Rogers 2164f91fa2aeSIan Rogers name = pmu->alias_name; 216513d60ba0SKan Liang if (!name) 2166f91fa2aeSIan Rogers return false; 216713d60ba0SKan Liang 2168f91fa2aeSIan Rogers if (!strncmp(name, "uncore_", 7)) 2169f91fa2aeSIan Rogers name += 7; 2170c47a5599SJin Yao 2171f91fa2aeSIan Rogers return perf_pmu__match_ignoring_suffix(name, tok) || 2172f91fa2aeSIan Rogers (need_fnmatch && !fnmatch(tok, name, 0)); 2173c47a5599SJin Yao } 21741d3351e6SJin Yao 2175acef233bSJing Zhang double __weak perf_pmu__cpu_slots_per_cycle(void) 2176acef233bSJing Zhang { 2177acef233bSJing Zhang return NAN; 2178acef233bSJing Zhang } 2179f8ad6018SJames Clark 2180f8ad6018SJames Clark int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size) 2181f8ad6018SJames Clark { 2182f8ad6018SJames Clark const char *sysfs = sysfs__mountpoint(); 2183f8ad6018SJames Clark 2184f8ad6018SJames Clark if (!sysfs) 2185f8ad6018SJames Clark return 0; 2186f8ad6018SJames Clark return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs); 2187f8ad6018SJames Clark } 2188f8ad6018SJames Clark 2189e293a5e8SNamhyung Kim int perf_pmu__event_source_devices_fd(void) 2190e293a5e8SNamhyung Kim { 2191e293a5e8SNamhyung Kim char path[PATH_MAX]; 2192e293a5e8SNamhyung Kim const char *sysfs = sysfs__mountpoint(); 2193e293a5e8SNamhyung Kim 2194e293a5e8SNamhyung Kim if (!sysfs) 2195e293a5e8SNamhyung Kim return -1; 2196e293a5e8SNamhyung Kim 2197e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs); 2198e293a5e8SNamhyung Kim return open(path, O_DIRECTORY); 2199e293a5e8SNamhyung Kim } 2200e293a5e8SNamhyung Kim 2201f8ad6018SJames Clark /* 2202f8ad6018SJames Clark * Fill 'buf' with the path to a file or folder in 'pmu_name' in 2203f8ad6018SJames Clark * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format" 2204f8ad6018SJames Clark * then pathname will be filled with 2205f8ad6018SJames Clark * "/sys/bus/event_source/devices/cs_etm/format" 2206f8ad6018SJames Clark * 2207e1a3aad3SIan Rogers * Return 0 if the sysfs mountpoint couldn't be found, if no characters were 2208e1a3aad3SIan Rogers * written or if the buffer size is exceeded. 2209f8ad6018SJames Clark */ 2210f8ad6018SJames Clark int perf_pmu__pathname_scnprintf(char *buf, size_t size, 2211f8ad6018SJames Clark const char *pmu_name, const char *filename) 2212f8ad6018SJames Clark { 2213e1a3aad3SIan Rogers size_t len; 2214f8ad6018SJames Clark 2215e1a3aad3SIan Rogers len = perf_pmu__event_source_devices_scnprintf(buf, size); 2216e1a3aad3SIan Rogers if (!len || (len + strlen(pmu_name) + strlen(filename) + 1) >= size) 2217f8ad6018SJames Clark return 0; 2218e1a3aad3SIan Rogers 2219e1a3aad3SIan Rogers return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename); 2220f8ad6018SJames Clark } 2221eec11310SNamhyung Kim 2222e293a5e8SNamhyung Kim int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags) 2223e293a5e8SNamhyung Kim { 2224e293a5e8SNamhyung Kim char path[PATH_MAX]; 2225e293a5e8SNamhyung Kim 2226e293a5e8SNamhyung Kim scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename); 2227e293a5e8SNamhyung Kim return openat(dirfd, path, flags); 2228e293a5e8SNamhyung Kim } 2229e293a5e8SNamhyung Kim 22301eaf496eSIan Rogers void perf_pmu__delete(struct perf_pmu *pmu) 2231eec11310SNamhyung Kim { 2232eec11310SNamhyung Kim perf_pmu__del_formats(&pmu->format); 2233eec11310SNamhyung Kim perf_pmu__del_aliases(pmu); 2234eec11310SNamhyung Kim perf_pmu__del_caps(pmu); 2235eec11310SNamhyung Kim 2236eec11310SNamhyung Kim perf_cpu_map__put(pmu->cpus); 2237eec11310SNamhyung Kim 2238efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->name); 2239efe98a7aSArnaldo Carvalho de Melo zfree(&pmu->alias_name); 2240b7823045SIan Rogers zfree(&pmu->id); 2241eec11310SNamhyung Kim free(pmu); 2242eec11310SNamhyung Kim } 224367ee8e71SIan Rogers 224467ee8e71SIan Rogers const char *perf_pmu__name_from_config(struct perf_pmu *pmu, u64 config) 224567ee8e71SIan Rogers { 224667ee8e71SIan Rogers struct perf_pmu_alias *event; 224767ee8e71SIan Rogers 224867ee8e71SIan Rogers if (!pmu) 224967ee8e71SIan Rogers return NULL; 225067ee8e71SIan Rogers 22517b6dd7a9SIan Rogers pmu_aliases_parse(pmu); 225267ee8e71SIan Rogers pmu_add_cpu_aliases(pmu); 225367ee8e71SIan Rogers list_for_each_entry(event, &pmu->aliases, list) { 225467ee8e71SIan Rogers struct perf_event_attr attr = {.config = 0,}; 225567ee8e71SIan Rogers int ret = perf_pmu__config(pmu, &attr, &event->terms, NULL); 225667ee8e71SIan Rogers 225767ee8e71SIan Rogers if (ret == 0 && config == attr.config) 225867ee8e71SIan Rogers return event->name; 225967ee8e71SIan Rogers } 226067ee8e71SIan Rogers return NULL; 226167ee8e71SIan Rogers } 2262