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" 15cd82a32eSJiri Olsa 16ab1bf653SArnaldo Carvalho de Melo struct perf_pmu_format { 17ab1bf653SArnaldo Carvalho de Melo char *name; 18ab1bf653SArnaldo Carvalho de Melo int value; 19ab1bf653SArnaldo Carvalho de Melo DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 20ab1bf653SArnaldo Carvalho de Melo struct list_head list; 21ab1bf653SArnaldo Carvalho de Melo }; 22ab1bf653SArnaldo Carvalho de Melo 2350a9667cSRobert Richter #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" 2450a9667cSRobert Richter 25cd82a32eSJiri Olsa int perf_pmu_parse(struct list_head *list, char *name); 26cd82a32eSJiri Olsa extern FILE *perf_pmu_in; 27cd82a32eSJiri Olsa 28cd82a32eSJiri Olsa static LIST_HEAD(pmus); 29cd82a32eSJiri Olsa 30cd82a32eSJiri Olsa /* 31cd82a32eSJiri Olsa * Parse & process all the sysfs attributes located under 32cd82a32eSJiri Olsa * the directory specified in 'dir' parameter. 33cd82a32eSJiri Olsa */ 34cff7f956SJiri Olsa int perf_pmu__format_parse(char *dir, struct list_head *head) 35cd82a32eSJiri Olsa { 36cd82a32eSJiri Olsa struct dirent *evt_ent; 37cd82a32eSJiri Olsa DIR *format_dir; 38cd82a32eSJiri Olsa int ret = 0; 39cd82a32eSJiri Olsa 40cd82a32eSJiri Olsa format_dir = opendir(dir); 41cd82a32eSJiri Olsa if (!format_dir) 42cd82a32eSJiri Olsa return -EINVAL; 43cd82a32eSJiri Olsa 44cd82a32eSJiri Olsa while (!ret && (evt_ent = readdir(format_dir))) { 45cd82a32eSJiri Olsa char path[PATH_MAX]; 46cd82a32eSJiri Olsa char *name = evt_ent->d_name; 47cd82a32eSJiri Olsa FILE *file; 48cd82a32eSJiri Olsa 49cd82a32eSJiri Olsa if (!strcmp(name, ".") || !strcmp(name, "..")) 50cd82a32eSJiri Olsa continue; 51cd82a32eSJiri Olsa 52cd82a32eSJiri Olsa snprintf(path, PATH_MAX, "%s/%s", dir, name); 53cd82a32eSJiri Olsa 54cd82a32eSJiri Olsa ret = -EINVAL; 55cd82a32eSJiri Olsa file = fopen(path, "r"); 56cd82a32eSJiri Olsa if (!file) 57cd82a32eSJiri Olsa break; 58cd82a32eSJiri Olsa 59cd82a32eSJiri Olsa perf_pmu_in = file; 60cd82a32eSJiri Olsa ret = perf_pmu_parse(head, name); 61cd82a32eSJiri Olsa fclose(file); 62cd82a32eSJiri Olsa } 63cd82a32eSJiri Olsa 64cd82a32eSJiri Olsa closedir(format_dir); 65cd82a32eSJiri Olsa return ret; 66cd82a32eSJiri Olsa } 67cd82a32eSJiri Olsa 68cd82a32eSJiri Olsa /* 69cd82a32eSJiri Olsa * Reading/parsing the default pmu format definition, which should be 70cd82a32eSJiri Olsa * located at: 71cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 72cd82a32eSJiri Olsa */ 73b6b96fb4SAdrian Hunter static int pmu_format(const char *name, struct list_head *format) 74cd82a32eSJiri Olsa { 75cd82a32eSJiri Olsa struct stat st; 76cd82a32eSJiri Olsa char path[PATH_MAX]; 77cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 78cd82a32eSJiri Olsa 79cd82a32eSJiri Olsa if (!sysfs) 80cd82a32eSJiri Olsa return -1; 81cd82a32eSJiri Olsa 82cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 8350a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 84cd82a32eSJiri Olsa 85cd82a32eSJiri Olsa if (stat(path, &st) < 0) 869bc8f9feSRobert Richter return 0; /* no error if format does not exist */ 87cd82a32eSJiri Olsa 88cff7f956SJiri Olsa if (perf_pmu__format_parse(path, format)) 89cd82a32eSJiri Olsa return -1; 90cd82a32eSJiri Olsa 91cd82a32eSJiri Olsa return 0; 92cd82a32eSJiri Olsa } 93cd82a32eSJiri Olsa 94410136f5SStephane Eranian static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 95410136f5SStephane Eranian { 96410136f5SStephane Eranian struct stat st; 97410136f5SStephane Eranian ssize_t sret; 98410136f5SStephane Eranian char scale[128]; 99410136f5SStephane Eranian int fd, ret = -1; 100410136f5SStephane Eranian char path[PATH_MAX]; 1018a398897SStephane Eranian const char *lc; 102410136f5SStephane Eranian 103410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 104410136f5SStephane Eranian 105410136f5SStephane Eranian fd = open(path, O_RDONLY); 106410136f5SStephane Eranian if (fd == -1) 107410136f5SStephane Eranian return -1; 108410136f5SStephane Eranian 109410136f5SStephane Eranian if (fstat(fd, &st) < 0) 110410136f5SStephane Eranian goto error; 111410136f5SStephane Eranian 112410136f5SStephane Eranian sret = read(fd, scale, sizeof(scale)-1); 113410136f5SStephane Eranian if (sret < 0) 114410136f5SStephane Eranian goto error; 115410136f5SStephane Eranian 1169ecae065SMadhavan Srinivasan if (scale[sret - 1] == '\n') 1179ecae065SMadhavan Srinivasan scale[sret - 1] = '\0'; 1189ecae065SMadhavan Srinivasan else 119410136f5SStephane Eranian scale[sret] = '\0'; 1209ecae065SMadhavan Srinivasan 121410136f5SStephane Eranian /* 122410136f5SStephane Eranian * save current locale 123410136f5SStephane Eranian */ 124410136f5SStephane Eranian lc = setlocale(LC_NUMERIC, NULL); 125410136f5SStephane Eranian 126410136f5SStephane Eranian /* 127410136f5SStephane Eranian * force to C locale to ensure kernel 128410136f5SStephane Eranian * scale string is converted correctly. 129410136f5SStephane Eranian * kernel uses default C locale. 130410136f5SStephane Eranian */ 131410136f5SStephane Eranian setlocale(LC_NUMERIC, "C"); 132410136f5SStephane Eranian 133410136f5SStephane Eranian alias->scale = strtod(scale, NULL); 134410136f5SStephane Eranian 135410136f5SStephane Eranian /* restore locale */ 136410136f5SStephane Eranian setlocale(LC_NUMERIC, lc); 137410136f5SStephane Eranian 138410136f5SStephane Eranian ret = 0; 139410136f5SStephane Eranian error: 140410136f5SStephane Eranian close(fd); 141410136f5SStephane Eranian return ret; 142410136f5SStephane Eranian } 143410136f5SStephane Eranian 144410136f5SStephane Eranian static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 145410136f5SStephane Eranian { 146410136f5SStephane Eranian char path[PATH_MAX]; 147410136f5SStephane Eranian ssize_t sret; 148410136f5SStephane Eranian int fd; 149410136f5SStephane Eranian 150410136f5SStephane Eranian snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 151410136f5SStephane Eranian 152410136f5SStephane Eranian fd = open(path, O_RDONLY); 153410136f5SStephane Eranian if (fd == -1) 154410136f5SStephane Eranian return -1; 155410136f5SStephane Eranian 156410136f5SStephane Eranian sret = read(fd, alias->unit, UNIT_MAX_LEN); 157410136f5SStephane Eranian if (sret < 0) 158410136f5SStephane Eranian goto error; 159410136f5SStephane Eranian 160410136f5SStephane Eranian close(fd); 161410136f5SStephane Eranian 1629ecae065SMadhavan Srinivasan if (alias->unit[sret - 1] == '\n') 1639ecae065SMadhavan Srinivasan alias->unit[sret - 1] = '\0'; 1649ecae065SMadhavan Srinivasan else 165410136f5SStephane Eranian alias->unit[sret] = '\0'; 166410136f5SStephane Eranian 167410136f5SStephane Eranian return 0; 168410136f5SStephane Eranian error: 169410136f5SStephane Eranian close(fd); 170410136f5SStephane Eranian alias->unit[0] = '\0'; 171410136f5SStephane Eranian return -1; 172410136f5SStephane Eranian } 173410136f5SStephane Eranian 174044330c1SMatt Fleming static int 175044330c1SMatt Fleming perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 176044330c1SMatt Fleming { 177044330c1SMatt Fleming char path[PATH_MAX]; 178044330c1SMatt Fleming int fd; 179044330c1SMatt Fleming 180044330c1SMatt Fleming snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 181044330c1SMatt Fleming 182044330c1SMatt Fleming fd = open(path, O_RDONLY); 183044330c1SMatt Fleming if (fd == -1) 184044330c1SMatt Fleming return -1; 185044330c1SMatt Fleming 186044330c1SMatt Fleming close(fd); 187044330c1SMatt Fleming 188044330c1SMatt Fleming alias->per_pkg = true; 189044330c1SMatt Fleming return 0; 190044330c1SMatt Fleming } 191044330c1SMatt Fleming 1921d9e446bSJiri Olsa static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 1931d9e446bSJiri Olsa char *dir, char *name) 1941d9e446bSJiri Olsa { 1951d9e446bSJiri Olsa char path[PATH_MAX]; 1961d9e446bSJiri Olsa int fd; 1971d9e446bSJiri Olsa 1981d9e446bSJiri Olsa snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 1991d9e446bSJiri Olsa 2001d9e446bSJiri Olsa fd = open(path, O_RDONLY); 2011d9e446bSJiri Olsa if (fd == -1) 2021d9e446bSJiri Olsa return -1; 2031d9e446bSJiri Olsa 2041d9e446bSJiri Olsa alias->snapshot = true; 2051d9e446bSJiri Olsa close(fd); 2061d9e446bSJiri Olsa return 0; 2071d9e446bSJiri Olsa } 2081d9e446bSJiri Olsa 20970c646e0SSukadev Bhattiprolu static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 21070c646e0SSukadev Bhattiprolu char *desc __maybe_unused, char *val) 211a6146d50SZheng Yan { 2125c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 213a6146d50SZheng Yan int ret; 214a6146d50SZheng Yan 215a6146d50SZheng Yan alias = malloc(sizeof(*alias)); 216a6146d50SZheng Yan if (!alias) 217a6146d50SZheng Yan return -ENOMEM; 218a6146d50SZheng Yan 219a6146d50SZheng Yan INIT_LIST_HEAD(&alias->terms); 220410136f5SStephane Eranian alias->scale = 1.0; 221410136f5SStephane Eranian alias->unit[0] = '\0'; 222044330c1SMatt Fleming alias->per_pkg = false; 223*84530920SStephane Eranian alias->snapshot = false; 224410136f5SStephane Eranian 22570c646e0SSukadev Bhattiprolu ret = parse_events_terms(&alias->terms, val); 226a6146d50SZheng Yan if (ret) { 22770c646e0SSukadev Bhattiprolu pr_err("Cannot parse alias %s: %d\n", val, ret); 228a6146d50SZheng Yan free(alias); 229a6146d50SZheng Yan return ret; 230a6146d50SZheng Yan } 231a6146d50SZheng Yan 232a6146d50SZheng Yan alias->name = strdup(name); 23370c646e0SSukadev Bhattiprolu if (dir) { 234410136f5SStephane Eranian /* 235410136f5SStephane Eranian * load unit name and scale if available 236410136f5SStephane Eranian */ 237410136f5SStephane Eranian perf_pmu__parse_unit(alias, dir, name); 238410136f5SStephane Eranian perf_pmu__parse_scale(alias, dir, name); 239044330c1SMatt Fleming perf_pmu__parse_per_pkg(alias, dir, name); 2401d9e446bSJiri Olsa perf_pmu__parse_snapshot(alias, dir, name); 24170c646e0SSukadev Bhattiprolu } 242410136f5SStephane Eranian 243a6146d50SZheng Yan list_add_tail(&alias->list, list); 244410136f5SStephane Eranian 245a6146d50SZheng Yan return 0; 246a6146d50SZheng Yan } 247a6146d50SZheng Yan 24870c646e0SSukadev Bhattiprolu static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 24970c646e0SSukadev Bhattiprolu { 25070c646e0SSukadev Bhattiprolu char buf[256]; 25170c646e0SSukadev Bhattiprolu int ret; 25270c646e0SSukadev Bhattiprolu 25370c646e0SSukadev Bhattiprolu ret = fread(buf, 1, sizeof(buf), file); 25470c646e0SSukadev Bhattiprolu if (ret == 0) 25570c646e0SSukadev Bhattiprolu return -EINVAL; 25670c646e0SSukadev Bhattiprolu 25770c646e0SSukadev Bhattiprolu buf[ret] = 0; 25870c646e0SSukadev Bhattiprolu 25970c646e0SSukadev Bhattiprolu return __perf_pmu__new_alias(list, dir, name, NULL, buf); 26070c646e0SSukadev Bhattiprolu } 26170c646e0SSukadev Bhattiprolu 26246441bdcSMatt Fleming static inline bool pmu_alias_info_file(char *name) 26346441bdcSMatt Fleming { 26446441bdcSMatt Fleming size_t len; 26546441bdcSMatt Fleming 26646441bdcSMatt Fleming len = strlen(name); 26746441bdcSMatt Fleming if (len > 5 && !strcmp(name + len - 5, ".unit")) 26846441bdcSMatt Fleming return true; 26946441bdcSMatt Fleming if (len > 6 && !strcmp(name + len - 6, ".scale")) 27046441bdcSMatt Fleming return true; 271044330c1SMatt Fleming if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 272044330c1SMatt Fleming return true; 2731d9e446bSJiri Olsa if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 2741d9e446bSJiri Olsa return true; 27546441bdcSMatt Fleming 27646441bdcSMatt Fleming return false; 27746441bdcSMatt Fleming } 27846441bdcSMatt Fleming 279a6146d50SZheng Yan /* 280a6146d50SZheng Yan * Process all the sysfs attributes located under the directory 281a6146d50SZheng Yan * specified in 'dir' parameter. 282a6146d50SZheng Yan */ 283a6146d50SZheng Yan static int pmu_aliases_parse(char *dir, struct list_head *head) 284a6146d50SZheng Yan { 285a6146d50SZheng Yan struct dirent *evt_ent; 286a6146d50SZheng Yan DIR *event_dir; 287a6146d50SZheng Yan int ret = 0; 288a6146d50SZheng Yan 289a6146d50SZheng Yan event_dir = opendir(dir); 290a6146d50SZheng Yan if (!event_dir) 291a6146d50SZheng Yan return -EINVAL; 292a6146d50SZheng Yan 293a6146d50SZheng Yan while (!ret && (evt_ent = readdir(event_dir))) { 294a6146d50SZheng Yan char path[PATH_MAX]; 295a6146d50SZheng Yan char *name = evt_ent->d_name; 296a6146d50SZheng Yan FILE *file; 297a6146d50SZheng Yan 298a6146d50SZheng Yan if (!strcmp(name, ".") || !strcmp(name, "..")) 299a6146d50SZheng Yan continue; 300a6146d50SZheng Yan 301410136f5SStephane Eranian /* 30246441bdcSMatt Fleming * skip info files parsed in perf_pmu__new_alias() 303410136f5SStephane Eranian */ 30446441bdcSMatt Fleming if (pmu_alias_info_file(name)) 305410136f5SStephane Eranian continue; 306410136f5SStephane Eranian 307a6146d50SZheng Yan snprintf(path, PATH_MAX, "%s/%s", dir, name); 308a6146d50SZheng Yan 309a6146d50SZheng Yan ret = -EINVAL; 310a6146d50SZheng Yan file = fopen(path, "r"); 311a6146d50SZheng Yan if (!file) 312a6146d50SZheng Yan break; 313410136f5SStephane Eranian 314410136f5SStephane Eranian ret = perf_pmu__new_alias(head, dir, name, file); 315a6146d50SZheng Yan fclose(file); 316a6146d50SZheng Yan } 317a6146d50SZheng Yan 318a6146d50SZheng Yan closedir(event_dir); 319a6146d50SZheng Yan return ret; 320a6146d50SZheng Yan } 321a6146d50SZheng Yan 322a6146d50SZheng Yan /* 323a6146d50SZheng Yan * Reading the pmu event aliases definition, which should be located at: 324a6146d50SZheng Yan * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 325a6146d50SZheng Yan */ 326b6b96fb4SAdrian Hunter static int pmu_aliases(const char *name, struct list_head *head) 327a6146d50SZheng Yan { 328a6146d50SZheng Yan struct stat st; 329a6146d50SZheng Yan char path[PATH_MAX]; 330cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 331a6146d50SZheng Yan 332a6146d50SZheng Yan if (!sysfs) 333a6146d50SZheng Yan return -1; 334a6146d50SZheng Yan 335a6146d50SZheng Yan snprintf(path, PATH_MAX, 336a6146d50SZheng Yan "%s/bus/event_source/devices/%s/events", sysfs, name); 337a6146d50SZheng Yan 338a6146d50SZheng Yan if (stat(path, &st) < 0) 3393fded963SJiri Olsa return 0; /* no error if 'events' does not exist */ 340a6146d50SZheng Yan 341a6146d50SZheng Yan if (pmu_aliases_parse(path, head)) 342a6146d50SZheng Yan return -1; 343a6146d50SZheng Yan 344a6146d50SZheng Yan return 0; 345a6146d50SZheng Yan } 346a6146d50SZheng Yan 3475c6ccc37SArnaldo Carvalho de Melo static int pmu_alias_terms(struct perf_pmu_alias *alias, 348a6146d50SZheng Yan struct list_head *terms) 349a6146d50SZheng Yan { 3507c2f8164SJiri Olsa struct parse_events_term *term, *cloned; 351a6146d50SZheng Yan LIST_HEAD(list); 352a6146d50SZheng Yan int ret; 353a6146d50SZheng Yan 354a6146d50SZheng Yan list_for_each_entry(term, &alias->terms, list) { 3557c2f8164SJiri Olsa ret = parse_events_term__clone(&cloned, term); 356a6146d50SZheng Yan if (ret) { 357a6146d50SZheng Yan parse_events__free_terms(&list); 358a6146d50SZheng Yan return ret; 359a6146d50SZheng Yan } 3607c2f8164SJiri Olsa list_add_tail(&cloned->list, &list); 361a6146d50SZheng Yan } 362a6146d50SZheng Yan list_splice(&list, terms); 363a6146d50SZheng Yan return 0; 364a6146d50SZheng Yan } 365a6146d50SZheng Yan 366cd82a32eSJiri Olsa /* 367cd82a32eSJiri Olsa * Reading/parsing the default pmu type value, which should be 368cd82a32eSJiri Olsa * located at: 369cd82a32eSJiri Olsa * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 370cd82a32eSJiri Olsa */ 371b6b96fb4SAdrian Hunter static int pmu_type(const char *name, __u32 *type) 372cd82a32eSJiri Olsa { 373cd82a32eSJiri Olsa struct stat st; 374cd82a32eSJiri Olsa char path[PATH_MAX]; 375cd82a32eSJiri Olsa FILE *file; 376cd82a32eSJiri Olsa int ret = 0; 377cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 378cd82a32eSJiri Olsa 379cd82a32eSJiri Olsa if (!sysfs) 380cd82a32eSJiri Olsa return -1; 381cd82a32eSJiri Olsa 382cd82a32eSJiri Olsa snprintf(path, PATH_MAX, 38350a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 384cd82a32eSJiri Olsa 385cd82a32eSJiri Olsa if (stat(path, &st) < 0) 386cd82a32eSJiri Olsa return -1; 387cd82a32eSJiri Olsa 388cd82a32eSJiri Olsa file = fopen(path, "r"); 389cd82a32eSJiri Olsa if (!file) 390cd82a32eSJiri Olsa return -EINVAL; 391cd82a32eSJiri Olsa 392cd82a32eSJiri Olsa if (1 != fscanf(file, "%u", type)) 393cd82a32eSJiri Olsa ret = -1; 394cd82a32eSJiri Olsa 395cd82a32eSJiri Olsa fclose(file); 396cd82a32eSJiri Olsa return ret; 397cd82a32eSJiri Olsa } 398cd82a32eSJiri Olsa 39950a9667cSRobert Richter /* Add all pmus in sysfs to pmu list: */ 40050a9667cSRobert Richter static void pmu_read_sysfs(void) 40150a9667cSRobert Richter { 40250a9667cSRobert Richter char path[PATH_MAX]; 40350a9667cSRobert Richter DIR *dir; 40450a9667cSRobert Richter struct dirent *dent; 405cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 40650a9667cSRobert Richter 40750a9667cSRobert Richter if (!sysfs) 40850a9667cSRobert Richter return; 40950a9667cSRobert Richter 41050a9667cSRobert Richter snprintf(path, PATH_MAX, 41150a9667cSRobert Richter "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 41250a9667cSRobert Richter 41350a9667cSRobert Richter dir = opendir(path); 41450a9667cSRobert Richter if (!dir) 41550a9667cSRobert Richter return; 41650a9667cSRobert Richter 41750a9667cSRobert Richter while ((dent = readdir(dir))) { 41850a9667cSRobert Richter if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 41950a9667cSRobert Richter continue; 42050a9667cSRobert Richter /* add to static LIST_HEAD(pmus): */ 42150a9667cSRobert Richter perf_pmu__find(dent->d_name); 42250a9667cSRobert Richter } 42350a9667cSRobert Richter 42450a9667cSRobert Richter closedir(dir); 42550a9667cSRobert Richter } 42650a9667cSRobert Richter 427b6b96fb4SAdrian Hunter static struct cpu_map *pmu_cpumask(const char *name) 4287ae92e74SYan, Zheng { 4297ae92e74SYan, Zheng struct stat st; 4307ae92e74SYan, Zheng char path[PATH_MAX]; 4317ae92e74SYan, Zheng FILE *file; 4327ae92e74SYan, Zheng struct cpu_map *cpus; 433cf38fadaSArnaldo Carvalho de Melo const char *sysfs = sysfs__mountpoint(); 4347ae92e74SYan, Zheng 4357ae92e74SYan, Zheng if (!sysfs) 4367ae92e74SYan, Zheng return NULL; 4377ae92e74SYan, Zheng 4387ae92e74SYan, Zheng snprintf(path, PATH_MAX, 4397ae92e74SYan, Zheng "%s/bus/event_source/devices/%s/cpumask", sysfs, name); 4407ae92e74SYan, Zheng 4417ae92e74SYan, Zheng if (stat(path, &st) < 0) 4427ae92e74SYan, Zheng return NULL; 4437ae92e74SYan, Zheng 4447ae92e74SYan, Zheng file = fopen(path, "r"); 4457ae92e74SYan, Zheng if (!file) 4467ae92e74SYan, Zheng return NULL; 4477ae92e74SYan, Zheng 4487ae92e74SYan, Zheng cpus = cpu_map__read(file); 4497ae92e74SYan, Zheng fclose(file); 4507ae92e74SYan, Zheng return cpus; 4517ae92e74SYan, Zheng } 4527ae92e74SYan, Zheng 453c5de47f2SSukadev Bhattiprolu struct perf_event_attr * __weak 454dc0a6202SAdrian Hunter perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 455dc0a6202SAdrian Hunter { 456dc0a6202SAdrian Hunter return NULL; 457dc0a6202SAdrian Hunter } 458dc0a6202SAdrian Hunter 459b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_lookup(const char *name) 460cd82a32eSJiri Olsa { 461cd82a32eSJiri Olsa struct perf_pmu *pmu; 462cd82a32eSJiri Olsa LIST_HEAD(format); 463a6146d50SZheng Yan LIST_HEAD(aliases); 464cd82a32eSJiri Olsa __u32 type; 465cd82a32eSJiri Olsa 466cd82a32eSJiri Olsa /* 467cd82a32eSJiri Olsa * The pmu data we store & need consists of the pmu 468cd82a32eSJiri Olsa * type value and format definitions. Load both right 469cd82a32eSJiri Olsa * now. 470cd82a32eSJiri Olsa */ 471cd82a32eSJiri Olsa if (pmu_format(name, &format)) 472cd82a32eSJiri Olsa return NULL; 473cd82a32eSJiri Olsa 4743fded963SJiri Olsa if (pmu_aliases(name, &aliases)) 4753fded963SJiri Olsa return NULL; 4763fded963SJiri Olsa 477cd82a32eSJiri Olsa if (pmu_type(name, &type)) 478cd82a32eSJiri Olsa return NULL; 479cd82a32eSJiri Olsa 480cd82a32eSJiri Olsa pmu = zalloc(sizeof(*pmu)); 481cd82a32eSJiri Olsa if (!pmu) 482cd82a32eSJiri Olsa return NULL; 483cd82a32eSJiri Olsa 4847ae92e74SYan, Zheng pmu->cpus = pmu_cpumask(name); 4857ae92e74SYan, Zheng 486cd82a32eSJiri Olsa INIT_LIST_HEAD(&pmu->format); 487a6146d50SZheng Yan INIT_LIST_HEAD(&pmu->aliases); 488cd82a32eSJiri Olsa list_splice(&format, &pmu->format); 489a6146d50SZheng Yan list_splice(&aliases, &pmu->aliases); 490cd82a32eSJiri Olsa pmu->name = strdup(name); 491cd82a32eSJiri Olsa pmu->type = type; 4929bc8f9feSRobert Richter list_add_tail(&pmu->list, &pmus); 493dc0a6202SAdrian Hunter 494dc0a6202SAdrian Hunter pmu->default_config = perf_pmu__get_default_config(pmu); 495dc0a6202SAdrian Hunter 496cd82a32eSJiri Olsa return pmu; 497cd82a32eSJiri Olsa } 498cd82a32eSJiri Olsa 499b6b96fb4SAdrian Hunter static struct perf_pmu *pmu_find(const char *name) 500cd82a32eSJiri Olsa { 501cd82a32eSJiri Olsa struct perf_pmu *pmu; 502cd82a32eSJiri Olsa 503cd82a32eSJiri Olsa list_for_each_entry(pmu, &pmus, list) 504cd82a32eSJiri Olsa if (!strcmp(pmu->name, name)) 505cd82a32eSJiri Olsa return pmu; 506cd82a32eSJiri Olsa 507cd82a32eSJiri Olsa return NULL; 508cd82a32eSJiri Olsa } 509cd82a32eSJiri Olsa 51050a9667cSRobert Richter struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 51150a9667cSRobert Richter { 51250a9667cSRobert Richter /* 51350a9667cSRobert Richter * pmu iterator: If pmu is NULL, we start at the begin, 51450a9667cSRobert Richter * otherwise return the next pmu. Returns NULL on end. 51550a9667cSRobert Richter */ 51650a9667cSRobert Richter if (!pmu) { 51750a9667cSRobert Richter pmu_read_sysfs(); 51850a9667cSRobert Richter pmu = list_prepare_entry(pmu, &pmus, list); 51950a9667cSRobert Richter } 52050a9667cSRobert Richter list_for_each_entry_continue(pmu, &pmus, list) 52150a9667cSRobert Richter return pmu; 52250a9667cSRobert Richter return NULL; 52350a9667cSRobert Richter } 52450a9667cSRobert Richter 525b6b96fb4SAdrian Hunter struct perf_pmu *perf_pmu__find(const char *name) 526cd82a32eSJiri Olsa { 527cd82a32eSJiri Olsa struct perf_pmu *pmu; 528cd82a32eSJiri Olsa 529cd82a32eSJiri Olsa /* 530cd82a32eSJiri Olsa * Once PMU is loaded it stays in the list, 531cd82a32eSJiri Olsa * so we keep us from multiple reading/parsing 532cd82a32eSJiri Olsa * the pmu format definitions. 533cd82a32eSJiri Olsa */ 534cd82a32eSJiri Olsa pmu = pmu_find(name); 535cd82a32eSJiri Olsa if (pmu) 536cd82a32eSJiri Olsa return pmu; 537cd82a32eSJiri Olsa 538cd82a32eSJiri Olsa return pmu_lookup(name); 539cd82a32eSJiri Olsa } 540cd82a32eSJiri Olsa 5415c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_format * 54209ff6071SAdrian Hunter pmu_find_format(struct list_head *formats, const char *name) 543cd82a32eSJiri Olsa { 5445c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 545cd82a32eSJiri Olsa 546cd82a32eSJiri Olsa list_for_each_entry(format, formats, list) 547cd82a32eSJiri Olsa if (!strcmp(format->name, name)) 548cd82a32eSJiri Olsa return format; 549cd82a32eSJiri Olsa 550cd82a32eSJiri Olsa return NULL; 551cd82a32eSJiri Olsa } 552cd82a32eSJiri Olsa 55309ff6071SAdrian Hunter __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 55409ff6071SAdrian Hunter { 55509ff6071SAdrian Hunter struct perf_pmu_format *format = pmu_find_format(formats, name); 55609ff6071SAdrian Hunter __u64 bits = 0; 55709ff6071SAdrian Hunter int fbit; 55809ff6071SAdrian Hunter 55909ff6071SAdrian Hunter if (!format) 56009ff6071SAdrian Hunter return 0; 56109ff6071SAdrian Hunter 56209ff6071SAdrian Hunter for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 56309ff6071SAdrian Hunter bits |= 1ULL << fbit; 56409ff6071SAdrian Hunter 56509ff6071SAdrian Hunter return bits; 56609ff6071SAdrian Hunter } 56709ff6071SAdrian Hunter 568cd82a32eSJiri Olsa /* 569dc0a6202SAdrian Hunter * Sets value based on the format definition (format parameter) 570cd82a32eSJiri Olsa * and unformated value (value parameter). 571cd82a32eSJiri Olsa */ 572dc0a6202SAdrian Hunter static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 573dc0a6202SAdrian Hunter bool zero) 574cd82a32eSJiri Olsa { 575cd82a32eSJiri Olsa unsigned long fbit, vbit; 576cd82a32eSJiri Olsa 577cd82a32eSJiri Olsa for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 578cd82a32eSJiri Olsa 579cd82a32eSJiri Olsa if (!test_bit(fbit, format)) 580cd82a32eSJiri Olsa continue; 581cd82a32eSJiri Olsa 582dc0a6202SAdrian Hunter if (value & (1llu << vbit++)) 583dc0a6202SAdrian Hunter *v |= (1llu << fbit); 584dc0a6202SAdrian Hunter else if (zero) 585dc0a6202SAdrian Hunter *v &= ~(1llu << fbit); 586cd82a32eSJiri Olsa } 587cd82a32eSJiri Olsa } 588cd82a32eSJiri Olsa 5890efe6b67SAdrian Hunter static __u64 pmu_format_max_value(const unsigned long *format) 5900efe6b67SAdrian Hunter { 5910efe6b67SAdrian Hunter int w; 5920efe6b67SAdrian Hunter 5930efe6b67SAdrian Hunter w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 5940efe6b67SAdrian Hunter if (!w) 5950efe6b67SAdrian Hunter return 0; 5960efe6b67SAdrian Hunter if (w < 64) 5970efe6b67SAdrian Hunter return (1ULL << w) - 1; 5980efe6b67SAdrian Hunter return -1; 5990efe6b67SAdrian Hunter } 6000efe6b67SAdrian Hunter 601cd82a32eSJiri Olsa /* 602688d4dfcSCody P Schafer * Term is a string term, and might be a param-term. Try to look up it's value 603688d4dfcSCody P Schafer * in the remaining terms. 604688d4dfcSCody P Schafer * - We have a term like "base-or-format-term=param-term", 605688d4dfcSCody P Schafer * - We need to find the value supplied for "param-term" (with param-term named 606688d4dfcSCody P Schafer * in a config string) later on in the term list. 607688d4dfcSCody P Schafer */ 608688d4dfcSCody P Schafer static int pmu_resolve_param_term(struct parse_events_term *term, 609688d4dfcSCody P Schafer struct list_head *head_terms, 610688d4dfcSCody P Schafer __u64 *value) 611688d4dfcSCody P Schafer { 612688d4dfcSCody P Schafer struct parse_events_term *t; 613688d4dfcSCody P Schafer 614688d4dfcSCody P Schafer list_for_each_entry(t, head_terms, list) { 615688d4dfcSCody P Schafer if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 616688d4dfcSCody P Schafer if (!strcmp(t->config, term->config)) { 617688d4dfcSCody P Schafer t->used = true; 618688d4dfcSCody P Schafer *value = t->val.num; 619688d4dfcSCody P Schafer return 0; 620688d4dfcSCody P Schafer } 621688d4dfcSCody P Schafer } 622688d4dfcSCody P Schafer } 623688d4dfcSCody P Schafer 624688d4dfcSCody P Schafer if (verbose) 625688d4dfcSCody P Schafer printf("Required parameter '%s' not specified\n", term->config); 626688d4dfcSCody P Schafer 627688d4dfcSCody P Schafer return -1; 628688d4dfcSCody P Schafer } 629688d4dfcSCody P Schafer 630ffeb883eSHe Kuang static char *pmu_formats_string(struct list_head *formats) 631e64b020bSJiri Olsa { 632e64b020bSJiri Olsa struct perf_pmu_format *format; 633ffeb883eSHe Kuang char *str; 634ffeb883eSHe Kuang struct strbuf buf; 635e64b020bSJiri Olsa unsigned i = 0; 636e64b020bSJiri Olsa 637ffeb883eSHe Kuang if (!formats) 638e64b020bSJiri Olsa return NULL; 639e64b020bSJiri Olsa 640ffeb883eSHe Kuang strbuf_init(&buf, 0); 641e64b020bSJiri Olsa /* sysfs exported terms */ 642ffeb883eSHe Kuang list_for_each_entry(format, formats, list) 643ffeb883eSHe Kuang strbuf_addf(&buf, i++ ? ",%s" : "%s", 644ffeb883eSHe Kuang format->name); 645e64b020bSJiri Olsa 646ffeb883eSHe Kuang str = strbuf_detach(&buf, NULL); 647ffeb883eSHe Kuang strbuf_release(&buf); 648e64b020bSJiri Olsa 649e64b020bSJiri Olsa return str; 650e64b020bSJiri Olsa } 651e64b020bSJiri Olsa 652688d4dfcSCody P Schafer /* 653cd82a32eSJiri Olsa * Setup one of config[12] attr members based on the 65488aca8d9SCody P Schafer * user input data - term parameter. 655cd82a32eSJiri Olsa */ 656cd82a32eSJiri Olsa static int pmu_config_term(struct list_head *formats, 657cd82a32eSJiri Olsa struct perf_event_attr *attr, 658dc0a6202SAdrian Hunter struct parse_events_term *term, 659688d4dfcSCody P Schafer struct list_head *head_terms, 660e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 661cd82a32eSJiri Olsa { 6625c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 663cd82a32eSJiri Olsa __u64 *vp; 6640efe6b67SAdrian Hunter __u64 val, max_val; 665cd82a32eSJiri Olsa 666cd82a32eSJiri Olsa /* 667688d4dfcSCody P Schafer * If this is a parameter we've already used for parameterized-eval, 668688d4dfcSCody P Schafer * skip it in normal eval. 669688d4dfcSCody P Schafer */ 670688d4dfcSCody P Schafer if (term->used) 671688d4dfcSCody P Schafer return 0; 672688d4dfcSCody P Schafer 673688d4dfcSCody P Schafer /* 674cd82a32eSJiri Olsa * Hardcoded terms should be already in, so nothing 675cd82a32eSJiri Olsa * to be done for them. 676cd82a32eSJiri Olsa */ 677cd82a32eSJiri Olsa if (parse_events__is_hardcoded_term(term)) 678cd82a32eSJiri Olsa return 0; 679cd82a32eSJiri Olsa 680cd82a32eSJiri Olsa format = pmu_find_format(formats, term->config); 681688d4dfcSCody P Schafer if (!format) { 682688d4dfcSCody P Schafer if (verbose) 683688d4dfcSCody P Schafer printf("Invalid event/parameter '%s'\n", term->config); 684e64b020bSJiri Olsa if (err) { 685ffeb883eSHe Kuang char *pmu_term = pmu_formats_string(formats); 686ffeb883eSHe Kuang 687e64b020bSJiri Olsa err->idx = term->err_term; 688e64b020bSJiri Olsa err->str = strdup("unknown term"); 689ffeb883eSHe Kuang err->help = parse_events_formats_error_string(pmu_term); 690ffeb883eSHe Kuang free(pmu_term); 691e64b020bSJiri Olsa } 692cd82a32eSJiri Olsa return -EINVAL; 693688d4dfcSCody P Schafer } 694cd82a32eSJiri Olsa 695cd82a32eSJiri Olsa switch (format->value) { 696cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG: 697cd82a32eSJiri Olsa vp = &attr->config; 698cd82a32eSJiri Olsa break; 699cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG1: 700cd82a32eSJiri Olsa vp = &attr->config1; 701cd82a32eSJiri Olsa break; 702cd82a32eSJiri Olsa case PERF_PMU_FORMAT_VALUE_CONFIG2: 703cd82a32eSJiri Olsa vp = &attr->config2; 704cd82a32eSJiri Olsa break; 705cd82a32eSJiri Olsa default: 706cd82a32eSJiri Olsa return -EINVAL; 707cd82a32eSJiri Olsa } 708cd82a32eSJiri Olsa 70916fa7e82SJiri Olsa /* 710688d4dfcSCody P Schafer * Either directly use a numeric term, or try to translate string terms 711688d4dfcSCody P Schafer * using event parameters. 71216fa7e82SJiri Olsa */ 713688d4dfcSCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 714688d4dfcSCody P Schafer val = term->val.num; 715688d4dfcSCody P Schafer else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 716688d4dfcSCody P Schafer if (strcmp(term->val.str, "?")) { 717e64b020bSJiri Olsa if (verbose) { 718688d4dfcSCody P Schafer pr_info("Invalid sysfs entry %s=%s\n", 719688d4dfcSCody P Schafer term->config, term->val.str); 720e64b020bSJiri Olsa } 721e64b020bSJiri Olsa if (err) { 722e64b020bSJiri Olsa err->idx = term->err_val; 723e64b020bSJiri Olsa err->str = strdup("expected numeric value"); 724e64b020bSJiri Olsa } 725688d4dfcSCody P Schafer return -EINVAL; 726688d4dfcSCody P Schafer } 727688d4dfcSCody P Schafer 728688d4dfcSCody P Schafer if (pmu_resolve_param_term(term, head_terms, &val)) 729688d4dfcSCody P Schafer return -EINVAL; 730688d4dfcSCody P Schafer } else 731688d4dfcSCody P Schafer return -EINVAL; 732688d4dfcSCody P Schafer 7330efe6b67SAdrian Hunter max_val = pmu_format_max_value(format->bits); 7340efe6b67SAdrian Hunter if (val > max_val) { 7350efe6b67SAdrian Hunter if (err) { 7360efe6b67SAdrian Hunter err->idx = term->err_val; 7370efe6b67SAdrian Hunter if (asprintf(&err->str, 7380efe6b67SAdrian Hunter "value too big for format, maximum is %llu", 7390efe6b67SAdrian Hunter (unsigned long long)max_val) < 0) 7400efe6b67SAdrian Hunter err->str = strdup("value too big for format"); 7410efe6b67SAdrian Hunter return -EINVAL; 7420efe6b67SAdrian Hunter } 7430efe6b67SAdrian Hunter /* 7440efe6b67SAdrian Hunter * Assume we don't care if !err, in which case the value will be 7450efe6b67SAdrian Hunter * silently truncated. 7460efe6b67SAdrian Hunter */ 7470efe6b67SAdrian Hunter } 7480efe6b67SAdrian Hunter 749688d4dfcSCody P Schafer pmu_format_value(format->bits, val, vp, zero); 750cd82a32eSJiri Olsa return 0; 751cd82a32eSJiri Olsa } 752cd82a32eSJiri Olsa 753cff7f956SJiri Olsa int perf_pmu__config_terms(struct list_head *formats, 754cff7f956SJiri Olsa struct perf_event_attr *attr, 755dc0a6202SAdrian Hunter struct list_head *head_terms, 756e64b020bSJiri Olsa bool zero, struct parse_events_error *err) 757cd82a32eSJiri Olsa { 7586cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 759cd82a32eSJiri Olsa 760688d4dfcSCody P Schafer list_for_each_entry(term, head_terms, list) { 761e64b020bSJiri Olsa if (pmu_config_term(formats, attr, term, head_terms, 762e64b020bSJiri Olsa zero, err)) 763cd82a32eSJiri Olsa return -EINVAL; 764688d4dfcSCody P Schafer } 765cd82a32eSJiri Olsa 766cd82a32eSJiri Olsa return 0; 767cd82a32eSJiri Olsa } 768cd82a32eSJiri Olsa 769cd82a32eSJiri Olsa /* 770cd82a32eSJiri Olsa * Configures event's 'attr' parameter based on the: 771cd82a32eSJiri Olsa * 1) users input - specified in terms parameter 772cd82a32eSJiri Olsa * 2) pmu format definitions - specified by pmu parameter 773cd82a32eSJiri Olsa */ 774cd82a32eSJiri Olsa int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 775e64b020bSJiri Olsa struct list_head *head_terms, 776e64b020bSJiri Olsa struct parse_events_error *err) 777cd82a32eSJiri Olsa { 778dc0a6202SAdrian Hunter bool zero = !!pmu->default_config; 779dc0a6202SAdrian Hunter 780cd82a32eSJiri Olsa attr->type = pmu->type; 781e64b020bSJiri Olsa return perf_pmu__config_terms(&pmu->format, attr, head_terms, 782e64b020bSJiri Olsa zero, err); 783cd82a32eSJiri Olsa } 784cd82a32eSJiri Olsa 7855c6ccc37SArnaldo Carvalho de Melo static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 7866cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 787a6146d50SZheng Yan { 7885c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 789a6146d50SZheng Yan char *name; 790a6146d50SZheng Yan 791a6146d50SZheng Yan if (parse_events__is_hardcoded_term(term)) 792a6146d50SZheng Yan return NULL; 793a6146d50SZheng Yan 794a6146d50SZheng Yan if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 795a6146d50SZheng Yan if (term->val.num != 1) 796a6146d50SZheng Yan return NULL; 797a6146d50SZheng Yan if (pmu_find_format(&pmu->format, term->config)) 798a6146d50SZheng Yan return NULL; 799a6146d50SZheng Yan name = term->config; 800a6146d50SZheng Yan } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 801a6146d50SZheng Yan if (strcasecmp(term->config, "event")) 802a6146d50SZheng Yan return NULL; 803a6146d50SZheng Yan name = term->val.str; 804a6146d50SZheng Yan } else { 805a6146d50SZheng Yan return NULL; 806a6146d50SZheng Yan } 807a6146d50SZheng Yan 808a6146d50SZheng Yan list_for_each_entry(alias, &pmu->aliases, list) { 809a6146d50SZheng Yan if (!strcasecmp(alias->name, name)) 810a6146d50SZheng Yan return alias; 811a6146d50SZheng Yan } 812a6146d50SZheng Yan return NULL; 813a6146d50SZheng Yan } 814a6146d50SZheng Yan 815410136f5SStephane Eranian 8161d9e446bSJiri Olsa static int check_info_data(struct perf_pmu_alias *alias, 8171d9e446bSJiri Olsa struct perf_pmu_info *info) 818410136f5SStephane Eranian { 819410136f5SStephane Eranian /* 820410136f5SStephane Eranian * Only one term in event definition can 8211d9e446bSJiri Olsa * define unit, scale and snapshot, fail 8221d9e446bSJiri Olsa * if there's more than one. 823410136f5SStephane Eranian */ 8241d9e446bSJiri Olsa if ((info->unit && alias->unit) || 8251d9e446bSJiri Olsa (info->scale && alias->scale) || 8261d9e446bSJiri Olsa (info->snapshot && alias->snapshot)) 827410136f5SStephane Eranian return -EINVAL; 828410136f5SStephane Eranian 829410136f5SStephane Eranian if (alias->unit) 8301d9e446bSJiri Olsa info->unit = alias->unit; 831410136f5SStephane Eranian 832410136f5SStephane Eranian if (alias->scale) 8331d9e446bSJiri Olsa info->scale = alias->scale; 8341d9e446bSJiri Olsa 8351d9e446bSJiri Olsa if (alias->snapshot) 8361d9e446bSJiri Olsa info->snapshot = alias->snapshot; 837410136f5SStephane Eranian 838410136f5SStephane Eranian return 0; 839410136f5SStephane Eranian } 840410136f5SStephane Eranian 841a6146d50SZheng Yan /* 842a6146d50SZheng Yan * Find alias in the terms list and replace it with the terms 843a6146d50SZheng Yan * defined for the alias 844a6146d50SZheng Yan */ 845410136f5SStephane Eranian int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 84646441bdcSMatt Fleming struct perf_pmu_info *info) 847a6146d50SZheng Yan { 8486cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 8495c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_alias *alias; 850a6146d50SZheng Yan int ret; 851a6146d50SZheng Yan 852044330c1SMatt Fleming info->per_pkg = false; 853044330c1SMatt Fleming 8548a398897SStephane Eranian /* 8558a398897SStephane Eranian * Mark unit and scale as not set 8568a398897SStephane Eranian * (different from default values, see below) 8578a398897SStephane Eranian */ 85846441bdcSMatt Fleming info->unit = NULL; 85946441bdcSMatt Fleming info->scale = 0.0; 8601d9e446bSJiri Olsa info->snapshot = false; 861410136f5SStephane Eranian 862a6146d50SZheng Yan list_for_each_entry_safe(term, h, head_terms, list) { 863a6146d50SZheng Yan alias = pmu_find_alias(pmu, term); 864a6146d50SZheng Yan if (!alias) 865a6146d50SZheng Yan continue; 866a6146d50SZheng Yan ret = pmu_alias_terms(alias, &term->list); 867a6146d50SZheng Yan if (ret) 868a6146d50SZheng Yan return ret; 869410136f5SStephane Eranian 8701d9e446bSJiri Olsa ret = check_info_data(alias, info); 871410136f5SStephane Eranian if (ret) 872410136f5SStephane Eranian return ret; 873410136f5SStephane Eranian 874044330c1SMatt Fleming if (alias->per_pkg) 875044330c1SMatt Fleming info->per_pkg = true; 876044330c1SMatt Fleming 877a6146d50SZheng Yan list_del(&term->list); 878a6146d50SZheng Yan free(term); 879a6146d50SZheng Yan } 8808a398897SStephane Eranian 8818a398897SStephane Eranian /* 8828a398897SStephane Eranian * if no unit or scale foundin aliases, then 8838a398897SStephane Eranian * set defaults as for evsel 8848a398897SStephane Eranian * unit cannot left to NULL 8858a398897SStephane Eranian */ 88646441bdcSMatt Fleming if (info->unit == NULL) 88746441bdcSMatt Fleming info->unit = ""; 8888a398897SStephane Eranian 88946441bdcSMatt Fleming if (info->scale == 0.0) 89046441bdcSMatt Fleming info->scale = 1.0; 8918a398897SStephane Eranian 892a6146d50SZheng Yan return 0; 893a6146d50SZheng Yan } 894a6146d50SZheng Yan 895cd82a32eSJiri Olsa int perf_pmu__new_format(struct list_head *list, char *name, 896cd82a32eSJiri Olsa int config, unsigned long *bits) 897cd82a32eSJiri Olsa { 8985c6ccc37SArnaldo Carvalho de Melo struct perf_pmu_format *format; 899cd82a32eSJiri Olsa 900cd82a32eSJiri Olsa format = zalloc(sizeof(*format)); 901cd82a32eSJiri Olsa if (!format) 902cd82a32eSJiri Olsa return -ENOMEM; 903cd82a32eSJiri Olsa 904cd82a32eSJiri Olsa format->name = strdup(name); 905cd82a32eSJiri Olsa format->value = config; 906cd82a32eSJiri Olsa memcpy(format->bits, bits, sizeof(format->bits)); 907cd82a32eSJiri Olsa 908cd82a32eSJiri Olsa list_add_tail(&format->list, list); 909cd82a32eSJiri Olsa return 0; 910cd82a32eSJiri Olsa } 911cd82a32eSJiri Olsa 912cd82a32eSJiri Olsa void perf_pmu__set_format(unsigned long *bits, long from, long to) 913cd82a32eSJiri Olsa { 914cd82a32eSJiri Olsa long b; 915cd82a32eSJiri Olsa 916cd82a32eSJiri Olsa if (!to) 917cd82a32eSJiri Olsa to = from; 918cd82a32eSJiri Olsa 91915268138SSukadev Bhattiprolu memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 920cd82a32eSJiri Olsa for (b = from; b <= to; b++) 921cd82a32eSJiri Olsa set_bit(b, bits); 922cd82a32eSJiri Olsa } 923dc098b35SAndi Kleen 924aaea3617SCody P Schafer static int sub_non_neg(int a, int b) 925aaea3617SCody P Schafer { 926aaea3617SCody P Schafer if (b > a) 927aaea3617SCody P Schafer return 0; 928aaea3617SCody P Schafer return a - b; 929aaea3617SCody P Schafer } 930aaea3617SCody P Schafer 931dc098b35SAndi Kleen static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 932dc098b35SAndi Kleen struct perf_pmu_alias *alias) 933dc098b35SAndi Kleen { 934aaea3617SCody P Schafer struct parse_events_term *term; 935aaea3617SCody P Schafer int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 936aaea3617SCody P Schafer 937aaea3617SCody P Schafer list_for_each_entry(term, &alias->terms, list) { 938aaea3617SCody P Schafer if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 939aaea3617SCody P Schafer used += snprintf(buf + used, sub_non_neg(len, used), 940aaea3617SCody P Schafer ",%s=%s", term->config, 941aaea3617SCody P Schafer term->val.str); 942aaea3617SCody P Schafer } 943aaea3617SCody P Schafer 944aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 945aaea3617SCody P Schafer buf[used] = '/'; 946aaea3617SCody P Schafer used++; 947aaea3617SCody P Schafer } 948aaea3617SCody P Schafer if (sub_non_neg(len, used) > 0) { 949aaea3617SCody P Schafer buf[used] = '\0'; 950aaea3617SCody P Schafer used++; 951aaea3617SCody P Schafer } else 952aaea3617SCody P Schafer buf[len - 1] = '\0'; 953aaea3617SCody P Schafer 954dc098b35SAndi Kleen return buf; 955dc098b35SAndi Kleen } 956dc098b35SAndi Kleen 957dc098b35SAndi Kleen static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 958dc098b35SAndi Kleen struct perf_pmu_alias *alias) 959dc098b35SAndi Kleen { 960dc098b35SAndi Kleen snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 961dc098b35SAndi Kleen return buf; 962dc098b35SAndi Kleen } 963dc098b35SAndi Kleen 964dc098b35SAndi Kleen static int cmp_string(const void *a, const void *b) 965dc098b35SAndi Kleen { 966dc098b35SAndi Kleen const char * const *as = a; 967dc098b35SAndi Kleen const char * const *bs = b; 968dc098b35SAndi Kleen return strcmp(*as, *bs); 969dc098b35SAndi Kleen } 970dc098b35SAndi Kleen 971dc098b35SAndi Kleen void print_pmu_events(const char *event_glob, bool name_only) 972dc098b35SAndi Kleen { 973dc098b35SAndi Kleen struct perf_pmu *pmu; 974dc098b35SAndi Kleen struct perf_pmu_alias *alias; 975dc098b35SAndi Kleen char buf[1024]; 976dc098b35SAndi Kleen int printed = 0; 977dc098b35SAndi Kleen int len, j; 978dc098b35SAndi Kleen char **aliases; 979dc098b35SAndi Kleen 980dc098b35SAndi Kleen pmu = NULL; 981dc098b35SAndi Kleen len = 0; 98242634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 983dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 984dc098b35SAndi Kleen len++; 98542634bc7SAdrian Hunter if (pmu->selectable) 98642634bc7SAdrian Hunter len++; 98742634bc7SAdrian Hunter } 9887e4772dcSArnaldo Carvalho de Melo aliases = zalloc(sizeof(char *) * len); 989dc098b35SAndi Kleen if (!aliases) 9907e4772dcSArnaldo Carvalho de Melo goto out_enomem; 991dc098b35SAndi Kleen pmu = NULL; 992dc098b35SAndi Kleen j = 0; 99342634bc7SAdrian Hunter while ((pmu = perf_pmu__scan(pmu)) != NULL) { 994dc098b35SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) { 995dc098b35SAndi Kleen char *name = format_alias(buf, sizeof(buf), pmu, alias); 996dc098b35SAndi Kleen bool is_cpu = !strcmp(pmu->name, "cpu"); 997dc098b35SAndi Kleen 998dc098b35SAndi Kleen if (event_glob != NULL && 999dc098b35SAndi Kleen !(strglobmatch(name, event_glob) || 1000dc098b35SAndi Kleen (!is_cpu && strglobmatch(alias->name, 1001dc098b35SAndi Kleen event_glob)))) 1002dc098b35SAndi Kleen continue; 10037e4772dcSArnaldo Carvalho de Melo 1004dc098b35SAndi Kleen if (is_cpu && !name_only) 10057e4772dcSArnaldo Carvalho de Melo name = format_alias_or(buf, sizeof(buf), pmu, alias); 10067e4772dcSArnaldo Carvalho de Melo 10077e4772dcSArnaldo Carvalho de Melo aliases[j] = strdup(name); 10087e4772dcSArnaldo Carvalho de Melo if (aliases[j] == NULL) 10097e4772dcSArnaldo Carvalho de Melo goto out_enomem; 1010dc098b35SAndi Kleen j++; 1011dc098b35SAndi Kleen } 1012fa52ceabSArnaldo Carvalho de Melo if (pmu->selectable && 1013fa52ceabSArnaldo Carvalho de Melo (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 10147e4772dcSArnaldo Carvalho de Melo char *s; 10157e4772dcSArnaldo Carvalho de Melo if (asprintf(&s, "%s//", pmu->name) < 0) 10167e4772dcSArnaldo Carvalho de Melo goto out_enomem; 10177e4772dcSArnaldo Carvalho de Melo aliases[j] = s; 101842634bc7SAdrian Hunter j++; 101942634bc7SAdrian Hunter } 102042634bc7SAdrian Hunter } 1021dc098b35SAndi Kleen len = j; 1022dc098b35SAndi Kleen qsort(aliases, len, sizeof(char *), cmp_string); 1023dc098b35SAndi Kleen for (j = 0; j < len; j++) { 1024dc098b35SAndi Kleen if (name_only) { 1025dc098b35SAndi Kleen printf("%s ", aliases[j]); 1026dc098b35SAndi Kleen continue; 1027dc098b35SAndi Kleen } 1028dc098b35SAndi Kleen printf(" %-50s [Kernel PMU event]\n", aliases[j]); 1029dc098b35SAndi Kleen printed++; 1030dc098b35SAndi Kleen } 1031dfc431cbSArnaldo Carvalho de Melo if (printed && pager_in_use()) 1032dc098b35SAndi Kleen printf("\n"); 10337e4772dcSArnaldo Carvalho de Melo out_free: 10347e4772dcSArnaldo Carvalho de Melo for (j = 0; j < len; j++) 10357e4772dcSArnaldo Carvalho de Melo zfree(&aliases[j]); 10367e4772dcSArnaldo Carvalho de Melo zfree(&aliases); 10377e4772dcSArnaldo Carvalho de Melo return; 10387e4772dcSArnaldo Carvalho de Melo 10397e4772dcSArnaldo Carvalho de Melo out_enomem: 10407e4772dcSArnaldo Carvalho de Melo printf("FATAL: not enough memory to print PMU events\n"); 10417e4772dcSArnaldo Carvalho de Melo if (aliases) 10427e4772dcSArnaldo Carvalho de Melo goto out_free; 1043dc098b35SAndi Kleen } 10444cabc3d1SAndi Kleen 10454cabc3d1SAndi Kleen bool pmu_have_event(const char *pname, const char *name) 10464cabc3d1SAndi Kleen { 10474cabc3d1SAndi Kleen struct perf_pmu *pmu; 10484cabc3d1SAndi Kleen struct perf_pmu_alias *alias; 10494cabc3d1SAndi Kleen 10504cabc3d1SAndi Kleen pmu = NULL; 10514cabc3d1SAndi Kleen while ((pmu = perf_pmu__scan(pmu)) != NULL) { 10524cabc3d1SAndi Kleen if (strcmp(pname, pmu->name)) 10534cabc3d1SAndi Kleen continue; 10544cabc3d1SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) 10554cabc3d1SAndi Kleen if (!strcmp(alias->name, name)) 10564cabc3d1SAndi Kleen return true; 10574cabc3d1SAndi Kleen } 10584cabc3d1SAndi Kleen return false; 10594cabc3d1SAndi Kleen } 10607d4bdab5SAdrian Hunter 10617d4bdab5SAdrian Hunter static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 10627d4bdab5SAdrian Hunter { 10637d4bdab5SAdrian Hunter struct stat st; 10647d4bdab5SAdrian Hunter char path[PATH_MAX]; 10657d4bdab5SAdrian Hunter const char *sysfs; 10667d4bdab5SAdrian Hunter 10677d4bdab5SAdrian Hunter sysfs = sysfs__mountpoint(); 10687d4bdab5SAdrian Hunter if (!sysfs) 10697d4bdab5SAdrian Hunter return NULL; 10707d4bdab5SAdrian Hunter 10717d4bdab5SAdrian Hunter snprintf(path, PATH_MAX, 10727d4bdab5SAdrian Hunter "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 10737d4bdab5SAdrian Hunter 10747d4bdab5SAdrian Hunter if (stat(path, &st) < 0) 10757d4bdab5SAdrian Hunter return NULL; 10767d4bdab5SAdrian Hunter 10777d4bdab5SAdrian Hunter return fopen(path, "r"); 10787d4bdab5SAdrian Hunter } 10797d4bdab5SAdrian Hunter 10807d4bdab5SAdrian Hunter int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 10817d4bdab5SAdrian Hunter ...) 10827d4bdab5SAdrian Hunter { 10837d4bdab5SAdrian Hunter va_list args; 10847d4bdab5SAdrian Hunter FILE *file; 10857d4bdab5SAdrian Hunter int ret = EOF; 10867d4bdab5SAdrian Hunter 10877d4bdab5SAdrian Hunter va_start(args, fmt); 10887d4bdab5SAdrian Hunter file = perf_pmu__open_file(pmu, name); 10897d4bdab5SAdrian Hunter if (file) { 10907d4bdab5SAdrian Hunter ret = vfscanf(file, fmt, args); 10917d4bdab5SAdrian Hunter fclose(file); 10927d4bdab5SAdrian Hunter } 10937d4bdab5SAdrian Hunter va_end(args); 10947d4bdab5SAdrian Hunter return ret; 10957d4bdab5SAdrian Hunter } 1096