1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2cd82a32eSJiri Olsa #include <linux/list.h> 3c5de47f2SSukadev Bhattiprolu #include <linux/compiler.h> 4cd82a32eSJiri Olsa #include <sys/types.h> 5a43783aeSArnaldo Carvalho de Melo #include <errno.h> 6c23c2a0fSArnaldo Carvalho de Melo #include <fcntl.h> 77a8ef4c4SArnaldo Carvalho de Melo #include <sys/stat.h> 8cd82a32eSJiri Olsa #include <unistd.h> 9cd82a32eSJiri Olsa #include <stdio.h> 10dc0a6202SAdrian Hunter #include <stdbool.h> 117d4bdab5SAdrian Hunter #include <stdarg.h> 12cd82a32eSJiri Olsa #include <dirent.h> 13cd0cfad7SBorislav Petkov #include <api/fs/fs.h> 14410136f5SStephane Eranian #include <locale.h> 15fbc2844eSWilliam Cohen #include <regex.h> 16cd82a32eSJiri Olsa #include "util.h" 17cd82a32eSJiri Olsa #include "pmu.h" 18cd82a32eSJiri Olsa #include "parse-events.h" 197ae92e74SYan, Zheng #include "cpumap.h" 20933f82ffSSukadev Bhattiprolu #include "header.h" 21933f82ffSSukadev Bhattiprolu #include "pmu-events/pmu-events.h" 2261eb2eb4SAndi Kleen #include "cache.h" 23a067558eSArnaldo Carvalho de Melo #include "string2.h" 24cd82a32eSJiri Olsa 25ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 26ab1bf653SArnaldo Carvalho de Melo char *name; 27ab1bf653SArnaldo Carvalho de Melo int value; 28ab1bf653SArnaldo Carvalho de Melo DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 29ab1bf653SArnaldo Carvalho de Melo struct list_head list; 30ab1bf653SArnaldo Carvalho de Melo }; 31ab1bf653SArnaldo Carvalho de Melo 3250a9667cSRobert Richter #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" 3350a9667cSRobert Richter 34cd82a32eSJiri Olsa int perf_pmu_parse(struct list_head *list, char *name); 35cd82a32eSJiri Olsa extern FILE *perf_pmu_in; 36cd82a32eSJiri Olsa 37cd82a32eSJiri Olsa static LIST_HEAD(pmus); 38cd82a32eSJiri Olsa 39cd82a32eSJiri Olsa /* 40cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 41cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 42cd82a32eSJiri Olsa */ 43cff7f956SJiri Olsa int perf_pmu__format_parse(char *dir, struct list_head *head) 44cd82a32eSJiri Olsa { 45cd82a32eSJiri Olsa struct dirent *evt_ent; 46cd82a32eSJiri Olsa DIR *format_dir; 47cd82a32eSJiri Olsa int ret = 0; 48cd82a32eSJiri Olsa 49cd82a32eSJiri Olsa format_dir = opendir(dir); 50cd82a32eSJiri Olsa if (!format_dir) 51cd82a32eSJiri Olsa return -EINVAL; 52cd82a32eSJiri Olsa 53cd82a32eSJiri Olsa while (!ret && (evt_ent = readdir(format_dir))) { 54cd82a32eSJiri Olsa char path[PATH_MAX]; 55cd82a32eSJiri Olsa char *name = evt_ent->d_name; 56cd82a32eSJiri Olsa FILE *file; 57cd82a32eSJiri Olsa 58cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 59cd82a32eSJiri Olsa continue; 60cd82a32eSJiri Olsa 61cd82a32eSJiri Olsa snprintf(path, PATH_MAX, "%s/%s", dir, name); 62cd82a32eSJiri Olsa 63cd82a32eSJiri Olsa ret = -EINVAL; 64cd82a32eSJiri Olsa file = fopen(path, "r"); 65cd82a32eSJiri Olsa if (!file) 66cd82a32eSJiri Olsa break; 67cd82a32eSJiri Olsa 68cd82a32eSJiri Olsa perf_pmu_in = file; 69cd82a32eSJiri Olsa ret = perf_pmu_parse(head, name); 70cd82a32eSJiri Olsa fclose(file); 71cd82a32eSJiri Olsa } 72cd82a32eSJiri Olsa 73cd82a32eSJiri Olsa closedir(format_dir); 74cd82a32eSJiri Olsa return ret; 75cd82a32eSJiri Olsa } 76cd82a32eSJiri Olsa 77cd82a32eSJiri Olsa /* 78cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 79cd82a32eSJiri Olsa * located at: 80cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 81cd82a32eSJiri Olsa */ 82b6b96fb4SAdrian Hunter static int pmu_format(const char *name, struct list_head *format) 83cd82a32eSJiri Olsa { 84cd82a32eSJiri Olsa struct stat st; 85cd82a32eSJiri Olsa char path[PATH_MAX]; 86cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 87cd82a32eSJiri Olsa 88cd82a32eSJiri Olsa if (!sysfs) 89cd82a32eSJiri Olsa return -1; 90cd82a32eSJiri Olsa 91cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 9250a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 93cd82a32eSJiri Olsa 94cd82a32eSJiri Olsa if (stat(path, &st) < 0) 959bc8f9feSRobert Richter return 0; /* no error if format does not exist */ 96cd82a32eSJiri Olsa 97cff7f956SJiri Olsa if (perf_pmu__format_parse(path, format)) 98cd82a32eSJiri Olsa return -1; 99cd82a32eSJiri Olsa 100cd82a32eSJiri Olsa return 0; 101cd82a32eSJiri Olsa } 102cd82a32eSJiri Olsa 103d02fc6bcSAndi Kleen static int convert_scale(const char *scale, char **end, double *sval) 104d02fc6bcSAndi Kleen { 105d02fc6bcSAndi Kleen char *lc; 106d02fc6bcSAndi Kleen int ret = 0; 107d02fc6bcSAndi Kleen 108d02fc6bcSAndi Kleen /* 109d02fc6bcSAndi Kleen * save current locale 110d02fc6bcSAndi Kleen */ 111d02fc6bcSAndi Kleen lc = setlocale(LC_NUMERIC, NULL); 112d02fc6bcSAndi Kleen 113d02fc6bcSAndi Kleen /* 114d02fc6bcSAndi Kleen * The lc string may be allocated in static storage, 115d02fc6bcSAndi Kleen * so get a dynamic copy to make it survive setlocale 116d02fc6bcSAndi Kleen * call below. 117d02fc6bcSAndi Kleen */ 118d02fc6bcSAndi Kleen lc = strdup(lc); 119d02fc6bcSAndi Kleen if (!lc) { 120d02fc6bcSAndi Kleen ret = -ENOMEM; 121d02fc6bcSAndi Kleen goto out; 122d02fc6bcSAndi Kleen } 123d02fc6bcSAndi Kleen 124d02fc6bcSAndi Kleen /* 125d02fc6bcSAndi Kleen * force to C locale to ensure kernel 126d02fc6bcSAndi Kleen * scale string is converted correctly. 127d02fc6bcSAndi Kleen * kernel uses default C locale. 128d02fc6bcSAndi Kleen */ 129d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, "C"); 130d02fc6bcSAndi Kleen 131d02fc6bcSAndi Kleen *sval = strtod(scale, end); 132d02fc6bcSAndi Kleen 133d02fc6bcSAndi Kleen out: 134d02fc6bcSAndi Kleen /* restore locale */ 135d02fc6bcSAndi Kleen setlocale(LC_NUMERIC, lc); 136d02fc6bcSAndi Kleen free(lc); 137d02fc6bcSAndi Kleen return ret; 138d02fc6bcSAndi Kleen } 139d02fc6bcSAndi Kleen 140410136f5SStephane Eranian static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 141410136f5SStephane Eranian { 142410136f5SStephane Eranian struct stat st; 143410136f5SStephane Eranian ssize_t sret; 144410136f5SStephane Eranian char scale[128]; 145410136f5SStephane Eranian int fd, ret = -1; 146410136f5SStephane Eranian char path[PATH_MAX]; 147410136f5SStephane Eranian 148410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 149410136f5SStephane Eranian 150410136f5SStephane Eranian fd = open(path, O_RDONLY); 151410136f5SStephane Eranian if (fd == -1) 152410136f5SStephane Eranian return -1; 153410136f5SStephane Eranian 154410136f5SStephane Eranian if (fstat(fd, &st) < 0) 155410136f5SStephane Eranian goto error; 156410136f5SStephane Eranian 157410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 158410136f5SStephane Eranian if (sret < 0) 159410136f5SStephane Eranian goto error; 160410136f5SStephane Eranian 1619ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 1629ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 1639ecae065SMadhavan Srinivasan else 164410136f5SStephane Eranian scale[sret] = '\0'; 1659ecae065SMadhavan Srinivasan 166d02fc6bcSAndi Kleen ret = convert_scale(scale, NULL, &alias->scale); 167410136f5SStephane Eranian error: 168410136f5SStephane Eranian close(fd); 169410136f5SStephane Eranian return ret; 170410136f5SStephane Eranian } 171410136f5SStephane Eranian 172410136f5SStephane Eranian static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 173410136f5SStephane Eranian { 174410136f5SStephane Eranian char path[PATH_MAX]; 175410136f5SStephane Eranian ssize_t sret; 176410136f5SStephane Eranian int fd; 177410136f5SStephane Eranian 178410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 179410136f5SStephane Eranian 180410136f5SStephane Eranian fd = open(path, O_RDONLY); 181410136f5SStephane Eranian if (fd == -1) 182410136f5SStephane Eranian return -1; 183410136f5SStephane Eranian 184410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 185410136f5SStephane Eranian if (sret < 0) 186410136f5SStephane Eranian goto error; 187410136f5SStephane Eranian 188410136f5SStephane Eranian close(fd); 189410136f5SStephane Eranian 1909ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 1919ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 1929ecae065SMadhavan Srinivasan else 193410136f5SStephane Eranian alias->unit[sret] = '\0'; 194410136f5SStephane Eranian 195410136f5SStephane Eranian return 0; 196410136f5SStephane Eranian error: 197410136f5SStephane Eranian close(fd); 198410136f5SStephane Eranian alias->unit[0] = '\0'; 199410136f5SStephane Eranian return -1; 200410136f5SStephane Eranian } 201410136f5SStephane Eranian 202044330c1SMatt Fleming static int 203044330c1SMatt Fleming perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 204044330c1SMatt Fleming { 205044330c1SMatt Fleming char path[PATH_MAX]; 206044330c1SMatt Fleming int fd; 207044330c1SMatt Fleming 208044330c1SMatt Fleming snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 209044330c1SMatt Fleming 210044330c1SMatt Fleming fd = open(path, O_RDONLY); 211044330c1SMatt Fleming if (fd == -1) 212044330c1SMatt Fleming return -1; 213044330c1SMatt Fleming 214044330c1SMatt Fleming close(fd); 215044330c1SMatt Fleming 216044330c1SMatt Fleming alias->per_pkg = true; 217044330c1SMatt Fleming return 0; 218044330c1SMatt Fleming } 219044330c1SMatt Fleming 2201d9e446bSJiri Olsa static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 2211d9e446bSJiri Olsa char *dir, char *name) 2221d9e446bSJiri Olsa { 2231d9e446bSJiri Olsa char path[PATH_MAX]; 2241d9e446bSJiri Olsa int fd; 2251d9e446bSJiri Olsa 2261d9e446bSJiri Olsa snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 2271d9e446bSJiri Olsa 2281d9e446bSJiri Olsa fd = open(path, O_RDONLY); 2291d9e446bSJiri Olsa if (fd == -1) 2301d9e446bSJiri Olsa return -1; 2311d9e446bSJiri Olsa 2321d9e446bSJiri Olsa alias->snapshot = true; 2331d9e446bSJiri Olsa close(fd); 2341d9e446bSJiri Olsa return 0; 2351d9e446bSJiri Olsa } 2361d9e446bSJiri Olsa 23770c646e0SSukadev Bhattiprolu static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 238fedb2b51SAndi Kleen char *desc, char *val, 239fedb2b51SAndi Kleen char *long_desc, char *topic, 24000636c3bSAndi Kleen char *unit, char *perpkg, 24196284814SAndi Kleen char *metric_expr, 24296284814SAndi Kleen char *metric_name) 243a6146d50SZheng Yan { 2445c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 245a6146d50SZheng Yan int ret; 246fedb2b51SAndi Kleen int num; 247a6146d50SZheng Yan 248a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 249a6146d50SZheng Yan if (!alias) 250a6146d50SZheng Yan return -ENOMEM; 251a6146d50SZheng Yan 252a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 253410136f5SStephane Eranian alias->scale = 1.0; 254410136f5SStephane Eranian alias->unit[0] = '\0'; 255044330c1SMatt Fleming alias->per_pkg = false; 25684530920SStephane Eranian alias->snapshot = false; 257410136f5SStephane Eranian 25870c646e0SSukadev Bhattiprolu ret = parse_events_terms(&alias->terms, val); 259a6146d50SZheng Yan if (ret) { 26070c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 261a6146d50SZheng Yan free(alias); 262a6146d50SZheng Yan return ret; 263a6146d50SZheng Yan } 264a6146d50SZheng Yan 265a6146d50SZheng Yan alias->name = strdup(name); 26670c646e0SSukadev Bhattiprolu if (dir) { 267410136f5SStephane Eranian /* 268410136f5SStephane Eranian * load unit name and scale if available 269410136f5SStephane Eranian */ 270410136f5SStephane Eranian perf_pmu__parse_unit(alias, dir, name); 271410136f5SStephane Eranian perf_pmu__parse_scale(alias, dir, name); 272044330c1SMatt Fleming perf_pmu__parse_per_pkg(alias, dir, name); 2731d9e446bSJiri Olsa perf_pmu__parse_snapshot(alias, dir, name); 27470c646e0SSukadev Bhattiprolu } 275410136f5SStephane Eranian 27600636c3bSAndi Kleen alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL; 27796284814SAndi Kleen alias->metric_name = metric_name ? strdup(metric_name): NULL; 27808e60ed1SAndi Kleen alias->desc = desc ? strdup(desc) : NULL; 279c8d6828aSSukadev Bhattiprolu alias->long_desc = long_desc ? strdup(long_desc) : 280c8d6828aSSukadev Bhattiprolu desc ? strdup(desc) : NULL; 281dd5f1036SAndi Kleen alias->topic = topic ? strdup(topic) : NULL; 282fedb2b51SAndi Kleen if (unit) { 283fedb2b51SAndi Kleen if (convert_scale(unit, &unit, &alias->scale) < 0) 284fedb2b51SAndi Kleen return -1; 285fedb2b51SAndi Kleen snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 286fedb2b51SAndi Kleen } 287fedb2b51SAndi Kleen alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1; 288f2361024SAndi Kleen alias->str = strdup(val); 289f2361024SAndi Kleen 290a6146d50SZheng Yan list_add_tail(&alias->list, list); 291410136f5SStephane Eranian 292a6146d50SZheng Yan return 0; 293a6146d50SZheng Yan } 294a6146d50SZheng Yan 29570c646e0SSukadev Bhattiprolu static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 29670c646e0SSukadev Bhattiprolu { 29770c646e0SSukadev Bhattiprolu char buf[256]; 29870c646e0SSukadev Bhattiprolu int ret; 29970c646e0SSukadev Bhattiprolu 30070c646e0SSukadev Bhattiprolu ret = fread(buf, 1, sizeof(buf), file); 30170c646e0SSukadev Bhattiprolu if (ret == 0) 30270c646e0SSukadev Bhattiprolu return -EINVAL; 30370c646e0SSukadev Bhattiprolu 30470c646e0SSukadev Bhattiprolu buf[ret] = 0; 30570c646e0SSukadev Bhattiprolu 306fedb2b51SAndi Kleen return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL, 30796284814SAndi Kleen NULL, NULL, NULL); 30870c646e0SSukadev Bhattiprolu } 30970c646e0SSukadev Bhattiprolu 31046441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 31146441bdcSMatt Fleming { 31246441bdcSMatt Fleming size_t len; 31346441bdcSMatt Fleming 31446441bdcSMatt Fleming len = strlen(name); 31546441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 31646441bdcSMatt Fleming return true; 31746441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 31846441bdcSMatt Fleming return true; 319044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 320044330c1SMatt Fleming return true; 3211d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 3221d9e446bSJiri Olsa return true; 32346441bdcSMatt Fleming 32446441bdcSMatt Fleming return false; 32546441bdcSMatt Fleming } 32646441bdcSMatt Fleming 327a6146d50SZheng Yan /* 328a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 329a6146d50SZheng Yan * specified in 'dir' parameter. 330a6146d50SZheng Yan */ 331a6146d50SZheng Yan static int pmu_aliases_parse(char *dir, struct list_head *head) 332a6146d50SZheng Yan { 333a6146d50SZheng Yan struct dirent *evt_ent; 334a6146d50SZheng Yan DIR *event_dir; 335a6146d50SZheng Yan 336a6146d50SZheng Yan event_dir = opendir(dir); 337a6146d50SZheng Yan if (!event_dir) 338a6146d50SZheng Yan return -EINVAL; 339a6146d50SZheng Yan 340940db6dcSAndi Kleen while ((evt_ent = readdir(event_dir))) { 341a6146d50SZheng Yan char path[PATH_MAX]; 342a6146d50SZheng Yan char *name = evt_ent->d_name; 343a6146d50SZheng Yan FILE *file; 344a6146d50SZheng Yan 345a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 346a6146d50SZheng Yan continue; 347a6146d50SZheng Yan 348410136f5SStephane Eranian /* 34946441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 350410136f5SStephane Eranian */ 35146441bdcSMatt Fleming if (pmu_alias_info_file(name)) 352410136f5SStephane Eranian continue; 353410136f5SStephane Eranian 354a6146d50SZheng Yan snprintf(path, PATH_MAX, "%s/%s", dir, name); 355a6146d50SZheng Yan 356a6146d50SZheng Yan file = fopen(path, "r"); 357940db6dcSAndi Kleen if (!file) { 358940db6dcSAndi Kleen pr_debug("Cannot open %s\n", path); 359940db6dcSAndi Kleen continue; 360940db6dcSAndi Kleen } 361410136f5SStephane Eranian 362940db6dcSAndi Kleen if (perf_pmu__new_alias(head, dir, name, file) < 0) 363940db6dcSAndi Kleen pr_debug("Cannot set up %s\n", name); 364a6146d50SZheng Yan fclose(file); 365a6146d50SZheng Yan } 366a6146d50SZheng Yan 367a6146d50SZheng Yan closedir(event_dir); 368940db6dcSAndi Kleen return 0; 369a6146d50SZheng Yan } 370a6146d50SZheng Yan 371a6146d50SZheng Yan /* 372a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 373a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 374a6146d50SZheng Yan */ 375b6b96fb4SAdrian Hunter static int pmu_aliases(const char *name, struct list_head *head) 376a6146d50SZheng Yan { 377a6146d50SZheng Yan struct stat st; 378a6146d50SZheng Yan char path[PATH_MAX]; 379cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 380a6146d50SZheng Yan 381a6146d50SZheng Yan if (!sysfs) 382a6146d50SZheng Yan return -1; 383a6146d50SZheng Yan 384a6146d50SZheng Yan snprintf(path, PATH_MAX, 385a6146d50SZheng Yan "%s/bus/event_source/devices/%s/events", sysfs, name); 386a6146d50SZheng Yan 387a6146d50SZheng Yan if (stat(path, &st) < 0) 3883fded963SJiri Olsa return 0; /* no error if 'events' does not exist */ 389a6146d50SZheng Yan 390a6146d50SZheng Yan if (pmu_aliases_parse(path, head)) 391a6146d50SZheng Yan return -1; 392a6146d50SZheng Yan 393a6146d50SZheng Yan return 0; 394a6146d50SZheng Yan } 395a6146d50SZheng Yan 3965c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 397a6146d50SZheng Yan struct list_head *terms) 398a6146d50SZheng Yan { 3997c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 400a6146d50SZheng Yan LIST_HEAD(list); 401a6146d50SZheng Yan int ret; 402a6146d50SZheng Yan 403a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 4047c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 405a6146d50SZheng Yan if (ret) { 406682dc24cSArnaldo Carvalho de Melo parse_events_terms__purge(&list); 407a6146d50SZheng Yan return ret; 408a6146d50SZheng Yan } 409c2f1ceadSAndi Kleen /* 410c2f1ceadSAndi Kleen * Weak terms don't override command line options, 411c2f1ceadSAndi Kleen * which we don't want for implicit terms in aliases. 412c2f1ceadSAndi Kleen */ 413c2f1ceadSAndi Kleen cloned->weak = true; 4147c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 415a6146d50SZheng Yan } 416a6146d50SZheng Yan list_splice(&list, terms); 417a6146d50SZheng Yan return 0; 418a6146d50SZheng Yan } 419a6146d50SZheng Yan 420cd82a32eSJiri Olsa /* 421cd82a32eSJiri Olsa * Reading/parsing the default pmu type value, which should be 422cd82a32eSJiri Olsa * located at: 423cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 424cd82a32eSJiri Olsa */ 425b6b96fb4SAdrian Hunter static int pmu_type(const char *name, __u32 *type) 426cd82a32eSJiri Olsa { 427cd82a32eSJiri Olsa struct stat st; 428cd82a32eSJiri Olsa char path[PATH_MAX]; 429cd82a32eSJiri Olsa FILE *file; 430cd82a32eSJiri Olsa int ret = 0; 431cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 432cd82a32eSJiri Olsa 433cd82a32eSJiri Olsa if (!sysfs) 434cd82a32eSJiri Olsa return -1; 435cd82a32eSJiri Olsa 436cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 43750a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 438cd82a32eSJiri Olsa 439cd82a32eSJiri Olsa if (stat(path, &st) < 0) 440cd82a32eSJiri Olsa return -1; 441cd82a32eSJiri Olsa 442cd82a32eSJiri Olsa file = fopen(path, "r"); 443cd82a32eSJiri Olsa if (!file) 444cd82a32eSJiri Olsa return -EINVAL; 445cd82a32eSJiri Olsa 446cd82a32eSJiri Olsa if (1 != fscanf(file, "%u", type)) 447cd82a32eSJiri Olsa ret = -1; 448cd82a32eSJiri Olsa 449cd82a32eSJiri Olsa fclose(file); 450cd82a32eSJiri Olsa return ret; 451cd82a32eSJiri Olsa } 452cd82a32eSJiri Olsa 45350a9667cSRobert Richter /* Add all pmus in sysfs to pmu list: */ 45450a9667cSRobert Richter static void pmu_read_sysfs(void) 45550a9667cSRobert Richter { 45650a9667cSRobert Richter char path[PATH_MAX]; 45750a9667cSRobert Richter DIR *dir; 45850a9667cSRobert Richter struct dirent *dent; 459cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 46050a9667cSRobert Richter 46150a9667cSRobert Richter if (!sysfs) 46250a9667cSRobert Richter return; 46350a9667cSRobert Richter 46450a9667cSRobert Richter snprintf(path, PATH_MAX, 46550a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 46650a9667cSRobert Richter 46750a9667cSRobert Richter dir = opendir(path); 46850a9667cSRobert Richter if (!dir) 46950a9667cSRobert Richter return; 47050a9667cSRobert Richter 47150a9667cSRobert Richter while ((dent = readdir(dir))) { 47250a9667cSRobert Richter if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 47350a9667cSRobert Richter continue; 47450a9667cSRobert Richter /* add to static LIST_HEAD(pmus): */ 47550a9667cSRobert Richter perf_pmu__find(dent->d_name); 47650a9667cSRobert Richter } 47750a9667cSRobert Richter 47850a9667cSRobert Richter closedir(dir); 47950a9667cSRobert Richter } 48050a9667cSRobert Richter 48166ec1191SMark Rutland static struct cpu_map *__pmu_cpumask(const char *path) 48266ec1191SMark Rutland { 48366ec1191SMark Rutland FILE *file; 48466ec1191SMark Rutland struct cpu_map *cpus; 48566ec1191SMark Rutland 48666ec1191SMark Rutland file = fopen(path, "r"); 48766ec1191SMark Rutland if (!file) 48866ec1191SMark Rutland return NULL; 48966ec1191SMark Rutland 49066ec1191SMark Rutland cpus = cpu_map__read(file); 49166ec1191SMark Rutland fclose(file); 49266ec1191SMark Rutland return cpus; 49366ec1191SMark Rutland } 49466ec1191SMark Rutland 49566ec1191SMark Rutland /* 49666ec1191SMark Rutland * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 49766ec1191SMark Rutland * may have a "cpus" file. 49866ec1191SMark Rutland */ 49966ec1191SMark Rutland #define CPUS_TEMPLATE_UNCORE "%s/bus/event_source/devices/%s/cpumask" 50066ec1191SMark Rutland #define CPUS_TEMPLATE_CPU "%s/bus/event_source/devices/%s/cpus" 50166ec1191SMark Rutland 502b6b96fb4SAdrian Hunter static struct cpu_map *pmu_cpumask(const char *name) 5037ae92e74SYan, Zheng { 5047ae92e74SYan, Zheng char path[PATH_MAX]; 5057ae92e74SYan, Zheng struct cpu_map *cpus; 506cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 5077e3fcffeSMark Rutland const char *templates[] = { 50866ec1191SMark Rutland CPUS_TEMPLATE_UNCORE, 50966ec1191SMark Rutland CPUS_TEMPLATE_CPU, 5107e3fcffeSMark Rutland NULL 5117e3fcffeSMark Rutland }; 5127e3fcffeSMark Rutland const char **template; 5137ae92e74SYan, Zheng 5147ae92e74SYan, Zheng if (!sysfs) 5157ae92e74SYan, Zheng return NULL; 5167ae92e74SYan, Zheng 5177e3fcffeSMark Rutland for (template = templates; *template; template++) { 5187e3fcffeSMark Rutland snprintf(path, PATH_MAX, *template, sysfs, name); 51966ec1191SMark Rutland cpus = __pmu_cpumask(path); 52066ec1191SMark Rutland if (cpus) 52166ec1191SMark Rutland return cpus; 5227e3fcffeSMark Rutland } 5237ae92e74SYan, Zheng 5247ae92e74SYan, Zheng return NULL; 52566ec1191SMark Rutland } 5267ae92e74SYan, Zheng 52766ec1191SMark Rutland static bool pmu_is_uncore(const char *name) 52866ec1191SMark Rutland { 52966ec1191SMark Rutland char path[PATH_MAX]; 53066ec1191SMark Rutland struct cpu_map *cpus; 53166ec1191SMark Rutland const char *sysfs = sysfs__mountpoint(); 5327ae92e74SYan, Zheng 53366ec1191SMark Rutland snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name); 53466ec1191SMark Rutland cpus = __pmu_cpumask(path); 53566ec1191SMark Rutland cpu_map__put(cpus); 53666ec1191SMark Rutland 53766ec1191SMark Rutland return !!cpus; 5387ae92e74SYan, Zheng } 5397ae92e74SYan, Zheng 540933f82ffSSukadev Bhattiprolu /* 54114b22ae0SGanapatrao Kulkarni * PMU CORE devices have different name other than cpu in sysfs on some 54214b22ae0SGanapatrao Kulkarni * platforms. looking for possible sysfs files to identify as core device. 54314b22ae0SGanapatrao Kulkarni */ 54414b22ae0SGanapatrao Kulkarni static int is_pmu_core(const char *name) 54514b22ae0SGanapatrao Kulkarni { 54614b22ae0SGanapatrao Kulkarni struct stat st; 54714b22ae0SGanapatrao Kulkarni char path[PATH_MAX]; 54814b22ae0SGanapatrao Kulkarni const char *sysfs = sysfs__mountpoint(); 54914b22ae0SGanapatrao Kulkarni 55014b22ae0SGanapatrao Kulkarni if (!sysfs) 55114b22ae0SGanapatrao Kulkarni return 0; 55214b22ae0SGanapatrao Kulkarni 55314b22ae0SGanapatrao Kulkarni /* Look for cpu sysfs (x86 and others) */ 55414b22ae0SGanapatrao Kulkarni scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu", sysfs); 55514b22ae0SGanapatrao Kulkarni if ((stat(path, &st) == 0) && 55614b22ae0SGanapatrao Kulkarni (strncmp(name, "cpu", strlen("cpu")) == 0)) 55714b22ae0SGanapatrao Kulkarni return 1; 55814b22ae0SGanapatrao Kulkarni 55914b22ae0SGanapatrao Kulkarni /* Look for cpu sysfs (specific to arm) */ 56014b22ae0SGanapatrao Kulkarni scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus", 56114b22ae0SGanapatrao Kulkarni sysfs, name); 56214b22ae0SGanapatrao Kulkarni if (stat(path, &st) == 0) 56314b22ae0SGanapatrao Kulkarni return 1; 56414b22ae0SGanapatrao Kulkarni 56514b22ae0SGanapatrao Kulkarni return 0; 56614b22ae0SGanapatrao Kulkarni } 56714b22ae0SGanapatrao Kulkarni 56814b22ae0SGanapatrao Kulkarni /* 569933f82ffSSukadev Bhattiprolu * Return the CPU id as a raw string. 570933f82ffSSukadev Bhattiprolu * 571933f82ffSSukadev Bhattiprolu * Each architecture should provide a more precise id string that 572933f82ffSSukadev Bhattiprolu * can be use to match the architecture's "mapfile". 573933f82ffSSukadev Bhattiprolu */ 57454e32dc0SGanapatrao Kulkarni char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused) 575933f82ffSSukadev Bhattiprolu { 576933f82ffSSukadev Bhattiprolu return NULL; 577933f82ffSSukadev Bhattiprolu } 578933f82ffSSukadev Bhattiprolu 57954e32dc0SGanapatrao Kulkarni static char *perf_pmu__getcpuid(struct perf_pmu *pmu) 580d77ade9fSAndi Kleen { 581d77ade9fSAndi Kleen char *cpuid; 582d77ade9fSAndi Kleen static bool printed; 583d77ade9fSAndi Kleen 584d77ade9fSAndi Kleen cpuid = getenv("PERF_CPUID"); 585d77ade9fSAndi Kleen if (cpuid) 586d77ade9fSAndi Kleen cpuid = strdup(cpuid); 587d77ade9fSAndi Kleen if (!cpuid) 58854e32dc0SGanapatrao Kulkarni cpuid = get_cpuid_str(pmu); 589d77ade9fSAndi Kleen if (!cpuid) 590d77ade9fSAndi Kleen return NULL; 591d77ade9fSAndi Kleen 592d77ade9fSAndi Kleen if (!printed) { 593d77ade9fSAndi Kleen pr_debug("Using CPUID %s\n", cpuid); 594d77ade9fSAndi Kleen printed = true; 595d77ade9fSAndi Kleen } 596d77ade9fSAndi Kleen return cpuid; 597d77ade9fSAndi Kleen } 598d77ade9fSAndi Kleen 59954e32dc0SGanapatrao Kulkarni struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu) 600d77ade9fSAndi Kleen { 601d77ade9fSAndi Kleen struct pmu_events_map *map; 60254e32dc0SGanapatrao Kulkarni char *cpuid = perf_pmu__getcpuid(pmu); 603d77ade9fSAndi Kleen int i; 604d77ade9fSAndi Kleen 605de3d0f12SGanapatrao Kulkarni /* on some platforms which uses cpus map, cpuid can be NULL for 606de3d0f12SGanapatrao Kulkarni * PMUs other than CORE PMUs. 607de3d0f12SGanapatrao Kulkarni */ 608de3d0f12SGanapatrao Kulkarni if (!cpuid) 609de3d0f12SGanapatrao Kulkarni return NULL; 610de3d0f12SGanapatrao Kulkarni 611d77ade9fSAndi Kleen i = 0; 612d77ade9fSAndi Kleen for (;;) { 613fbc2844eSWilliam Cohen regex_t re; 614fbc2844eSWilliam Cohen regmatch_t pmatch[1]; 615fbc2844eSWilliam Cohen int match; 616fbc2844eSWilliam Cohen 617d77ade9fSAndi Kleen map = &pmu_events_map[i++]; 618d77ade9fSAndi Kleen if (!map->table) { 619d77ade9fSAndi Kleen map = NULL; 620d77ade9fSAndi Kleen break; 621d77ade9fSAndi Kleen } 622d77ade9fSAndi Kleen 623fbc2844eSWilliam Cohen if (regcomp(&re, map->cpuid, REG_EXTENDED) != 0) { 624fbc2844eSWilliam Cohen /* Warn unable to generate match particular string. */ 625fbc2844eSWilliam Cohen pr_info("Invalid regular expression %s\n", map->cpuid); 626d77ade9fSAndi Kleen break; 627d77ade9fSAndi Kleen } 628fbc2844eSWilliam Cohen 629fbc2844eSWilliam Cohen match = !regexec(&re, cpuid, 1, pmatch, 0); 630fbc2844eSWilliam Cohen regfree(&re); 631fbc2844eSWilliam Cohen if (match) { 632fbc2844eSWilliam Cohen size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so); 633fbc2844eSWilliam Cohen 634fbc2844eSWilliam Cohen /* Verify the entire string matched. */ 635fbc2844eSWilliam Cohen if (match_len == strlen(cpuid)) 636fbc2844eSWilliam Cohen break; 637fbc2844eSWilliam Cohen } 638fbc2844eSWilliam Cohen } 639d77ade9fSAndi Kleen free(cpuid); 640d77ade9fSAndi Kleen return map; 641d77ade9fSAndi Kleen } 642d77ade9fSAndi Kleen 643933f82ffSSukadev Bhattiprolu /* 644933f82ffSSukadev Bhattiprolu * From the pmu_events_map, find the table of PMU events that corresponds 645933f82ffSSukadev Bhattiprolu * to the current running CPU. Then, add all PMU events from that table 646933f82ffSSukadev Bhattiprolu * as aliases. 647933f82ffSSukadev Bhattiprolu */ 64854e32dc0SGanapatrao Kulkarni static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu) 649933f82ffSSukadev Bhattiprolu { 650933f82ffSSukadev Bhattiprolu int i; 651933f82ffSSukadev Bhattiprolu struct pmu_events_map *map; 652933f82ffSSukadev Bhattiprolu struct pmu_event *pe; 65354e32dc0SGanapatrao Kulkarni const char *name = pmu->name; 654933f82ffSSukadev Bhattiprolu 65554e32dc0SGanapatrao Kulkarni map = perf_pmu__find_map(pmu); 656d77ade9fSAndi Kleen if (!map) 657933f82ffSSukadev Bhattiprolu return; 658933f82ffSSukadev Bhattiprolu 659933f82ffSSukadev Bhattiprolu /* 660933f82ffSSukadev Bhattiprolu * Found a matching PMU events table. Create aliases 661933f82ffSSukadev Bhattiprolu */ 662933f82ffSSukadev Bhattiprolu i = 0; 663933f82ffSSukadev Bhattiprolu while (1) { 664fedb2b51SAndi Kleen 665933f82ffSSukadev Bhattiprolu pe = &map->table[i++]; 666b18f3e36SAndi Kleen if (!pe->name) { 667b18f3e36SAndi Kleen if (pe->metric_group || pe->metric_name) 668b18f3e36SAndi Kleen continue; 669933f82ffSSukadev Bhattiprolu break; 670b18f3e36SAndi Kleen } 671933f82ffSSukadev Bhattiprolu 67214b22ae0SGanapatrao Kulkarni if (!is_pmu_core(name)) { 67314b22ae0SGanapatrao Kulkarni /* check for uncore devices */ 67414b22ae0SGanapatrao Kulkarni if (pe->pmu == NULL) 675fedb2b51SAndi Kleen continue; 67614b22ae0SGanapatrao Kulkarni if (strncmp(pe->pmu, name, strlen(pe->pmu))) 67714b22ae0SGanapatrao Kulkarni continue; 67814b22ae0SGanapatrao Kulkarni } 679fedb2b51SAndi Kleen 680933f82ffSSukadev Bhattiprolu /* need type casts to override 'const' */ 681933f82ffSSukadev Bhattiprolu __perf_pmu__new_alias(head, NULL, (char *)pe->name, 682c8d6828aSSukadev Bhattiprolu (char *)pe->desc, (char *)pe->event, 683fedb2b51SAndi Kleen (char *)pe->long_desc, (char *)pe->topic, 68400636c3bSAndi Kleen (char *)pe->unit, (char *)pe->perpkg, 68596284814SAndi Kleen (char *)pe->metric_expr, 68696284814SAndi Kleen (char *)pe->metric_name); 687933f82ffSSukadev Bhattiprolu } 688933f82ffSSukadev Bhattiprolu } 689933f82ffSSukadev Bhattiprolu 690c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 691dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 692dc0a6202SAdrian Hunter { 693dc0a6202SAdrian Hunter return NULL; 694dc0a6202SAdrian Hunter } 695dc0a6202SAdrian Hunter 696b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_lookup(const char *name) 697cd82a32eSJiri Olsa { 698cd82a32eSJiri Olsa struct perf_pmu *pmu; 699cd82a32eSJiri Olsa LIST_HEAD(format); 700a6146d50SZheng Yan LIST_HEAD(aliases); 701cd82a32eSJiri Olsa __u32 type; 702cd82a32eSJiri Olsa 703cd82a32eSJiri Olsa /* 704cd82a32eSJiri Olsa * The pmu data we store & need consists of the pmu 705cd82a32eSJiri Olsa * type value and format definitions. Load both right 706cd82a32eSJiri Olsa * now. 707cd82a32eSJiri Olsa */ 708cd82a32eSJiri Olsa if (pmu_format(name, &format)) 709cd82a32eSJiri Olsa return NULL; 710cd82a32eSJiri Olsa 71115b22ed3SAndi Kleen /* 71215b22ed3SAndi Kleen * Check the type first to avoid unnecessary work. 71315b22ed3SAndi Kleen */ 71415b22ed3SAndi Kleen if (pmu_type(name, &type)) 71515b22ed3SAndi Kleen return NULL; 71615b22ed3SAndi Kleen 7173fded963SJiri Olsa if (pmu_aliases(name, &aliases)) 7183fded963SJiri Olsa return NULL; 7193fded963SJiri Olsa 720cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 721cd82a32eSJiri Olsa if (!pmu) 722cd82a32eSJiri Olsa return NULL; 723cd82a32eSJiri Olsa 7247ae92e74SYan, Zheng pmu->cpus = pmu_cpumask(name); 72554e32dc0SGanapatrao Kulkarni pmu->name = strdup(name); 72654e32dc0SGanapatrao Kulkarni pmu->type = type; 72766ec1191SMark Rutland pmu->is_uncore = pmu_is_uncore(name); 72854e32dc0SGanapatrao Kulkarni pmu_add_cpu_aliases(&aliases, pmu); 72966ec1191SMark Rutland 730cd82a32eSJiri Olsa INIT_LIST_HEAD(&pmu->format); 731a6146d50SZheng Yan INIT_LIST_HEAD(&pmu->aliases); 732cd82a32eSJiri Olsa list_splice(&format, &pmu->format); 733a6146d50SZheng Yan list_splice(&aliases, &pmu->aliases); 7349bc8f9feSRobert Richter list_add_tail(&pmu->list, &pmus); 735dc0a6202SAdrian Hunter 736dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 737dc0a6202SAdrian Hunter 738cd82a32eSJiri Olsa return pmu; 739cd82a32eSJiri Olsa } 740cd82a32eSJiri Olsa 741b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_find(const char *name) 742cd82a32eSJiri Olsa { 743cd82a32eSJiri Olsa struct perf_pmu *pmu; 744cd82a32eSJiri Olsa 745cd82a32eSJiri Olsa list_for_each_entry(pmu, &pmus, list) 746cd82a32eSJiri Olsa if (!strcmp(pmu->name, name)) 747cd82a32eSJiri Olsa return pmu; 748cd82a32eSJiri Olsa 749cd82a32eSJiri Olsa return NULL; 750cd82a32eSJiri Olsa } 751cd82a32eSJiri Olsa 75250a9667cSRobert Richter struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 75350a9667cSRobert Richter { 75450a9667cSRobert Richter /* 75550a9667cSRobert Richter * pmu iterator: If pmu is NULL, we start at the begin, 75650a9667cSRobert Richter * otherwise return the next pmu. Returns NULL on end. 75750a9667cSRobert Richter */ 75850a9667cSRobert Richter if (!pmu) { 75950a9667cSRobert Richter pmu_read_sysfs(); 76050a9667cSRobert Richter pmu = list_prepare_entry(pmu, &pmus, list); 76150a9667cSRobert Richter } 76250a9667cSRobert Richter list_for_each_entry_continue(pmu, &pmus, list) 76350a9667cSRobert Richter return pmu; 76450a9667cSRobert Richter return NULL; 76550a9667cSRobert Richter } 76650a9667cSRobert Richter 767b6b96fb4SAdrian Hunter struct perf_pmu *perf_pmu__find(const char *name) 768cd82a32eSJiri Olsa { 769cd82a32eSJiri Olsa struct perf_pmu *pmu; 770cd82a32eSJiri Olsa 771cd82a32eSJiri Olsa /* 772cd82a32eSJiri Olsa * Once PMU is loaded it stays in the list, 773cd82a32eSJiri Olsa * so we keep us from multiple reading/parsing 774cd82a32eSJiri Olsa * the pmu format definitions. 775cd82a32eSJiri Olsa */ 776cd82a32eSJiri Olsa pmu = pmu_find(name); 777cd82a32eSJiri Olsa if (pmu) 778cd82a32eSJiri Olsa return pmu; 779cd82a32eSJiri Olsa 780cd82a32eSJiri Olsa return pmu_lookup(name); 781cd82a32eSJiri Olsa } 782cd82a32eSJiri Olsa 7835c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 78409ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 785cd82a32eSJiri Olsa { 7865c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 787cd82a32eSJiri Olsa 788cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 789cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 790cd82a32eSJiri Olsa return format; 791cd82a32eSJiri Olsa 792cd82a32eSJiri Olsa return NULL; 793cd82a32eSJiri Olsa } 794cd82a32eSJiri Olsa 79509ff6071SAdrian Hunter __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 79609ff6071SAdrian Hunter { 79709ff6071SAdrian Hunter struct perf_pmu_format *format = pmu_find_format(formats, name); 79809ff6071SAdrian Hunter __u64 bits = 0; 79909ff6071SAdrian Hunter int fbit; 80009ff6071SAdrian Hunter 80109ff6071SAdrian Hunter if (!format) 80209ff6071SAdrian Hunter return 0; 80309ff6071SAdrian Hunter 80409ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 80509ff6071SAdrian Hunter bits |= 1ULL << fbit; 80609ff6071SAdrian Hunter 80709ff6071SAdrian Hunter return bits; 80809ff6071SAdrian Hunter } 80909ff6071SAdrian Hunter 810cd82a32eSJiri Olsa /* 811dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 812cd82a32eSJiri Olsa * and unformated value (value parameter). 813cd82a32eSJiri Olsa */ 814dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 815dc0a6202SAdrian Hunter bool zero) 816cd82a32eSJiri Olsa { 817cd82a32eSJiri Olsa unsigned long fbit, vbit; 818cd82a32eSJiri Olsa 819cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 820cd82a32eSJiri Olsa 821cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 822cd82a32eSJiri Olsa continue; 823cd82a32eSJiri Olsa 824dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 825dc0a6202SAdrian Hunter *v |= (1llu << fbit); 826dc0a6202SAdrian Hunter else if (zero) 827dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 828cd82a32eSJiri Olsa } 829cd82a32eSJiri Olsa } 830cd82a32eSJiri Olsa 8310efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 8320efe6b67SAdrian Hunter { 833ac0e2cd5SKan Liang __u64 w = 0; 834ac0e2cd5SKan Liang int fbit; 8350efe6b67SAdrian Hunter 836ac0e2cd5SKan Liang for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS) 837ac0e2cd5SKan Liang w |= (1ULL << fbit); 838ac0e2cd5SKan Liang 839ac0e2cd5SKan Liang return w; 8400efe6b67SAdrian Hunter } 8410efe6b67SAdrian Hunter 842cd82a32eSJiri Olsa /* 843688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 844688d4dfcSCody P Schafer * in the remaining terms. 845688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 846688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 847688d4dfcSCody P Schafer * in a config string) later on in the term list. 848688d4dfcSCody P Schafer */ 849688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 850688d4dfcSCody P Schafer struct list_head *head_terms, 851688d4dfcSCody P Schafer __u64 *value) 852688d4dfcSCody P Schafer { 853688d4dfcSCody P Schafer struct parse_events_term *t; 854688d4dfcSCody P Schafer 855688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 856688d4dfcSCody P Schafer if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 857688d4dfcSCody P Schafer if (!strcmp(t->config, term->config)) { 858688d4dfcSCody P Schafer t->used = true; 859688d4dfcSCody P Schafer *value = t->val.num; 860688d4dfcSCody P Schafer return 0; 861688d4dfcSCody P Schafer } 862688d4dfcSCody P Schafer } 863688d4dfcSCody P Schafer } 864688d4dfcSCody P Schafer 865bb963e16SNamhyung Kim if (verbose > 0) 866688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 867688d4dfcSCody P Schafer 868688d4dfcSCody P Schafer return -1; 869688d4dfcSCody P Schafer } 870688d4dfcSCody P Schafer 871ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 872e64b020bSJiri Olsa { 873e64b020bSJiri Olsa struct perf_pmu_format *format; 87411db4e29SMasami Hiramatsu char *str = NULL; 87511db4e29SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 876e64b020bSJiri Olsa unsigned i = 0; 877e64b020bSJiri Olsa 878ffeb883eSHe Kuang if (!formats) 879e64b020bSJiri Olsa return NULL; 880e64b020bSJiri Olsa 881e64b020bSJiri Olsa /* sysfs exported terms */ 882ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 88311db4e29SMasami Hiramatsu if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 88411db4e29SMasami Hiramatsu goto error; 885e64b020bSJiri Olsa 886ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 88711db4e29SMasami Hiramatsu error: 888ffeb883eSHe Kuang strbuf_release(&buf); 889e64b020bSJiri Olsa 890e64b020bSJiri Olsa return str; 891e64b020bSJiri Olsa } 892e64b020bSJiri Olsa 893688d4dfcSCody P Schafer /* 894cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 89588aca8d9SCody P Schafer * user input data - term parameter. 896cd82a32eSJiri Olsa */ 897cd82a32eSJiri Olsa static int pmu_config_term(struct list_head *formats, 898cd82a32eSJiri Olsa struct perf_event_attr *attr, 899dc0a6202SAdrian Hunter struct parse_events_term *term, 900688d4dfcSCody P Schafer struct list_head *head_terms, 901e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 902cd82a32eSJiri Olsa { 9035c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 904cd82a32eSJiri Olsa __u64 *vp; 9050efe6b67SAdrian Hunter __u64 val, max_val; 906cd82a32eSJiri Olsa 907cd82a32eSJiri Olsa /* 908688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 909688d4dfcSCody P Schafer * skip it in normal eval. 910688d4dfcSCody P Schafer */ 911688d4dfcSCody P Schafer if (term->used) 912688d4dfcSCody P Schafer return 0; 913688d4dfcSCody P Schafer 914688d4dfcSCody P Schafer /* 915cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 916cd82a32eSJiri Olsa * to be done for them. 917cd82a32eSJiri Olsa */ 918cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 919cd82a32eSJiri Olsa return 0; 920cd82a32eSJiri Olsa 921cd82a32eSJiri Olsa format = pmu_find_format(formats, term->config); 922688d4dfcSCody P Schafer if (!format) { 923bb963e16SNamhyung Kim if (verbose > 0) 924688d4dfcSCody P Schafer printf("Invalid event/parameter '%s'\n", term->config); 925e64b020bSJiri Olsa if (err) { 926ffeb883eSHe Kuang char *pmu_term = pmu_formats_string(formats); 927ffeb883eSHe Kuang 928e64b020bSJiri Olsa err->idx = term->err_term; 929e64b020bSJiri Olsa err->str = strdup("unknown term"); 930ffeb883eSHe Kuang err->help = parse_events_formats_error_string(pmu_term); 931ffeb883eSHe Kuang free(pmu_term); 932e64b020bSJiri Olsa } 933cd82a32eSJiri Olsa return -EINVAL; 934688d4dfcSCody P Schafer } 935cd82a32eSJiri Olsa 936cd82a32eSJiri Olsa switch (format->value) { 937cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 938cd82a32eSJiri Olsa vp = &attr->config; 939cd82a32eSJiri Olsa break; 940cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 941cd82a32eSJiri Olsa vp = &attr->config1; 942cd82a32eSJiri Olsa break; 943cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 944cd82a32eSJiri Olsa vp = &attr->config2; 945cd82a32eSJiri Olsa break; 946cd82a32eSJiri Olsa default: 947cd82a32eSJiri Olsa return -EINVAL; 948cd82a32eSJiri Olsa } 949cd82a32eSJiri Olsa 95016fa7e82SJiri Olsa /* 951688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 952688d4dfcSCody P Schafer * using event parameters. 95316fa7e82SJiri Olsa */ 95499e7138eSJiri Olsa if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 95599e7138eSJiri Olsa if (term->no_value && 95699e7138eSJiri Olsa bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 95799e7138eSJiri Olsa if (err) { 95899e7138eSJiri Olsa err->idx = term->err_val; 95999e7138eSJiri Olsa err->str = strdup("no value assigned for term"); 96099e7138eSJiri Olsa } 96199e7138eSJiri Olsa return -EINVAL; 96299e7138eSJiri Olsa } 96399e7138eSJiri Olsa 964688d4dfcSCody P Schafer val = term->val.num; 96599e7138eSJiri Olsa } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 966688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 967bb963e16SNamhyung Kim if (verbose > 0) { 968688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 969688d4dfcSCody P Schafer term->config, term->val.str); 970e64b020bSJiri Olsa } 971e64b020bSJiri Olsa if (err) { 972e64b020bSJiri Olsa err->idx = term->err_val; 973e64b020bSJiri Olsa err->str = strdup("expected numeric value"); 974e64b020bSJiri Olsa } 975688d4dfcSCody P Schafer return -EINVAL; 976688d4dfcSCody P Schafer } 977688d4dfcSCody P Schafer 978688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 979688d4dfcSCody P Schafer return -EINVAL; 980688d4dfcSCody P Schafer } else 981688d4dfcSCody P Schafer return -EINVAL; 982688d4dfcSCody P Schafer 9830efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 9840efe6b67SAdrian Hunter if (val > max_val) { 9850efe6b67SAdrian Hunter if (err) { 9860efe6b67SAdrian Hunter err->idx = term->err_val; 9870efe6b67SAdrian Hunter if (asprintf(&err->str, 9880efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 9890efe6b67SAdrian Hunter (unsigned long long)max_val) < 0) 9900efe6b67SAdrian Hunter err->str = strdup("value too big for format"); 9910efe6b67SAdrian Hunter return -EINVAL; 9920efe6b67SAdrian Hunter } 9930efe6b67SAdrian Hunter /* 9940efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 9950efe6b67SAdrian Hunter * silently truncated. 9960efe6b67SAdrian Hunter */ 9970efe6b67SAdrian Hunter } 9980efe6b67SAdrian Hunter 999688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 1000cd82a32eSJiri Olsa return 0; 1001cd82a32eSJiri Olsa } 1002cd82a32eSJiri Olsa 1003cff7f956SJiri Olsa int perf_pmu__config_terms(struct list_head *formats, 1004cff7f956SJiri Olsa struct perf_event_attr *attr, 1005dc0a6202SAdrian Hunter struct list_head *head_terms, 1006e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 1007cd82a32eSJiri Olsa { 10086cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 1009cd82a32eSJiri Olsa 1010688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 1011e64b020bSJiri Olsa if (pmu_config_term(formats, attr, term, head_terms, 1012e64b020bSJiri Olsa zero, err)) 1013cd82a32eSJiri Olsa return -EINVAL; 1014688d4dfcSCody P Schafer } 1015cd82a32eSJiri Olsa 1016cd82a32eSJiri Olsa return 0; 1017cd82a32eSJiri Olsa } 1018cd82a32eSJiri Olsa 1019cd82a32eSJiri Olsa /* 1020cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 1021cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 1022cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 1023cd82a32eSJiri Olsa */ 1024cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1025e64b020bSJiri Olsa struct list_head *head_terms, 1026e64b020bSJiri Olsa struct parse_events_error *err) 1027cd82a32eSJiri Olsa { 1028dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 1029dc0a6202SAdrian Hunter 1030cd82a32eSJiri Olsa attr->type = pmu->type; 1031e64b020bSJiri Olsa return perf_pmu__config_terms(&pmu->format, attr, head_terms, 1032e64b020bSJiri Olsa zero, err); 1033cd82a32eSJiri Olsa } 1034cd82a32eSJiri Olsa 10355c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 10366cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 1037a6146d50SZheng Yan { 10385c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1039a6146d50SZheng Yan char *name; 1040a6146d50SZheng Yan 1041a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 1042a6146d50SZheng Yan return NULL; 1043a6146d50SZheng Yan 1044a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1045a6146d50SZheng Yan if (term->val.num != 1) 1046a6146d50SZheng Yan return NULL; 1047a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 1048a6146d50SZheng Yan return NULL; 1049a6146d50SZheng Yan name = term->config; 1050a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1051a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 1052a6146d50SZheng Yan return NULL; 1053a6146d50SZheng Yan name = term->val.str; 1054a6146d50SZheng Yan } else { 1055a6146d50SZheng Yan return NULL; 1056a6146d50SZheng Yan } 1057a6146d50SZheng Yan 1058a6146d50SZheng Yan list_for_each_entry(alias, &pmu->aliases, list) { 1059a6146d50SZheng Yan if (!strcasecmp(alias->name, name)) 1060a6146d50SZheng Yan return alias; 1061a6146d50SZheng Yan } 1062a6146d50SZheng Yan return NULL; 1063a6146d50SZheng Yan } 1064a6146d50SZheng Yan 1065410136f5SStephane Eranian 10661d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 10671d9e446bSJiri Olsa struct perf_pmu_info *info) 1068410136f5SStephane Eranian { 1069410136f5SStephane Eranian /* 1070410136f5SStephane Eranian * Only one term in event definition can 10711d9e446bSJiri Olsa * define unit, scale and snapshot, fail 10721d9e446bSJiri Olsa * if there's more than one. 1073410136f5SStephane Eranian */ 1074b30a7d1fSArnaldo Carvalho de Melo if ((info->unit && alias->unit[0]) || 10751d9e446bSJiri Olsa (info->scale && alias->scale) || 10761d9e446bSJiri Olsa (info->snapshot && alias->snapshot)) 1077410136f5SStephane Eranian return -EINVAL; 1078410136f5SStephane Eranian 1079b30a7d1fSArnaldo Carvalho de Melo if (alias->unit[0]) 10801d9e446bSJiri Olsa info->unit = alias->unit; 1081410136f5SStephane Eranian 1082410136f5SStephane Eranian if (alias->scale) 10831d9e446bSJiri Olsa info->scale = alias->scale; 10841d9e446bSJiri Olsa 10851d9e446bSJiri Olsa if (alias->snapshot) 10861d9e446bSJiri Olsa info->snapshot = alias->snapshot; 1087410136f5SStephane Eranian 1088410136f5SStephane Eranian return 0; 1089410136f5SStephane Eranian } 1090410136f5SStephane Eranian 1091a6146d50SZheng Yan /* 1092a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 1093a6146d50SZheng Yan * defined for the alias 1094a6146d50SZheng Yan */ 1095410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 109646441bdcSMatt Fleming struct perf_pmu_info *info) 1097a6146d50SZheng Yan { 10986cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 10995c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 1100a6146d50SZheng Yan int ret; 1101a6146d50SZheng Yan 1102044330c1SMatt Fleming info->per_pkg = false; 1103044330c1SMatt Fleming 11048a398897SStephane Eranian /* 11058a398897SStephane Eranian * Mark unit and scale as not set 11068a398897SStephane Eranian * (different from default values, see below) 11078a398897SStephane Eranian */ 110846441bdcSMatt Fleming info->unit = NULL; 110946441bdcSMatt Fleming info->scale = 0.0; 11101d9e446bSJiri Olsa info->snapshot = false; 111137932c18SAndi Kleen info->metric_expr = NULL; 111296284814SAndi Kleen info->metric_name = NULL; 1113410136f5SStephane Eranian 1114a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 1115a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 1116a6146d50SZheng Yan if (!alias) 1117a6146d50SZheng Yan continue; 1118a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 1119a6146d50SZheng Yan if (ret) 1120a6146d50SZheng Yan return ret; 1121410136f5SStephane Eranian 11221d9e446bSJiri Olsa ret = check_info_data(alias, info); 1123410136f5SStephane Eranian if (ret) 1124410136f5SStephane Eranian return ret; 1125410136f5SStephane Eranian 1126044330c1SMatt Fleming if (alias->per_pkg) 1127044330c1SMatt Fleming info->per_pkg = true; 112837932c18SAndi Kleen info->metric_expr = alias->metric_expr; 112996284814SAndi Kleen info->metric_name = alias->metric_name; 1130044330c1SMatt Fleming 1131a6146d50SZheng Yan list_del(&term->list); 1132a6146d50SZheng Yan free(term); 1133a6146d50SZheng Yan } 11348a398897SStephane Eranian 11358a398897SStephane Eranian /* 11368a398897SStephane Eranian * if no unit or scale foundin aliases, then 11378a398897SStephane Eranian * set defaults as for evsel 11388a398897SStephane Eranian * unit cannot left to NULL 11398a398897SStephane Eranian */ 114046441bdcSMatt Fleming if (info->unit == NULL) 114146441bdcSMatt Fleming info->unit = ""; 11428a398897SStephane Eranian 114346441bdcSMatt Fleming if (info->scale == 0.0) 114446441bdcSMatt Fleming info->scale = 1.0; 11458a398897SStephane Eranian 1146a6146d50SZheng Yan return 0; 1147a6146d50SZheng Yan } 1148a6146d50SZheng Yan 1149cd82a32eSJiri Olsa int perf_pmu__new_format(struct list_head *list, char *name, 1150cd82a32eSJiri Olsa int config, unsigned long *bits) 1151cd82a32eSJiri Olsa { 11525c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 1153cd82a32eSJiri Olsa 1154cd82a32eSJiri Olsa format = zalloc(sizeof(*format)); 1155cd82a32eSJiri Olsa if (!format) 1156cd82a32eSJiri Olsa return -ENOMEM; 1157cd82a32eSJiri Olsa 1158cd82a32eSJiri Olsa format->name = strdup(name); 1159cd82a32eSJiri Olsa format->value = config; 1160cd82a32eSJiri Olsa memcpy(format->bits, bits, sizeof(format->bits)); 1161cd82a32eSJiri Olsa 1162cd82a32eSJiri Olsa list_add_tail(&format->list, list); 1163cd82a32eSJiri Olsa return 0; 1164cd82a32eSJiri Olsa } 1165cd82a32eSJiri Olsa 1166cd82a32eSJiri Olsa void perf_pmu__set_format(unsigned long *bits, long from, long to) 1167cd82a32eSJiri Olsa { 1168cd82a32eSJiri Olsa long b; 1169cd82a32eSJiri Olsa 1170cd82a32eSJiri Olsa if (!to) 1171cd82a32eSJiri Olsa to = from; 1172cd82a32eSJiri Olsa 117315268138SSukadev Bhattiprolu memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 1174cd82a32eSJiri Olsa for (b = from; b <= to; b++) 1175cd82a32eSJiri Olsa set_bit(b, bits); 1176cd82a32eSJiri Olsa } 1177dc098b35SAndi Kleen 1178aaea3617SCody P Schafer static int sub_non_neg(int a, int b) 1179aaea3617SCody P Schafer { 1180aaea3617SCody P Schafer if (b > a) 1181aaea3617SCody P Schafer return 0; 1182aaea3617SCody P Schafer return a - b; 1183aaea3617SCody P Schafer } 1184aaea3617SCody P Schafer 1185dc098b35SAndi Kleen static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 1186dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1187dc098b35SAndi Kleen { 1188aaea3617SCody P Schafer struct parse_events_term *term; 1189aaea3617SCody P Schafer int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1190aaea3617SCody P Schafer 1191aaea3617SCody P Schafer list_for_each_entry(term, &alias->terms, list) { 1192aaea3617SCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1193aaea3617SCody P Schafer used += snprintf(buf + used, sub_non_neg(len, used), 1194aaea3617SCody P Schafer ",%s=%s", term->config, 1195aaea3617SCody P Schafer term->val.str); 1196aaea3617SCody P Schafer } 1197aaea3617SCody P Schafer 1198aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1199aaea3617SCody P Schafer buf[used] = '/'; 1200aaea3617SCody P Schafer used++; 1201aaea3617SCody P Schafer } 1202aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 1203aaea3617SCody P Schafer buf[used] = '\0'; 1204aaea3617SCody P Schafer used++; 1205aaea3617SCody P Schafer } else 1206aaea3617SCody P Schafer buf[len - 1] = '\0'; 1207aaea3617SCody P Schafer 1208dc098b35SAndi Kleen return buf; 1209dc098b35SAndi Kleen } 1210dc098b35SAndi Kleen 1211dc098b35SAndi Kleen static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 1212dc098b35SAndi Kleen struct perf_pmu_alias *alias) 1213dc098b35SAndi Kleen { 1214dc098b35SAndi Kleen snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 1215dc098b35SAndi Kleen return buf; 1216dc098b35SAndi Kleen } 1217dc098b35SAndi Kleen 1218dd5f1036SAndi Kleen struct sevent { 121908e60ed1SAndi Kleen char *name; 122008e60ed1SAndi Kleen char *desc; 1221dd5f1036SAndi Kleen char *topic; 1222f2361024SAndi Kleen char *str; 1223f2361024SAndi Kleen char *pmu; 12247f372a63SAndi Kleen char *metric_expr; 122596284814SAndi Kleen char *metric_name; 122608e60ed1SAndi Kleen }; 122708e60ed1SAndi Kleen 1228dd5f1036SAndi Kleen static int cmp_sevent(const void *a, const void *b) 1229dc098b35SAndi Kleen { 1230dd5f1036SAndi Kleen const struct sevent *as = a; 1231dd5f1036SAndi Kleen const struct sevent *bs = b; 123208e60ed1SAndi Kleen 123308e60ed1SAndi Kleen /* Put extra events last */ 123408e60ed1SAndi Kleen if (!!as->desc != !!bs->desc) 123508e60ed1SAndi Kleen return !!as->desc - !!bs->desc; 1236dd5f1036SAndi Kleen if (as->topic && bs->topic) { 1237dd5f1036SAndi Kleen int n = strcmp(as->topic, bs->topic); 1238dd5f1036SAndi Kleen 1239dd5f1036SAndi Kleen if (n) 1240dd5f1036SAndi Kleen return n; 1241dd5f1036SAndi Kleen } 124208e60ed1SAndi Kleen return strcmp(as->name, bs->name); 124308e60ed1SAndi Kleen } 124408e60ed1SAndi Kleen 124508e60ed1SAndi Kleen static void wordwrap(char *s, int start, int max, int corr) 124608e60ed1SAndi Kleen { 124708e60ed1SAndi Kleen int column = start; 124808e60ed1SAndi Kleen int n; 124908e60ed1SAndi Kleen 125008e60ed1SAndi Kleen while (*s) { 125108e60ed1SAndi Kleen int wlen = strcspn(s, " \t"); 125208e60ed1SAndi Kleen 125308e60ed1SAndi Kleen if (column + wlen >= max && column > start) { 125408e60ed1SAndi Kleen printf("\n%*s", start, ""); 125508e60ed1SAndi Kleen column = start + corr; 125608e60ed1SAndi Kleen } 125708e60ed1SAndi Kleen n = printf("%s%.*s", column > start ? " " : "", wlen, s); 125808e60ed1SAndi Kleen if (n <= 0) 125908e60ed1SAndi Kleen break; 126008e60ed1SAndi Kleen s += wlen; 126108e60ed1SAndi Kleen column += n; 1262aa4beb10STaeung Song s = ltrim(s); 126308e60ed1SAndi Kleen } 1264dc098b35SAndi Kleen } 1265dc098b35SAndi Kleen 1266c8d6828aSSukadev Bhattiprolu void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag, 1267bf874fcfSAndi Kleen bool long_desc, bool details_flag) 1268dc098b35SAndi Kleen { 1269dc098b35SAndi Kleen struct perf_pmu *pmu; 1270dc098b35SAndi Kleen struct perf_pmu_alias *alias; 1271dc098b35SAndi Kleen char buf[1024]; 1272dc098b35SAndi Kleen int printed = 0; 1273dc098b35SAndi Kleen int len, j; 1274dd5f1036SAndi Kleen struct sevent *aliases; 127508e60ed1SAndi Kleen int numdesc = 0; 127661eb2eb4SAndi Kleen int columns = pager_get_columns(); 1277dd5f1036SAndi Kleen char *topic = NULL; 1278dc098b35SAndi Kleen 1279dc098b35SAndi Kleen pmu = NULL; 1280dc098b35SAndi Kleen len = 0; 128142634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1282dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 1283dc098b35SAndi Kleen len++; 128442634bc7SAdrian Hunter if (pmu->selectable) 128542634bc7SAdrian Hunter len++; 128642634bc7SAdrian Hunter } 1287dd5f1036SAndi Kleen aliases = zalloc(sizeof(struct sevent) * len); 1288dc098b35SAndi Kleen if (!aliases) 12897e4772dcSArnaldo Carvalho de Melo goto out_enomem; 1290dc098b35SAndi Kleen pmu = NULL; 1291dc098b35SAndi Kleen j = 0; 129242634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1293dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) { 129408e60ed1SAndi Kleen char *name = alias->desc ? alias->name : 129508e60ed1SAndi Kleen format_alias(buf, sizeof(buf), pmu, alias); 1296dc098b35SAndi Kleen bool is_cpu = !strcmp(pmu->name, "cpu"); 1297dc098b35SAndi Kleen 1298dc098b35SAndi Kleen if (event_glob != NULL && 129938d14f0cSAndi Kleen !(strglobmatch_nocase(name, event_glob) || 130038d14f0cSAndi Kleen (!is_cpu && strglobmatch_nocase(alias->name, 130167bdc35fSAndi Kleen event_glob)) || 130267bdc35fSAndi Kleen (alias->topic && 130367bdc35fSAndi Kleen strglobmatch_nocase(alias->topic, event_glob)))) 1304dc098b35SAndi Kleen continue; 13057e4772dcSArnaldo Carvalho de Melo 130608e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 13077e4772dcSArnaldo Carvalho de Melo name = format_alias_or(buf, sizeof(buf), pmu, alias); 13087e4772dcSArnaldo Carvalho de Melo 130908e60ed1SAndi Kleen aliases[j].name = name; 131008e60ed1SAndi Kleen if (is_cpu && !name_only && !alias->desc) 131108e60ed1SAndi Kleen aliases[j].name = format_alias_or(buf, 131208e60ed1SAndi Kleen sizeof(buf), 131308e60ed1SAndi Kleen pmu, alias); 131408e60ed1SAndi Kleen aliases[j].name = strdup(aliases[j].name); 131508e60ed1SAndi Kleen if (!aliases[j].name) 13167e4772dcSArnaldo Carvalho de Melo goto out_enomem; 131708e60ed1SAndi Kleen 1318c8d6828aSSukadev Bhattiprolu aliases[j].desc = long_desc ? alias->long_desc : 1319c8d6828aSSukadev Bhattiprolu alias->desc; 1320dd5f1036SAndi Kleen aliases[j].topic = alias->topic; 1321f2361024SAndi Kleen aliases[j].str = alias->str; 1322f2361024SAndi Kleen aliases[j].pmu = pmu->name; 13237f372a63SAndi Kleen aliases[j].metric_expr = alias->metric_expr; 132496284814SAndi Kleen aliases[j].metric_name = alias->metric_name; 1325dc098b35SAndi Kleen j++; 1326dc098b35SAndi Kleen } 1327fa52ceabSArnaldo Carvalho de Melo if (pmu->selectable && 1328fa52ceabSArnaldo Carvalho de Melo (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 13297e4772dcSArnaldo Carvalho de Melo char *s; 13307e4772dcSArnaldo Carvalho de Melo if (asprintf(&s, "%s//", pmu->name) < 0) 13317e4772dcSArnaldo Carvalho de Melo goto out_enomem; 133208e60ed1SAndi Kleen aliases[j].name = s; 133342634bc7SAdrian Hunter j++; 133442634bc7SAdrian Hunter } 133542634bc7SAdrian Hunter } 1336dc098b35SAndi Kleen len = j; 1337dd5f1036SAndi Kleen qsort(aliases, len, sizeof(struct sevent), cmp_sevent); 1338dc098b35SAndi Kleen for (j = 0; j < len; j++) { 133915b22ed3SAndi Kleen /* Skip duplicates */ 134015b22ed3SAndi Kleen if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name)) 134115b22ed3SAndi Kleen continue; 1342dc098b35SAndi Kleen if (name_only) { 134308e60ed1SAndi Kleen printf("%s ", aliases[j].name); 1344dc098b35SAndi Kleen continue; 1345dc098b35SAndi Kleen } 13461c5f01feSAndi Kleen if (aliases[j].desc && !quiet_flag) { 134708e60ed1SAndi Kleen if (numdesc++ == 0) 134808e60ed1SAndi Kleen printf("\n"); 1349dd5f1036SAndi Kleen if (aliases[j].topic && (!topic || 1350dd5f1036SAndi Kleen strcmp(topic, aliases[j].topic))) { 1351dd5f1036SAndi Kleen printf("%s%s:\n", topic ? "\n" : "", 1352dd5f1036SAndi Kleen aliases[j].topic); 1353dd5f1036SAndi Kleen topic = aliases[j].topic; 1354dd5f1036SAndi Kleen } 135508e60ed1SAndi Kleen printf(" %-50s\n", aliases[j].name); 135608e60ed1SAndi Kleen printf("%*s", 8, "["); 135708e60ed1SAndi Kleen wordwrap(aliases[j].desc, 8, columns, 0); 135808e60ed1SAndi Kleen printf("]\n"); 1359bf874fcfSAndi Kleen if (details_flag) { 13607f372a63SAndi Kleen printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str); 136196284814SAndi Kleen if (aliases[j].metric_name) 136296284814SAndi Kleen printf(" MetricName: %s", aliases[j].metric_name); 13637f372a63SAndi Kleen if (aliases[j].metric_expr) 13647f372a63SAndi Kleen printf(" MetricExpr: %s", aliases[j].metric_expr); 13657f372a63SAndi Kleen putchar('\n'); 13667f372a63SAndi Kleen } 136708e60ed1SAndi Kleen } else 136808e60ed1SAndi Kleen printf(" %-50s [Kernel PMU event]\n", aliases[j].name); 1369dc098b35SAndi Kleen printed++; 1370dc098b35SAndi Kleen } 1371dfc431cbSArnaldo Carvalho de Melo if (printed && pager_in_use()) 1372dc098b35SAndi Kleen printf("\n"); 13737e4772dcSArnaldo Carvalho de Melo out_free: 13747e4772dcSArnaldo Carvalho de Melo for (j = 0; j < len; j++) 137508e60ed1SAndi Kleen zfree(&aliases[j].name); 13767e4772dcSArnaldo Carvalho de Melo zfree(&aliases); 13777e4772dcSArnaldo Carvalho de Melo return; 13787e4772dcSArnaldo Carvalho de Melo 13797e4772dcSArnaldo Carvalho de Melo out_enomem: 13807e4772dcSArnaldo Carvalho de Melo printf("FATAL: not enough memory to print PMU events\n"); 13817e4772dcSArnaldo Carvalho de Melo if (aliases) 13827e4772dcSArnaldo Carvalho de Melo goto out_free; 1383dc098b35SAndi Kleen } 13844cabc3d1SAndi Kleen 13854cabc3d1SAndi Kleen bool pmu_have_event(const char *pname, const char *name) 13864cabc3d1SAndi Kleen { 13874cabc3d1SAndi Kleen struct perf_pmu *pmu; 13884cabc3d1SAndi Kleen struct perf_pmu_alias *alias; 13894cabc3d1SAndi Kleen 13904cabc3d1SAndi Kleen pmu = NULL; 13914cabc3d1SAndi Kleen while ((pmu = perf_pmu__scan(pmu)) != NULL) { 13924cabc3d1SAndi Kleen if (strcmp(pname, pmu->name)) 13934cabc3d1SAndi Kleen continue; 13944cabc3d1SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 13954cabc3d1SAndi Kleen if (!strcmp(alias->name, name)) 13964cabc3d1SAndi Kleen return true; 13974cabc3d1SAndi Kleen } 13984cabc3d1SAndi Kleen return false; 13994cabc3d1SAndi Kleen } 14007d4bdab5SAdrian Hunter 14017d4bdab5SAdrian Hunter static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 14027d4bdab5SAdrian Hunter { 14037d4bdab5SAdrian Hunter struct stat st; 14047d4bdab5SAdrian Hunter char path[PATH_MAX]; 14057d4bdab5SAdrian Hunter const char *sysfs; 14067d4bdab5SAdrian Hunter 14077d4bdab5SAdrian Hunter sysfs = sysfs__mountpoint(); 14087d4bdab5SAdrian Hunter if (!sysfs) 14097d4bdab5SAdrian Hunter return NULL; 14107d4bdab5SAdrian Hunter 14117d4bdab5SAdrian Hunter snprintf(path, PATH_MAX, 14127d4bdab5SAdrian Hunter "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 14137d4bdab5SAdrian Hunter 14147d4bdab5SAdrian Hunter if (stat(path, &st) < 0) 14157d4bdab5SAdrian Hunter return NULL; 14167d4bdab5SAdrian Hunter 14177d4bdab5SAdrian Hunter return fopen(path, "r"); 14187d4bdab5SAdrian Hunter } 14197d4bdab5SAdrian Hunter 14207d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 14217d4bdab5SAdrian Hunter ...) 14227d4bdab5SAdrian Hunter { 14237d4bdab5SAdrian Hunter va_list args; 14247d4bdab5SAdrian Hunter FILE *file; 14257d4bdab5SAdrian Hunter int ret = EOF; 14267d4bdab5SAdrian Hunter 14277d4bdab5SAdrian Hunter va_start(args, fmt); 14287d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 14297d4bdab5SAdrian Hunter if (file) { 14307d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 14317d4bdab5SAdrian Hunter fclose(file); 14327d4bdab5SAdrian Hunter } 14337d4bdab5SAdrian Hunter va_end(args); 14347d4bdab5SAdrian Hunter return ret; 14357d4bdab5SAdrian Hunter } 1436