1cd82a32eSJiri Olsa #include <linux/list.h> 2c5de47f2SSukadev Bhattiprolu #include <linux/compiler.h> 3cd82a32eSJiri Olsa #include <sys/types.h> 4cd82a32eSJiri Olsa #include <unistd.h> 5cd82a32eSJiri Olsa #include <stdio.h> 6dc0a6202SAdrian Hunter #include <stdbool.h> 77d4bdab5SAdrian Hunter #include <stdarg.h> 8cd82a32eSJiri Olsa #include <dirent.h> 9cd0cfad7SBorislav Petkov #include <api/fs/fs.h> 10410136f5SStephane Eranian #include <locale.h> 11cd82a32eSJiri Olsa #include "util.h" 12cd82a32eSJiri Olsa #include "pmu.h" 13cd82a32eSJiri Olsa #include "parse-events.h" 147ae92e74SYan, Zheng #include "cpumap.h" 15933f82ffSSukadev Bhattiprolu #include "header.h" 16933f82ffSSukadev Bhattiprolu #include "pmu-events/pmu-events.h" 17cd82a32eSJiri Olsa 18ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 19ab1bf653SArnaldo Carvalho de Melo char *name; 20ab1bf653SArnaldo Carvalho de Melo int value; 21ab1bf653SArnaldo Carvalho de Melo DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 22ab1bf653SArnaldo Carvalho de Melo struct list_head list; 23ab1bf653SArnaldo Carvalho de Melo }; 24ab1bf653SArnaldo Carvalho de Melo 2550a9667cSRobert Richter #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" 2650a9667cSRobert Richter 27cd82a32eSJiri Olsa int perf_pmu_parse(struct list_head *list, char *name); 28cd82a32eSJiri Olsa extern FILE *perf_pmu_in; 29cd82a32eSJiri Olsa 30cd82a32eSJiri Olsa static LIST_HEAD(pmus); 31cd82a32eSJiri Olsa 32cd82a32eSJiri Olsa /* 33cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 34cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 35cd82a32eSJiri Olsa */ 36cff7f956SJiri Olsa int perf_pmu__format_parse(char *dir, struct list_head *head) 37cd82a32eSJiri Olsa { 38cd82a32eSJiri Olsa struct dirent *evt_ent; 39cd82a32eSJiri Olsa DIR *format_dir; 40cd82a32eSJiri Olsa int ret = 0; 41cd82a32eSJiri Olsa 42cd82a32eSJiri Olsa format_dir = opendir(dir); 43cd82a32eSJiri Olsa if (!format_dir) 44cd82a32eSJiri Olsa return -EINVAL; 45cd82a32eSJiri Olsa 46cd82a32eSJiri Olsa while (!ret && (evt_ent = readdir(format_dir))) { 47cd82a32eSJiri Olsa char path[PATH_MAX]; 48cd82a32eSJiri Olsa char *name = evt_ent->d_name; 49cd82a32eSJiri Olsa FILE *file; 50cd82a32eSJiri Olsa 51cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 52cd82a32eSJiri Olsa continue; 53cd82a32eSJiri Olsa 54cd82a32eSJiri Olsa snprintf(path, PATH_MAX, "%s/%s", dir, name); 55cd82a32eSJiri Olsa 56cd82a32eSJiri Olsa ret = -EINVAL; 57cd82a32eSJiri Olsa file = fopen(path, "r"); 58cd82a32eSJiri Olsa if (!file) 59cd82a32eSJiri Olsa break; 60cd82a32eSJiri Olsa 61cd82a32eSJiri Olsa perf_pmu_in = file; 62cd82a32eSJiri Olsa ret = perf_pmu_parse(head, name); 63cd82a32eSJiri Olsa fclose(file); 64cd82a32eSJiri Olsa } 65cd82a32eSJiri Olsa 66cd82a32eSJiri Olsa closedir(format_dir); 67cd82a32eSJiri Olsa return ret; 68cd82a32eSJiri Olsa } 69cd82a32eSJiri Olsa 70cd82a32eSJiri Olsa /* 71cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 72cd82a32eSJiri Olsa * located at: 73cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 74cd82a32eSJiri Olsa */ 75b6b96fb4SAdrian Hunter static int pmu_format(const char *name, struct list_head *format) 76cd82a32eSJiri Olsa { 77cd82a32eSJiri Olsa struct stat st; 78cd82a32eSJiri Olsa char path[PATH_MAX]; 79cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 80cd82a32eSJiri Olsa 81cd82a32eSJiri Olsa if (!sysfs) 82cd82a32eSJiri Olsa return -1; 83cd82a32eSJiri Olsa 84cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 8550a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 86cd82a32eSJiri Olsa 87cd82a32eSJiri Olsa if (stat(path, &st) < 0) 889bc8f9feSRobert Richter return 0; /* no error if format does not exist */ 89cd82a32eSJiri Olsa 90cff7f956SJiri Olsa if (perf_pmu__format_parse(path, format)) 91cd82a32eSJiri Olsa return -1; 92cd82a32eSJiri Olsa 93cd82a32eSJiri Olsa return 0; 94cd82a32eSJiri Olsa } 95cd82a32eSJiri Olsa 96410136f5SStephane Eranian static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 97410136f5SStephane Eranian { 98410136f5SStephane Eranian struct stat st; 99410136f5SStephane Eranian ssize_t sret; 100410136f5SStephane Eranian char scale[128]; 101410136f5SStephane Eranian int fd, ret = -1; 102410136f5SStephane Eranian char path[PATH_MAX]; 103ea8f75f9SJiri Olsa char *lc; 104410136f5SStephane Eranian 105410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 106410136f5SStephane Eranian 107410136f5SStephane Eranian fd = open(path, O_RDONLY); 108410136f5SStephane Eranian if (fd == -1) 109410136f5SStephane Eranian return -1; 110410136f5SStephane Eranian 111410136f5SStephane Eranian if (fstat(fd, &st) < 0) 112410136f5SStephane Eranian goto error; 113410136f5SStephane Eranian 114410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 115410136f5SStephane Eranian if (sret < 0) 116410136f5SStephane Eranian goto error; 117410136f5SStephane Eranian 1189ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 1199ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 1209ecae065SMadhavan Srinivasan else 121410136f5SStephane Eranian scale[sret] = '\0'; 1229ecae065SMadhavan Srinivasan 123410136f5SStephane Eranian /* 124410136f5SStephane Eranian * save current locale 125410136f5SStephane Eranian */ 126410136f5SStephane Eranian lc = setlocale(LC_NUMERIC, NULL); 127410136f5SStephane Eranian 128410136f5SStephane Eranian /* 129f9a5978aSJiri Olsa * The lc string may be allocated in static storage, 130f9a5978aSJiri Olsa * so get a dynamic copy to make it survive setlocale 131f9a5978aSJiri Olsa * call below. 132f9a5978aSJiri Olsa */ 133f9a5978aSJiri Olsa lc = strdup(lc); 134f9a5978aSJiri Olsa if (!lc) { 135f9a5978aSJiri Olsa ret = -ENOMEM; 136f9a5978aSJiri Olsa goto error; 137f9a5978aSJiri Olsa } 138f9a5978aSJiri Olsa 139f9a5978aSJiri Olsa /* 140410136f5SStephane Eranian * force to C locale to ensure kernel 141410136f5SStephane Eranian * scale string is converted correctly. 142410136f5SStephane Eranian * kernel uses default C locale. 143410136f5SStephane Eranian */ 144410136f5SStephane Eranian setlocale(LC_NUMERIC, "C"); 145410136f5SStephane Eranian 146410136f5SStephane Eranian alias->scale = strtod(scale, NULL); 147410136f5SStephane Eranian 148410136f5SStephane Eranian /* restore locale */ 149410136f5SStephane Eranian setlocale(LC_NUMERIC, lc); 150410136f5SStephane Eranian 151ea8f75f9SJiri Olsa free(lc); 152f9a5978aSJiri Olsa 153410136f5SStephane Eranian ret = 0; 154410136f5SStephane Eranian error: 155410136f5SStephane Eranian close(fd); 156410136f5SStephane Eranian return ret; 157410136f5SStephane Eranian } 158410136f5SStephane Eranian 159410136f5SStephane Eranian static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 160410136f5SStephane Eranian { 161410136f5SStephane Eranian char path[PATH_MAX]; 162410136f5SStephane Eranian ssize_t sret; 163410136f5SStephane Eranian int fd; 164410136f5SStephane Eranian 165410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 166410136f5SStephane Eranian 167410136f5SStephane Eranian fd = open(path, O_RDONLY); 168410136f5SStephane Eranian if (fd == -1) 169410136f5SStephane Eranian return -1; 170410136f5SStephane Eranian 171410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 172410136f5SStephane Eranian if (sret < 0) 173410136f5SStephane Eranian goto error; 174410136f5SStephane Eranian 175410136f5SStephane Eranian close(fd); 176410136f5SStephane Eranian 1779ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 1789ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 1799ecae065SMadhavan Srinivasan else 180410136f5SStephane Eranian alias->unit[sret] = '\0'; 181410136f5SStephane Eranian 182410136f5SStephane Eranian return 0; 183410136f5SStephane Eranian error: 184410136f5SStephane Eranian close(fd); 185410136f5SStephane Eranian alias->unit[0] = '\0'; 186410136f5SStephane Eranian return -1; 187410136f5SStephane Eranian } 188410136f5SStephane Eranian 189044330c1SMatt Fleming static int 190044330c1SMatt Fleming perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 191044330c1SMatt Fleming { 192044330c1SMatt Fleming char path[PATH_MAX]; 193044330c1SMatt Fleming int fd; 194044330c1SMatt Fleming 195044330c1SMatt Fleming snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 196044330c1SMatt Fleming 197044330c1SMatt Fleming fd = open(path, O_RDONLY); 198044330c1SMatt Fleming if (fd == -1) 199044330c1SMatt Fleming return -1; 200044330c1SMatt Fleming 201044330c1SMatt Fleming close(fd); 202044330c1SMatt Fleming 203044330c1SMatt Fleming alias->per_pkg = true; 204044330c1SMatt Fleming return 0; 205044330c1SMatt Fleming } 206044330c1SMatt Fleming 2071d9e446bSJiri Olsa static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 2081d9e446bSJiri Olsa char *dir, char *name) 2091d9e446bSJiri Olsa { 2101d9e446bSJiri Olsa char path[PATH_MAX]; 2111d9e446bSJiri Olsa int fd; 2121d9e446bSJiri Olsa 2131d9e446bSJiri Olsa snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 2141d9e446bSJiri Olsa 2151d9e446bSJiri Olsa fd = open(path, O_RDONLY); 2161d9e446bSJiri Olsa if (fd == -1) 2171d9e446bSJiri Olsa return -1; 2181d9e446bSJiri Olsa 2191d9e446bSJiri Olsa alias->snapshot = true; 2201d9e446bSJiri Olsa close(fd); 2211d9e446bSJiri Olsa return 0; 2221d9e446bSJiri Olsa } 2231d9e446bSJiri Olsa 22470c646e0SSukadev Bhattiprolu static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 22508e60ed1SAndi Kleen char *desc, char *val) 226a6146d50SZheng Yan { 2275c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 228a6146d50SZheng Yan int ret; 229a6146d50SZheng Yan 230a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 231a6146d50SZheng Yan if (!alias) 232a6146d50SZheng Yan return -ENOMEM; 233a6146d50SZheng Yan 234a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 235410136f5SStephane Eranian alias->scale = 1.0; 236410136f5SStephane Eranian alias->unit[0] = '\0'; 237044330c1SMatt Fleming alias->per_pkg = false; 23884530920SStephane Eranian alias->snapshot = false; 239410136f5SStephane Eranian 24070c646e0SSukadev Bhattiprolu ret = parse_events_terms(&alias->terms, val); 241a6146d50SZheng Yan if (ret) { 24270c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 243a6146d50SZheng Yan free(alias); 244a6146d50SZheng Yan return ret; 245a6146d50SZheng Yan } 246a6146d50SZheng Yan 247a6146d50SZheng Yan alias->name = strdup(name); 24870c646e0SSukadev Bhattiprolu if (dir) { 249410136f5SStephane Eranian /* 250410136f5SStephane Eranian * load unit name and scale if available 251410136f5SStephane Eranian */ 252410136f5SStephane Eranian perf_pmu__parse_unit(alias, dir, name); 253410136f5SStephane Eranian perf_pmu__parse_scale(alias, dir, name); 254044330c1SMatt Fleming perf_pmu__parse_per_pkg(alias, dir, name); 2551d9e446bSJiri Olsa perf_pmu__parse_snapshot(alias, dir, name); 25670c646e0SSukadev Bhattiprolu } 257410136f5SStephane Eranian 25808e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 25908e60ed1SAndi Kleen 260a6146d50SZheng Yan list_add_tail(&alias->list, list); 261410136f5SStephane Eranian 262a6146d50SZheng Yan return 0; 263a6146d50SZheng Yan } 264a6146d50SZheng Yan 26570c646e0SSukadev Bhattiprolu static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 26670c646e0SSukadev Bhattiprolu { 26770c646e0SSukadev Bhattiprolu char buf[256]; 26870c646e0SSukadev Bhattiprolu int ret; 26970c646e0SSukadev Bhattiprolu 27070c646e0SSukadev Bhattiprolu ret = fread(buf, 1, sizeof(buf), file); 27170c646e0SSukadev Bhattiprolu if (ret == 0) 27270c646e0SSukadev Bhattiprolu return -EINVAL; 27370c646e0SSukadev Bhattiprolu 27470c646e0SSukadev Bhattiprolu buf[ret] = 0; 27570c646e0SSukadev Bhattiprolu 27670c646e0SSukadev Bhattiprolu return __perf_pmu__new_alias(list, dir, name, NULL, buf); 27770c646e0SSukadev Bhattiprolu } 27870c646e0SSukadev Bhattiprolu 27946441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 28046441bdcSMatt Fleming { 28146441bdcSMatt Fleming size_t len; 28246441bdcSMatt Fleming 28346441bdcSMatt Fleming len = strlen(name); 28446441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 28546441bdcSMatt Fleming return true; 28646441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 28746441bdcSMatt Fleming return true; 288044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 289044330c1SMatt Fleming return true; 2901d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 2911d9e446bSJiri Olsa return true; 29246441bdcSMatt Fleming 29346441bdcSMatt Fleming return false; 29446441bdcSMatt Fleming } 29546441bdcSMatt Fleming 296a6146d50SZheng Yan /* 297a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 298a6146d50SZheng Yan * specified in 'dir' parameter. 299a6146d50SZheng Yan */ 300a6146d50SZheng Yan static int pmu_aliases_parse(char *dir, struct list_head *head) 301a6146d50SZheng Yan { 302a6146d50SZheng Yan struct dirent *evt_ent; 303a6146d50SZheng Yan DIR *event_dir; 304a6146d50SZheng Yan 305a6146d50SZheng Yan event_dir = opendir(dir); 306a6146d50SZheng Yan if (!event_dir) 307a6146d50SZheng Yan return -EINVAL; 308a6146d50SZheng Yan 309940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 310a6146d50SZheng Yan char path[PATH_MAX]; 311a6146d50SZheng Yan char *name = evt_ent->d_name; 312a6146d50SZheng Yan FILE *file; 313a6146d50SZheng Yan 314a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 315a6146d50SZheng Yan continue; 316a6146d50SZheng Yan 317410136f5SStephane Eranian /* 31846441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 319410136f5SStephane Eranian */ 32046441bdcSMatt Fleming if (pmu_alias_info_file(name)) 321410136f5SStephane Eranian continue; 322410136f5SStephane Eranian 323a6146d50SZheng Yan snprintf(path, PATH_MAX, "%s/%s", dir, name); 324a6146d50SZheng Yan 325a6146d50SZheng Yan file = fopen(path, "r"); 326940db6dcSAndi Kleen if (!file) { 327940db6dcSAndi Kleen pr_debug("Cannot open %s\n", path); 328940db6dcSAndi Kleen continue; 329940db6dcSAndi Kleen } 330410136f5SStephane Eranian 331940db6dcSAndi Kleen if (perf_pmu__new_alias(head, dir, name, file) < 0) 332940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 333a6146d50SZheng Yan fclose(file); 334a6146d50SZheng Yan } 335a6146d50SZheng Yan 336a6146d50SZheng Yan closedir(event_dir); 337940db6dcSAndi Kleen return 0; 338a6146d50SZheng Yan } 339a6146d50SZheng Yan 340a6146d50SZheng Yan /* 341a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 342a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 343a6146d50SZheng Yan */ 344b6b96fb4SAdrian Hunter static int pmu_aliases(const char *name, struct list_head *head) 345a6146d50SZheng Yan { 346a6146d50SZheng Yan struct stat st; 347a6146d50SZheng Yan char path[PATH_MAX]; 348cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 349a6146d50SZheng Yan 350a6146d50SZheng Yan if (!sysfs) 351a6146d50SZheng Yan return -1; 352a6146d50SZheng Yan 353a6146d50SZheng Yan snprintf(path, PATH_MAX, 354a6146d50SZheng Yan "%s/bus/event_source/devices/%s/events", sysfs, name); 355a6146d50SZheng Yan 356a6146d50SZheng Yan if (stat(path, &st) < 0) 3573fded963SJiri Olsa return 0; /* no error if 'events' does not exist */ 358a6146d50SZheng Yan 359a6146d50SZheng Yan if (pmu_aliases_parse(path, head)) 360a6146d50SZheng Yan return -1; 361a6146d50SZheng Yan 362a6146d50SZheng Yan return 0; 363a6146d50SZheng Yan } 364a6146d50SZheng Yan 3655c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 366a6146d50SZheng Yan struct list_head *terms) 367a6146d50SZheng Yan { 3687c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 369a6146d50SZheng Yan LIST_HEAD(list); 370a6146d50SZheng Yan int ret; 371a6146d50SZheng Yan 372a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 3737c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 374a6146d50SZheng Yan if (ret) { 375682dc24cSArnaldo Carvalho de Melo parse_events_terms__purge(&list); 376a6146d50SZheng Yan return ret; 377a6146d50SZheng Yan } 3787c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 379a6146d50SZheng Yan } 380a6146d50SZheng Yan list_splice(&list, terms); 381a6146d50SZheng Yan return 0; 382a6146d50SZheng Yan } 383a6146d50SZheng Yan 384cd82a32eSJiri Olsa /* 385cd82a32eSJiri Olsa * Reading/parsing the default pmu type value, which should be 386cd82a32eSJiri Olsa * located at: 387cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 388cd82a32eSJiri Olsa */ 389b6b96fb4SAdrian Hunter static int pmu_type(const char *name, __u32 *type) 390cd82a32eSJiri Olsa { 391cd82a32eSJiri Olsa struct stat st; 392cd82a32eSJiri Olsa char path[PATH_MAX]; 393cd82a32eSJiri Olsa FILE *file; 394cd82a32eSJiri Olsa int ret = 0; 395cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 396cd82a32eSJiri Olsa 397cd82a32eSJiri Olsa if (!sysfs) 398cd82a32eSJiri Olsa return -1; 399cd82a32eSJiri Olsa 400cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 40150a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 402cd82a32eSJiri Olsa 403cd82a32eSJiri Olsa if (stat(path, &st) < 0) 404cd82a32eSJiri Olsa return -1; 405cd82a32eSJiri Olsa 406cd82a32eSJiri Olsa file = fopen(path, "r"); 407cd82a32eSJiri Olsa if (!file) 408cd82a32eSJiri Olsa return -EINVAL; 409cd82a32eSJiri Olsa 410cd82a32eSJiri Olsa if (1 != fscanf(file, "%u", type)) 411cd82a32eSJiri Olsa ret = -1; 412cd82a32eSJiri Olsa 413cd82a32eSJiri Olsa fclose(file); 414cd82a32eSJiri Olsa return ret; 415cd82a32eSJiri Olsa } 416cd82a32eSJiri Olsa 41750a9667cSRobert Richter /* Add all pmus in sysfs to pmu list: */ 41850a9667cSRobert Richter static void pmu_read_sysfs(void) 41950a9667cSRobert Richter { 42050a9667cSRobert Richter char path[PATH_MAX]; 42150a9667cSRobert Richter DIR *dir; 42250a9667cSRobert Richter struct dirent *dent; 423cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 42450a9667cSRobert Richter 42550a9667cSRobert Richter if (!sysfs) 42650a9667cSRobert Richter return; 42750a9667cSRobert Richter 42850a9667cSRobert Richter snprintf(path, PATH_MAX, 42950a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 43050a9667cSRobert Richter 43150a9667cSRobert Richter dir = opendir(path); 43250a9667cSRobert Richter if (!dir) 43350a9667cSRobert Richter return; 43450a9667cSRobert Richter 43550a9667cSRobert Richter while ((dent = readdir(dir))) { 43650a9667cSRobert Richter if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 43750a9667cSRobert Richter continue; 43850a9667cSRobert Richter /* add to static LIST_HEAD(pmus): */ 43950a9667cSRobert Richter perf_pmu__find(dent->d_name); 44050a9667cSRobert Richter } 44150a9667cSRobert Richter 44250a9667cSRobert Richter closedir(dir); 44350a9667cSRobert Richter } 44450a9667cSRobert Richter 445b6b96fb4SAdrian Hunter static struct cpu_map *pmu_cpumask(const char *name) 4467ae92e74SYan, Zheng { 4477ae92e74SYan, Zheng struct stat st; 4487ae92e74SYan, Zheng char path[PATH_MAX]; 4497ae92e74SYan, Zheng FILE *file; 4507ae92e74SYan, Zheng struct cpu_map *cpus; 451cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 4527e3fcffeSMark Rutland const char *templates[] = { 4537e3fcffeSMark Rutland "%s/bus/event_source/devices/%s/cpumask", 4547e3fcffeSMark Rutland "%s/bus/event_source/devices/%s/cpus", 4557e3fcffeSMark Rutland NULL 4567e3fcffeSMark Rutland }; 4577e3fcffeSMark Rutland const char **template; 4587ae92e74SYan, Zheng 4597ae92e74SYan, Zheng if (!sysfs) 4607ae92e74SYan, Zheng return NULL; 4617ae92e74SYan, Zheng 4627e3fcffeSMark Rutland for (template = templates; *template; template++) { 4637e3fcffeSMark Rutland snprintf(path, PATH_MAX, *template, sysfs, name); 4647e3fcffeSMark Rutland if (stat(path, &st) == 0) 4657e3fcffeSMark Rutland break; 4667e3fcffeSMark Rutland } 4677ae92e74SYan, Zheng 4687e3fcffeSMark Rutland if (!*template) 4697ae92e74SYan, Zheng return NULL; 4707ae92e74SYan, Zheng 4717ae92e74SYan, Zheng file = fopen(path, "r"); 4727ae92e74SYan, Zheng if (!file) 4737ae92e74SYan, Zheng return NULL; 4747ae92e74SYan, Zheng 4757ae92e74SYan, Zheng cpus = cpu_map__read(file); 4767ae92e74SYan, Zheng fclose(file); 4777ae92e74SYan, Zheng return cpus; 4787ae92e74SYan, Zheng } 4797ae92e74SYan, Zheng 480933f82ffSSukadev Bhattiprolu /* 481933f82ffSSukadev Bhattiprolu * Return the CPU id as a raw string. 482933f82ffSSukadev Bhattiprolu * 483933f82ffSSukadev Bhattiprolu * Each architecture should provide a more precise id string that 484933f82ffSSukadev Bhattiprolu * can be use to match the architecture's "mapfile". 485933f82ffSSukadev Bhattiprolu */ 486933f82ffSSukadev Bhattiprolu char * __weak get_cpuid_str(void) 487933f82ffSSukadev Bhattiprolu { 488933f82ffSSukadev Bhattiprolu return NULL; 489933f82ffSSukadev Bhattiprolu } 490933f82ffSSukadev Bhattiprolu 491933f82ffSSukadev Bhattiprolu /* 492933f82ffSSukadev Bhattiprolu * From the pmu_events_map, find the table of PMU events that corresponds 493933f82ffSSukadev Bhattiprolu * to the current running CPU. Then, add all PMU events from that table 494933f82ffSSukadev Bhattiprolu * as aliases. 495933f82ffSSukadev Bhattiprolu */ 496933f82ffSSukadev Bhattiprolu static void pmu_add_cpu_aliases(struct list_head *head) 497933f82ffSSukadev Bhattiprolu { 498933f82ffSSukadev Bhattiprolu int i; 499933f82ffSSukadev Bhattiprolu struct pmu_events_map *map; 500933f82ffSSukadev Bhattiprolu struct pmu_event *pe; 501933f82ffSSukadev Bhattiprolu char *cpuid; 502933f82ffSSukadev Bhattiprolu 503933f82ffSSukadev Bhattiprolu cpuid = get_cpuid_str(); 504933f82ffSSukadev Bhattiprolu if (!cpuid) 505933f82ffSSukadev Bhattiprolu return; 506933f82ffSSukadev Bhattiprolu 507933f82ffSSukadev Bhattiprolu i = 0; 508933f82ffSSukadev Bhattiprolu while (1) { 509933f82ffSSukadev Bhattiprolu map = &pmu_events_map[i++]; 510933f82ffSSukadev Bhattiprolu if (!map->table) 511933f82ffSSukadev Bhattiprolu goto out; 512933f82ffSSukadev Bhattiprolu 513933f82ffSSukadev Bhattiprolu if (!strcmp(map->cpuid, cpuid)) 514933f82ffSSukadev Bhattiprolu break; 515933f82ffSSukadev Bhattiprolu } 516933f82ffSSukadev Bhattiprolu 517933f82ffSSukadev Bhattiprolu /* 518933f82ffSSukadev Bhattiprolu * Found a matching PMU events table. Create aliases 519933f82ffSSukadev Bhattiprolu */ 520933f82ffSSukadev Bhattiprolu i = 0; 521933f82ffSSukadev Bhattiprolu while (1) { 522933f82ffSSukadev Bhattiprolu pe = &map->table[i++]; 523933f82ffSSukadev Bhattiprolu if (!pe->name) 524933f82ffSSukadev Bhattiprolu break; 525933f82ffSSukadev Bhattiprolu 526933f82ffSSukadev Bhattiprolu /* need type casts to override 'const' */ 527933f82ffSSukadev Bhattiprolu __perf_pmu__new_alias(head, NULL, (char *)pe->name, 528933f82ffSSukadev Bhattiprolu (char *)pe->desc, (char *)pe->event); 529933f82ffSSukadev Bhattiprolu } 530933f82ffSSukadev Bhattiprolu 531933f82ffSSukadev Bhattiprolu out: 532933f82ffSSukadev Bhattiprolu free(cpuid); 533933f82ffSSukadev Bhattiprolu } 534933f82ffSSukadev Bhattiprolu 535c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 536dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 537dc0a6202SAdrian Hunter { 538dc0a6202SAdrian Hunter return NULL; 539dc0a6202SAdrian Hunter } 540dc0a6202SAdrian Hunter 541b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_lookup(const char *name) 542cd82a32eSJiri Olsa { 543cd82a32eSJiri Olsa struct perf_pmu *pmu; 544cd82a32eSJiri Olsa LIST_HEAD(format); 545a6146d50SZheng Yan LIST_HEAD(aliases); 546cd82a32eSJiri Olsa __u32 type; 547cd82a32eSJiri Olsa 548cd82a32eSJiri Olsa /* 549cd82a32eSJiri Olsa * The pmu data we store & need consists of the pmu 550cd82a32eSJiri Olsa * type value and format definitions. Load both right 551cd82a32eSJiri Olsa * now. 552cd82a32eSJiri Olsa */ 553cd82a32eSJiri Olsa if (pmu_format(name, &format)) 554cd82a32eSJiri Olsa return NULL; 555cd82a32eSJiri Olsa 5563fded963SJiri Olsa if (pmu_aliases(name, &aliases)) 5573fded963SJiri Olsa return NULL; 5583fded963SJiri Olsa 559933f82ffSSukadev Bhattiprolu if (!strcmp(name, "cpu")) 560933f82ffSSukadev Bhattiprolu pmu_add_cpu_aliases(&aliases); 561933f82ffSSukadev Bhattiprolu 562cd82a32eSJiri Olsa if (pmu_type(name, &type)) 563cd82a32eSJiri Olsa return NULL; 564cd82a32eSJiri Olsa 565cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 566cd82a32eSJiri Olsa if (!pmu) 567cd82a32eSJiri Olsa return NULL; 568cd82a32eSJiri Olsa 5697ae92e74SYan, Zheng pmu->cpus = pmu_cpumask(name); 5707ae92e74SYan, Zheng 571cd82a32eSJiri Olsa INIT_LIST_HEAD(&pmu->format); 572a6146d50SZheng Yan INIT_LIST_HEAD(&pmu->aliases); 573cd82a32eSJiri Olsa list_splice(&format, &pmu->format); 574a6146d50SZheng Yan list_splice(&aliases, &pmu->aliases); 575cd82a32eSJiri Olsa pmu->name = strdup(name); 576cd82a32eSJiri Olsa pmu->type = type; 5779bc8f9feSRobert Richter list_add_tail(&pmu->list, &pmus); 578dc0a6202SAdrian Hunter 579dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 580dc0a6202SAdrian Hunter 581cd82a32eSJiri Olsa return pmu; 582cd82a32eSJiri Olsa } 583cd82a32eSJiri Olsa 584b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_find(const char *name) 585cd82a32eSJiri Olsa { 586cd82a32eSJiri Olsa struct perf_pmu *pmu; 587cd82a32eSJiri Olsa 588cd82a32eSJiri Olsa list_for_each_entry(pmu, &pmus, list) 589cd82a32eSJiri Olsa if (!strcmp(pmu->name, name)) 590cd82a32eSJiri Olsa return pmu; 591cd82a32eSJiri Olsa 592cd82a32eSJiri Olsa return NULL; 593cd82a32eSJiri Olsa } 594cd82a32eSJiri Olsa 59550a9667cSRobert Richter struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 59650a9667cSRobert Richter { 59750a9667cSRobert Richter /* 59850a9667cSRobert Richter * pmu iterator: If pmu is NULL, we start at the begin, 59950a9667cSRobert Richter * otherwise return the next pmu. Returns NULL on end. 60050a9667cSRobert Richter */ 60150a9667cSRobert Richter if (!pmu) { 60250a9667cSRobert Richter pmu_read_sysfs(); 60350a9667cSRobert Richter pmu = list_prepare_entry(pmu, &pmus, list); 60450a9667cSRobert Richter } 60550a9667cSRobert Richter list_for_each_entry_continue(pmu, &pmus, list) 60650a9667cSRobert Richter return pmu; 60750a9667cSRobert Richter return NULL; 60850a9667cSRobert Richter } 60950a9667cSRobert Richter 610b6b96fb4SAdrian Hunter struct perf_pmu *perf_pmu__find(const char *name) 611cd82a32eSJiri Olsa { 612cd82a32eSJiri Olsa struct perf_pmu *pmu; 613cd82a32eSJiri Olsa 614cd82a32eSJiri Olsa /* 615cd82a32eSJiri Olsa * Once PMU is loaded it stays in the list, 616cd82a32eSJiri Olsa * so we keep us from multiple reading/parsing 617cd82a32eSJiri Olsa * the pmu format definitions. 618cd82a32eSJiri Olsa */ 619cd82a32eSJiri Olsa pmu = pmu_find(name); 620cd82a32eSJiri Olsa if (pmu) 621cd82a32eSJiri Olsa return pmu; 622cd82a32eSJiri Olsa 623cd82a32eSJiri Olsa return pmu_lookup(name); 624cd82a32eSJiri Olsa } 625cd82a32eSJiri Olsa 6265c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 62709ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 628cd82a32eSJiri Olsa { 6295c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 630cd82a32eSJiri Olsa 631cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 632cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 633cd82a32eSJiri Olsa return format; 634cd82a32eSJiri Olsa 635cd82a32eSJiri Olsa return NULL; 636cd82a32eSJiri Olsa } 637cd82a32eSJiri Olsa 63809ff6071SAdrian Hunter __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 63909ff6071SAdrian Hunter { 64009ff6071SAdrian Hunter struct perf_pmu_format *format = pmu_find_format(formats, name); 64109ff6071SAdrian Hunter __u64 bits = 0; 64209ff6071SAdrian Hunter int fbit; 64309ff6071SAdrian Hunter 64409ff6071SAdrian Hunter if (!format) 64509ff6071SAdrian Hunter return 0; 64609ff6071SAdrian Hunter 64709ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 64809ff6071SAdrian Hunter bits |= 1ULL << fbit; 64909ff6071SAdrian Hunter 65009ff6071SAdrian Hunter return bits; 65109ff6071SAdrian Hunter } 65209ff6071SAdrian Hunter 653cd82a32eSJiri Olsa /* 654dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 655cd82a32eSJiri Olsa * and unformated value (value parameter). 656cd82a32eSJiri Olsa */ 657dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 658dc0a6202SAdrian Hunter bool zero) 659cd82a32eSJiri Olsa { 660cd82a32eSJiri Olsa unsigned long fbit, vbit; 661cd82a32eSJiri Olsa 662cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 663cd82a32eSJiri Olsa 664cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 665cd82a32eSJiri Olsa continue; 666cd82a32eSJiri Olsa 667dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 668dc0a6202SAdrian Hunter *v |= (1llu << fbit); 669dc0a6202SAdrian Hunter else if (zero) 670dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 671cd82a32eSJiri Olsa } 672cd82a32eSJiri Olsa } 673cd82a32eSJiri Olsa 6740efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 6750efe6b67SAdrian Hunter { 676ac0e2cd5SKan Liang __u64 w = 0; 677ac0e2cd5SKan Liang int fbit; 6780efe6b67SAdrian Hunter 679ac0e2cd5SKan Liang for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS) 680ac0e2cd5SKan Liang w |= (1ULL << fbit); 681ac0e2cd5SKan Liang 682ac0e2cd5SKan Liang return w; 6830efe6b67SAdrian Hunter } 6840efe6b67SAdrian Hunter 685cd82a32eSJiri Olsa /* 686688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 687688d4dfcSCody P Schafer * in the remaining terms. 688688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 689688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 690688d4dfcSCody P Schafer * in a config string) later on in the term list. 691688d4dfcSCody P Schafer */ 692688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 693688d4dfcSCody P Schafer struct list_head *head_terms, 694688d4dfcSCody P Schafer __u64 *value) 695688d4dfcSCody P Schafer { 696688d4dfcSCody P Schafer struct parse_events_term *t; 697688d4dfcSCody P Schafer 698688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 699688d4dfcSCody P Schafer if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 700688d4dfcSCody P Schafer if (!strcmp(t->config, term->config)) { 701688d4dfcSCody P Schafer t->used = true; 702688d4dfcSCody P Schafer *value = t->val.num; 703688d4dfcSCody P Schafer return 0; 704688d4dfcSCody P Schafer } 705688d4dfcSCody P Schafer } 706688d4dfcSCody P Schafer } 707688d4dfcSCody P Schafer 708688d4dfcSCody P Schafer if (verbose) 709688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 710688d4dfcSCody P Schafer 711688d4dfcSCody P Schafer return -1; 712688d4dfcSCody P Schafer } 713688d4dfcSCody P Schafer 714ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 715e64b020bSJiri Olsa { 716e64b020bSJiri Olsa struct perf_pmu_format *format; 71711db4e29SMasami Hiramatsu char *str = NULL; 71811db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 719e64b020bSJiri Olsa unsigned i = 0; 720e64b020bSJiri Olsa 721ffeb883eSHe Kuang if (!formats) 722e64b020bSJiri Olsa return NULL; 723e64b020bSJiri Olsa 724e64b020bSJiri Olsa /* sysfs exported terms */ 725ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 72611db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 72711db4e29SMasami Hiramatsu goto error; 728e64b020bSJiri Olsa 729ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 73011db4e29SMasami Hiramatsu error: 731ffeb883eSHe Kuang strbuf_release(&buf); 732e64b020bSJiri Olsa 733e64b020bSJiri Olsa return str; 734e64b020bSJiri Olsa } 735e64b020bSJiri Olsa 736688d4dfcSCody P Schafer /* 737cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 73888aca8d9SCody P Schafer * user input data - term parameter. 739cd82a32eSJiri Olsa */ 740cd82a32eSJiri Olsa static int pmu_config_term(struct list_head *formats, 741cd82a32eSJiri Olsa struct perf_event_attr *attr, 742dc0a6202SAdrian Hunter struct parse_events_term *term, 743688d4dfcSCody P Schafer struct list_head *head_terms, 744e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 745cd82a32eSJiri Olsa { 7465c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 747cd82a32eSJiri Olsa __u64 *vp; 7480efe6b67SAdrian Hunter __u64 val, max_val; 749cd82a32eSJiri Olsa 750cd82a32eSJiri Olsa /* 751688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 752688d4dfcSCody P Schafer * skip it in normal eval. 753688d4dfcSCody P Schafer */ 754688d4dfcSCody P Schafer if (term->used) 755688d4dfcSCody P Schafer return 0; 756688d4dfcSCody P Schafer 757688d4dfcSCody P Schafer /* 758cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 759cd82a32eSJiri Olsa * to be done for them. 760cd82a32eSJiri Olsa */ 761cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 762cd82a32eSJiri Olsa return 0; 763cd82a32eSJiri Olsa 764cd82a32eSJiri Olsa format = pmu_find_format(formats, term->config); 765688d4dfcSCody P Schafer if (!format) { 766688d4dfcSCody P Schafer if (verbose) 767688d4dfcSCody P Schafer printf("Invalid event/parameter '%s'\n", term->config); 768e64b020bSJiri Olsa if (err) { 769ffeb883eSHe Kuang char *pmu_term = pmu_formats_string(formats); 770ffeb883eSHe Kuang 771e64b020bSJiri Olsa err->idx = term->err_term; 772e64b020bSJiri Olsa err->str = strdup("unknown term"); 773ffeb883eSHe Kuang err->help = parse_events_formats_error_string(pmu_term); 774ffeb883eSHe Kuang free(pmu_term); 775e64b020bSJiri Olsa } 776cd82a32eSJiri Olsa return -EINVAL; 777688d4dfcSCody P Schafer } 778cd82a32eSJiri Olsa 779cd82a32eSJiri Olsa switch (format->value) { 780cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 781cd82a32eSJiri Olsa vp = &attr->config; 782cd82a32eSJiri Olsa break; 783cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 784cd82a32eSJiri Olsa vp = &attr->config1; 785cd82a32eSJiri Olsa break; 786cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 787cd82a32eSJiri Olsa vp = &attr->config2; 788cd82a32eSJiri Olsa break; 789cd82a32eSJiri Olsa default: 790cd82a32eSJiri Olsa return -EINVAL; 791cd82a32eSJiri Olsa } 792cd82a32eSJiri Olsa 79316fa7e82SJiri Olsa /* 794688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 795688d4dfcSCody P Schafer * using event parameters. 79616fa7e82SJiri Olsa */ 797688d4dfcSCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 798688d4dfcSCody P Schafer val = term->val.num; 799688d4dfcSCody P Schafer else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 800688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 801e64b020bSJiri Olsa if (verbose) { 802688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 803688d4dfcSCody P Schafer term->config, term->val.str); 804e64b020bSJiri Olsa } 805e64b020bSJiri Olsa if (err) { 806e64b020bSJiri Olsa err->idx = term->err_val; 807e64b020bSJiri Olsa err->str = strdup("expected numeric value"); 808e64b020bSJiri Olsa } 809688d4dfcSCody P Schafer return -EINVAL; 810688d4dfcSCody P Schafer } 811688d4dfcSCody P Schafer 812688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 813688d4dfcSCody P Schafer return -EINVAL; 814688d4dfcSCody P Schafer } else 815688d4dfcSCody P Schafer return -EINVAL; 816688d4dfcSCody P Schafer 8170efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 8180efe6b67SAdrian Hunter if (val > max_val) { 8190efe6b67SAdrian Hunter if (err) { 8200efe6b67SAdrian Hunter err->idx = term->err_val; 8210efe6b67SAdrian Hunter if (asprintf(&err->str, 8220efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 8230efe6b67SAdrian Hunter (unsigned long long)max_val) < 0) 8240efe6b67SAdrian Hunter err->str = strdup("value too big for format"); 8250efe6b67SAdrian Hunter return -EINVAL; 8260efe6b67SAdrian Hunter } 8270efe6b67SAdrian Hunter /* 8280efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 8290efe6b67SAdrian Hunter * silently truncated. 8300efe6b67SAdrian Hunter */ 8310efe6b67SAdrian Hunter } 8320efe6b67SAdrian Hunter 833688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 834cd82a32eSJiri Olsa return 0; 835cd82a32eSJiri Olsa } 836cd82a32eSJiri Olsa 837cff7f956SJiri Olsa int perf_pmu__config_terms(struct list_head *formats, 838cff7f956SJiri Olsa struct perf_event_attr *attr, 839dc0a6202SAdrian Hunter struct list_head *head_terms, 840e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 841cd82a32eSJiri Olsa { 8426cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 843cd82a32eSJiri Olsa 844688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 845e64b020bSJiri Olsa if (pmu_config_term(formats, attr, term, head_terms, 846e64b020bSJiri Olsa zero, err)) 847cd82a32eSJiri Olsa return -EINVAL; 848688d4dfcSCody P Schafer } 849cd82a32eSJiri Olsa 850cd82a32eSJiri Olsa return 0; 851cd82a32eSJiri Olsa } 852cd82a32eSJiri Olsa 853cd82a32eSJiri Olsa /* 854cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 855cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 856cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 857cd82a32eSJiri Olsa */ 858cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 859e64b020bSJiri Olsa struct list_head *head_terms, 860e64b020bSJiri Olsa struct parse_events_error *err) 861cd82a32eSJiri Olsa { 862dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 863dc0a6202SAdrian Hunter 864cd82a32eSJiri Olsa attr->type = pmu->type; 865e64b020bSJiri Olsa return perf_pmu__config_terms(&pmu->format, attr, head_terms, 866e64b020bSJiri Olsa zero, err); 867cd82a32eSJiri Olsa } 868cd82a32eSJiri Olsa 8695c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 8706cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 871a6146d50SZheng Yan { 8725c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 873a6146d50SZheng Yan char *name; 874a6146d50SZheng Yan 875a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 876a6146d50SZheng Yan return NULL; 877a6146d50SZheng Yan 878a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 879a6146d50SZheng Yan if (term->val.num != 1) 880a6146d50SZheng Yan return NULL; 881a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 882a6146d50SZheng Yan return NULL; 883a6146d50SZheng Yan name = term->config; 884a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 885a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 886a6146d50SZheng Yan return NULL; 887a6146d50SZheng Yan name = term->val.str; 888a6146d50SZheng Yan } else { 889a6146d50SZheng Yan return NULL; 890a6146d50SZheng Yan } 891a6146d50SZheng Yan 892a6146d50SZheng Yan list_for_each_entry(alias, &pmu->aliases, list) { 893a6146d50SZheng Yan if (!strcasecmp(alias->name, name)) 894a6146d50SZheng Yan return alias; 895a6146d50SZheng Yan } 896a6146d50SZheng Yan return NULL; 897a6146d50SZheng Yan } 898a6146d50SZheng Yan 899410136f5SStephane Eranian 9001d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 9011d9e446bSJiri Olsa struct perf_pmu_info *info) 902410136f5SStephane Eranian { 903410136f5SStephane Eranian /* 904410136f5SStephane Eranian * Only one term in event definition can 9051d9e446bSJiri Olsa * define unit, scale and snapshot, fail 9061d9e446bSJiri Olsa * if there's more than one. 907410136f5SStephane Eranian */ 9081d9e446bSJiri Olsa if ((info->unit && alias->unit) || 9091d9e446bSJiri Olsa (info->scale && alias->scale) || 9101d9e446bSJiri Olsa (info->snapshot && alias->snapshot)) 911410136f5SStephane Eranian return -EINVAL; 912410136f5SStephane Eranian 913410136f5SStephane Eranian if (alias->unit) 9141d9e446bSJiri Olsa info->unit = alias->unit; 915410136f5SStephane Eranian 916410136f5SStephane Eranian if (alias->scale) 9171d9e446bSJiri Olsa info->scale = alias->scale; 9181d9e446bSJiri Olsa 9191d9e446bSJiri Olsa if (alias->snapshot) 9201d9e446bSJiri Olsa info->snapshot = alias->snapshot; 921410136f5SStephane Eranian 922410136f5SStephane Eranian return 0; 923410136f5SStephane Eranian } 924410136f5SStephane Eranian 925a6146d50SZheng Yan /* 926a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 927a6146d50SZheng Yan * defined for the alias 928a6146d50SZheng Yan */ 929410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 93046441bdcSMatt Fleming struct perf_pmu_info *info) 931a6146d50SZheng Yan { 9326cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 9335c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 934a6146d50SZheng Yan int ret; 935a6146d50SZheng Yan 936044330c1SMatt Fleming info->per_pkg = false; 937044330c1SMatt Fleming 9388a398897SStephane Eranian /* 9398a398897SStephane Eranian * Mark unit and scale as not set 9408a398897SStephane Eranian * (different from default values, see below) 9418a398897SStephane Eranian */ 94246441bdcSMatt Fleming info->unit = NULL; 94346441bdcSMatt Fleming info->scale = 0.0; 9441d9e446bSJiri Olsa info->snapshot = false; 945410136f5SStephane Eranian 946a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 947a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 948a6146d50SZheng Yan if (!alias) 949a6146d50SZheng Yan continue; 950a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 951a6146d50SZheng Yan if (ret) 952a6146d50SZheng Yan return ret; 953410136f5SStephane Eranian 9541d9e446bSJiri Olsa ret = check_info_data(alias, info); 955410136f5SStephane Eranian if (ret) 956410136f5SStephane Eranian return ret; 957410136f5SStephane Eranian 958044330c1SMatt Fleming if (alias->per_pkg) 959044330c1SMatt Fleming info->per_pkg = true; 960044330c1SMatt Fleming 961a6146d50SZheng Yan list_del(&term->list); 962a6146d50SZheng Yan free(term); 963a6146d50SZheng Yan } 9648a398897SStephane Eranian 9658a398897SStephane Eranian /* 9668a398897SStephane Eranian * if no unit or scale foundin aliases, then 9678a398897SStephane Eranian * set defaults as for evsel 9688a398897SStephane Eranian * unit cannot left to NULL 9698a398897SStephane Eranian */ 97046441bdcSMatt Fleming if (info->unit == NULL) 97146441bdcSMatt Fleming info->unit = ""; 9728a398897SStephane Eranian 97346441bdcSMatt Fleming if (info->scale == 0.0) 97446441bdcSMatt Fleming info->scale = 1.0; 9758a398897SStephane Eranian 976a6146d50SZheng Yan return 0; 977a6146d50SZheng Yan } 978a6146d50SZheng Yan 979cd82a32eSJiri Olsa int perf_pmu__new_format(struct list_head *list, char *name, 980cd82a32eSJiri Olsa int config, unsigned long *bits) 981cd82a32eSJiri Olsa { 9825c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 983cd82a32eSJiri Olsa 984cd82a32eSJiri Olsa format = zalloc(sizeof(*format)); 985cd82a32eSJiri Olsa if (!format) 986cd82a32eSJiri Olsa return -ENOMEM; 987cd82a32eSJiri Olsa 988cd82a32eSJiri Olsa format->name = strdup(name); 989cd82a32eSJiri Olsa format->value = config; 990cd82a32eSJiri Olsa memcpy(format->bits, bits, sizeof(format->bits)); 991cd82a32eSJiri Olsa 992cd82a32eSJiri Olsa list_add_tail(&format->list, list); 993cd82a32eSJiri Olsa return 0; 994cd82a32eSJiri Olsa } 995cd82a32eSJiri Olsa 996cd82a32eSJiri Olsa void perf_pmu__set_format(unsigned long *bits, long from, long to) 997cd82a32eSJiri Olsa { 998cd82a32eSJiri Olsa long b; 999cd82a32eSJiri Olsa 1000cd82a32eSJiri Olsa if (!to) 1001cd82a32eSJiri Olsa to = from; 1002cd82a32eSJiri Olsa 100315268138SSukadev Bhattiprolu memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 1004cd82a32eSJiri Olsa for (b = from; b <= to; b++) 1005cd82a32eSJiri Olsa set_bit(b, bits); 1006cd82a32eSJiri Olsa } 1007dc098b35SAndi Kleen 1008aaea3617SCody P Schafer static int sub_non_neg(int a, int b) 1009aaea3617SCody P Schafer { 1010aaea3617SCody P Schafer if (b > a) 1011aaea3617SCody P Schafer return 0; 1012aaea3617SCody P Schafer return a - b; 1013aaea3617SCody P Schafer } 1014aaea3617SCody P Schafer 1015dc098b35SAndi Kleen static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 1016dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1017dc098b35SAndi Kleen { 1018aaea3617SCody P Schafer struct parse_events_term *term; 1019aaea3617SCody P Schafer int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1020aaea3617SCody P Schafer 1021aaea3617SCody P Schafer list_for_each_entry(term, &alias->terms, list) { 1022aaea3617SCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1023aaea3617SCody P Schafer used += snprintf(buf + used, sub_non_neg(len, used), 1024aaea3617SCody P Schafer ",%s=%s", term->config, 1025aaea3617SCody P Schafer term->val.str); 1026aaea3617SCody P Schafer } 1027aaea3617SCody P Schafer 1028aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1029aaea3617SCody P Schafer buf[used] = '/'; 1030aaea3617SCody P Schafer used++; 1031aaea3617SCody P Schafer } 1032aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1033aaea3617SCody P Schafer buf[used] = '\0'; 1034aaea3617SCody P Schafer used++; 1035aaea3617SCody P Schafer } else 1036aaea3617SCody P Schafer buf[len - 1] = '\0'; 1037aaea3617SCody P Schafer 1038dc098b35SAndi Kleen return buf; 1039dc098b35SAndi Kleen } 1040dc098b35SAndi Kleen 1041dc098b35SAndi Kleen static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 1042dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1043dc098b35SAndi Kleen { 1044dc098b35SAndi Kleen snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 1045dc098b35SAndi Kleen return buf; 1046dc098b35SAndi Kleen } 1047dc098b35SAndi Kleen 104808e60ed1SAndi Kleen struct pair { 104908e60ed1SAndi Kleen char *name; 105008e60ed1SAndi Kleen char *desc; 105108e60ed1SAndi Kleen }; 105208e60ed1SAndi Kleen 105308e60ed1SAndi Kleen static int cmp_pair(const void *a, const void *b) 1054dc098b35SAndi Kleen { 105508e60ed1SAndi Kleen const struct pair *as = a; 105608e60ed1SAndi Kleen const struct pair *bs = b; 105708e60ed1SAndi Kleen 105808e60ed1SAndi Kleen /* Put extra events last */ 105908e60ed1SAndi Kleen if (!!as->desc != !!bs->desc) 106008e60ed1SAndi Kleen return !!as->desc - !!bs->desc; 106108e60ed1SAndi Kleen return strcmp(as->name, bs->name); 106208e60ed1SAndi Kleen } 106308e60ed1SAndi Kleen 106408e60ed1SAndi Kleen static void wordwrap(char *s, int start, int max, int corr) 106508e60ed1SAndi Kleen { 106608e60ed1SAndi Kleen int column = start; 106708e60ed1SAndi Kleen int n; 106808e60ed1SAndi Kleen 106908e60ed1SAndi Kleen while (*s) { 107008e60ed1SAndi Kleen int wlen = strcspn(s, " \t"); 107108e60ed1SAndi Kleen 107208e60ed1SAndi Kleen if (column + wlen >= max && column > start) { 107308e60ed1SAndi Kleen printf("\n%*s", start, ""); 107408e60ed1SAndi Kleen column = start + corr; 107508e60ed1SAndi Kleen } 107608e60ed1SAndi Kleen n = printf("%s%.*s", column > start ? " " : "", wlen, s); 107708e60ed1SAndi Kleen if (n <= 0) 107808e60ed1SAndi Kleen break; 107908e60ed1SAndi Kleen s += wlen; 108008e60ed1SAndi Kleen column += n; 108108e60ed1SAndi Kleen while (isspace(*s)) 108208e60ed1SAndi Kleen s++; 108308e60ed1SAndi Kleen } 1084dc098b35SAndi Kleen } 1085dc098b35SAndi Kleen 1086dc098b35SAndi Kleen void print_pmu_events(const char *event_glob, bool name_only) 1087dc098b35SAndi Kleen { 1088dc098b35SAndi Kleen struct perf_pmu *pmu; 1089dc098b35SAndi Kleen struct perf_pmu_alias *alias; 1090dc098b35SAndi Kleen char buf[1024]; 1091dc098b35SAndi Kleen int printed = 0; 1092dc098b35SAndi Kleen int len, j; 109308e60ed1SAndi Kleen struct pair *aliases; 109408e60ed1SAndi Kleen int numdesc = 0; 109508e60ed1SAndi Kleen int columns = 78; 1096dc098b35SAndi Kleen 1097dc098b35SAndi Kleen pmu = NULL; 1098dc098b35SAndi Kleen len = 0; 109942634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1100dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 1101dc098b35SAndi Kleen len++; 110242634bc7SAdrian Hunter if (pmu->selectable) 110342634bc7SAdrian Hunter len++; 110442634bc7SAdrian Hunter } 110508e60ed1SAndi Kleen aliases = zalloc(sizeof(struct pair) * len); 1106dc098b35SAndi Kleen if (!aliases) 11077e4772dcSArnaldo Carvalho de Melo goto out_enomem; 1108dc098b35SAndi Kleen pmu = NULL; 1109dc098b35SAndi Kleen j = 0; 111042634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1111dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) { 111208e60ed1SAndi Kleen char *name = alias->desc ? alias->name : 111308e60ed1SAndi Kleen format_alias(buf, sizeof(buf), pmu, alias); 1114dc098b35SAndi Kleen bool is_cpu = !strcmp(pmu->name, "cpu"); 1115dc098b35SAndi Kleen 1116dc098b35SAndi Kleen if (event_glob != NULL && 1117dc098b35SAndi Kleen !(strglobmatch(name, event_glob) || 1118dc098b35SAndi Kleen (!is_cpu && strglobmatch(alias->name, 1119dc098b35SAndi Kleen event_glob)))) 1120dc098b35SAndi Kleen continue; 11217e4772dcSArnaldo Carvalho de Melo 112208e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 11237e4772dcSArnaldo Carvalho de Melo name = format_alias_or(buf, sizeof(buf), pmu, alias); 11247e4772dcSArnaldo Carvalho de Melo 112508e60ed1SAndi Kleen aliases[j].name = name; 112608e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 112708e60ed1SAndi Kleen aliases[j].name = format_alias_or(buf, 112808e60ed1SAndi Kleen sizeof(buf), 112908e60ed1SAndi Kleen pmu, alias); 113008e60ed1SAndi Kleen aliases[j].name = strdup(aliases[j].name); 113108e60ed1SAndi Kleen if (!aliases[j].name) 11327e4772dcSArnaldo Carvalho de Melo goto out_enomem; 113308e60ed1SAndi Kleen 113408e60ed1SAndi Kleen aliases[j].desc = alias->desc; 1135dc098b35SAndi Kleen j++; 1136dc098b35SAndi Kleen } 1137fa52ceabSArnaldo Carvalho de Melo if (pmu->selectable && 1138fa52ceabSArnaldo Carvalho de Melo (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 11397e4772dcSArnaldo Carvalho de Melo char *s; 11407e4772dcSArnaldo Carvalho de Melo if (asprintf(&s, "%s//", pmu->name) < 0) 11417e4772dcSArnaldo Carvalho de Melo goto out_enomem; 114208e60ed1SAndi Kleen aliases[j].name = s; 114342634bc7SAdrian Hunter j++; 114442634bc7SAdrian Hunter } 114542634bc7SAdrian Hunter } 1146dc098b35SAndi Kleen len = j; 114708e60ed1SAndi Kleen qsort(aliases, len, sizeof(struct pair), cmp_pair); 1148dc098b35SAndi Kleen for (j = 0; j < len; j++) { 1149dc098b35SAndi Kleen if (name_only) { 115008e60ed1SAndi Kleen printf("%s ", aliases[j].name); 1151dc098b35SAndi Kleen continue; 1152dc098b35SAndi Kleen } 115308e60ed1SAndi Kleen if (aliases[j].desc) { 115408e60ed1SAndi Kleen if (numdesc++ == 0) 115508e60ed1SAndi Kleen printf("\n"); 115608e60ed1SAndi Kleen printf(" %-50s\n", aliases[j].name); 115708e60ed1SAndi Kleen printf("%*s", 8, "["); 115808e60ed1SAndi Kleen wordwrap(aliases[j].desc, 8, columns, 0); 115908e60ed1SAndi Kleen printf("]\n"); 116008e60ed1SAndi Kleen } else 116108e60ed1SAndi Kleen printf(" %-50s [Kernel PMU event]\n", aliases[j].name); 1162dc098b35SAndi Kleen printed++; 1163dc098b35SAndi Kleen } 1164dfc431cbSArnaldo Carvalho de Melo if (printed && pager_in_use()) 1165dc098b35SAndi Kleen printf("\n"); 11667e4772dcSArnaldo Carvalho de Melo out_free: 11677e4772dcSArnaldo Carvalho de Melo for (j = 0; j < len; j++) 116808e60ed1SAndi Kleen zfree(&aliases[j].name); 11697e4772dcSArnaldo Carvalho de Melo zfree(&aliases); 11707e4772dcSArnaldo Carvalho de Melo return; 11717e4772dcSArnaldo Carvalho de Melo 11727e4772dcSArnaldo Carvalho de Melo out_enomem: 11737e4772dcSArnaldo Carvalho de Melo printf("FATAL: not enough memory to print PMU events\n"); 11747e4772dcSArnaldo Carvalho de Melo if (aliases) 11757e4772dcSArnaldo Carvalho de Melo goto out_free; 1176dc098b35SAndi Kleen } 11774cabc3d1SAndi Kleen 11784cabc3d1SAndi Kleen bool pmu_have_event(const char *pname, const char *name) 11794cabc3d1SAndi Kleen { 11804cabc3d1SAndi Kleen struct perf_pmu *pmu; 11814cabc3d1SAndi Kleen struct perf_pmu_alias *alias; 11824cabc3d1SAndi Kleen 11834cabc3d1SAndi Kleen pmu = NULL; 11844cabc3d1SAndi Kleen while ((pmu = perf_pmu__scan(pmu)) != NULL) { 11854cabc3d1SAndi Kleen if (strcmp(pname, pmu->name)) 11864cabc3d1SAndi Kleen continue; 11874cabc3d1SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 11884cabc3d1SAndi Kleen if (!strcmp(alias->name, name)) 11894cabc3d1SAndi Kleen return true; 11904cabc3d1SAndi Kleen } 11914cabc3d1SAndi Kleen return false; 11924cabc3d1SAndi Kleen } 11937d4bdab5SAdrian Hunter 11947d4bdab5SAdrian Hunter static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 11957d4bdab5SAdrian Hunter { 11967d4bdab5SAdrian Hunter struct stat st; 11977d4bdab5SAdrian Hunter char path[PATH_MAX]; 11987d4bdab5SAdrian Hunter const char *sysfs; 11997d4bdab5SAdrian Hunter 12007d4bdab5SAdrian Hunter sysfs = sysfs__mountpoint(); 12017d4bdab5SAdrian Hunter if (!sysfs) 12027d4bdab5SAdrian Hunter return NULL; 12037d4bdab5SAdrian Hunter 12047d4bdab5SAdrian Hunter snprintf(path, PATH_MAX, 12057d4bdab5SAdrian Hunter "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 12067d4bdab5SAdrian Hunter 12077d4bdab5SAdrian Hunter if (stat(path, &st) < 0) 12087d4bdab5SAdrian Hunter return NULL; 12097d4bdab5SAdrian Hunter 12107d4bdab5SAdrian Hunter return fopen(path, "r"); 12117d4bdab5SAdrian Hunter } 12127d4bdab5SAdrian Hunter 12137d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 12147d4bdab5SAdrian Hunter ...) 12157d4bdab5SAdrian Hunter { 12167d4bdab5SAdrian Hunter va_list args; 12177d4bdab5SAdrian Hunter FILE *file; 12187d4bdab5SAdrian Hunter int ret = EOF; 12197d4bdab5SAdrian Hunter 12207d4bdab5SAdrian Hunter va_start(args, fmt); 12217d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 12227d4bdab5SAdrian Hunter if (file) { 12237d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 12247d4bdab5SAdrian Hunter fclose(file); 12257d4bdab5SAdrian Hunter } 12267d4bdab5SAdrian Hunter va_end(args); 12277d4bdab5SAdrian Hunter return ret; 12287d4bdab5SAdrian Hunter } 1229