Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <linux/list.h>
0003 #include <linux/compiler.h>
0004 #include <linux/string.h>
0005 #include <linux/zalloc.h>
0006 #include <linux/ctype.h>
0007 #include <subcmd/pager.h>
0008 #include <sys/types.h>
0009 #include <errno.h>
0010 #include <fcntl.h>
0011 #include <sys/stat.h>
0012 #include <unistd.h>
0013 #include <stdio.h>
0014 #include <stdbool.h>
0015 #include <stdarg.h>
0016 #include <dirent.h>
0017 #include <api/fs/fs.h>
0018 #include <locale.h>
0019 #include <regex.h>
0020 #include <perf/cpumap.h>
0021 #include <fnmatch.h>
0022 #include "debug.h"
0023 #include "evsel.h"
0024 #include "pmu.h"
0025 #include "parse-events.h"
0026 #include "header.h"
0027 #include "string2.h"
0028 #include "strbuf.h"
0029 #include "fncache.h"
0030 #include "pmu-hybrid.h"
0031 
0032 struct perf_pmu perf_pmu__fake;
0033 
0034 struct perf_pmu_format {
0035     char *name;
0036     int value;
0037     DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
0038     struct list_head list;
0039 };
0040 
0041 int perf_pmu_parse(struct list_head *list, char *name);
0042 extern FILE *perf_pmu_in;
0043 
0044 static LIST_HEAD(pmus);
0045 static bool hybrid_scanned;
0046 
0047 /*
0048  * Parse & process all the sysfs attributes located under
0049  * the directory specified in 'dir' parameter.
0050  */
0051 int perf_pmu__format_parse(char *dir, struct list_head *head)
0052 {
0053     struct dirent *evt_ent;
0054     DIR *format_dir;
0055     int ret = 0;
0056 
0057     format_dir = opendir(dir);
0058     if (!format_dir)
0059         return -EINVAL;
0060 
0061     while (!ret && (evt_ent = readdir(format_dir))) {
0062         char path[PATH_MAX];
0063         char *name = evt_ent->d_name;
0064         FILE *file;
0065 
0066         if (!strcmp(name, ".") || !strcmp(name, ".."))
0067             continue;
0068 
0069         snprintf(path, PATH_MAX, "%s/%s", dir, name);
0070 
0071         ret = -EINVAL;
0072         file = fopen(path, "r");
0073         if (!file)
0074             break;
0075 
0076         perf_pmu_in = file;
0077         ret = perf_pmu_parse(head, name);
0078         fclose(file);
0079     }
0080 
0081     closedir(format_dir);
0082     return ret;
0083 }
0084 
0085 /*
0086  * Reading/parsing the default pmu format definition, which should be
0087  * located at:
0088  * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
0089  */
0090 static int pmu_format(const char *name, struct list_head *format)
0091 {
0092     char path[PATH_MAX];
0093     const char *sysfs = sysfs__mountpoint();
0094 
0095     if (!sysfs)
0096         return -1;
0097 
0098     snprintf(path, PATH_MAX,
0099          "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
0100 
0101     if (!file_available(path))
0102         return 0;
0103 
0104     if (perf_pmu__format_parse(path, format))
0105         return -1;
0106 
0107     return 0;
0108 }
0109 
0110 int perf_pmu__convert_scale(const char *scale, char **end, double *sval)
0111 {
0112     char *lc;
0113     int ret = 0;
0114 
0115     /*
0116      * save current locale
0117      */
0118     lc = setlocale(LC_NUMERIC, NULL);
0119 
0120     /*
0121      * The lc string may be allocated in static storage,
0122      * so get a dynamic copy to make it survive setlocale
0123      * call below.
0124      */
0125     lc = strdup(lc);
0126     if (!lc) {
0127         ret = -ENOMEM;
0128         goto out;
0129     }
0130 
0131     /*
0132      * force to C locale to ensure kernel
0133      * scale string is converted correctly.
0134      * kernel uses default C locale.
0135      */
0136     setlocale(LC_NUMERIC, "C");
0137 
0138     *sval = strtod(scale, end);
0139 
0140 out:
0141     /* restore locale */
0142     setlocale(LC_NUMERIC, lc);
0143     free(lc);
0144     return ret;
0145 }
0146 
0147 static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name)
0148 {
0149     struct stat st;
0150     ssize_t sret;
0151     char scale[128];
0152     int fd, ret = -1;
0153     char path[PATH_MAX];
0154 
0155     scnprintf(path, PATH_MAX, "%s/%s.scale", dir, name);
0156 
0157     fd = open(path, O_RDONLY);
0158     if (fd == -1)
0159         return -1;
0160 
0161     if (fstat(fd, &st) < 0)
0162         goto error;
0163 
0164     sret = read(fd, scale, sizeof(scale)-1);
0165     if (sret < 0)
0166         goto error;
0167 
0168     if (scale[sret - 1] == '\n')
0169         scale[sret - 1] = '\0';
0170     else
0171         scale[sret] = '\0';
0172 
0173     ret = perf_pmu__convert_scale(scale, NULL, &alias->scale);
0174 error:
0175     close(fd);
0176     return ret;
0177 }
0178 
0179 static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name)
0180 {
0181     char path[PATH_MAX];
0182     ssize_t sret;
0183     int fd;
0184 
0185     scnprintf(path, PATH_MAX, "%s/%s.unit", dir, name);
0186 
0187     fd = open(path, O_RDONLY);
0188     if (fd == -1)
0189         return -1;
0190 
0191     sret = read(fd, alias->unit, UNIT_MAX_LEN);
0192     if (sret < 0)
0193         goto error;
0194 
0195     close(fd);
0196 
0197     if (alias->unit[sret - 1] == '\n')
0198         alias->unit[sret - 1] = '\0';
0199     else
0200         alias->unit[sret] = '\0';
0201 
0202     return 0;
0203 error:
0204     close(fd);
0205     alias->unit[0] = '\0';
0206     return -1;
0207 }
0208 
0209 static int
0210 perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name)
0211 {
0212     char path[PATH_MAX];
0213     int fd;
0214 
0215     scnprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name);
0216 
0217     fd = open(path, O_RDONLY);
0218     if (fd == -1)
0219         return -1;
0220 
0221     close(fd);
0222 
0223     alias->per_pkg = true;
0224     return 0;
0225 }
0226 
0227 static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
0228                     char *dir, char *name)
0229 {
0230     char path[PATH_MAX];
0231     int fd;
0232 
0233     scnprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name);
0234 
0235     fd = open(path, O_RDONLY);
0236     if (fd == -1)
0237         return -1;
0238 
0239     alias->snapshot = true;
0240     close(fd);
0241     return 0;
0242 }
0243 
0244 static void perf_pmu_assign_str(char *name, const char *field, char **old_str,
0245                 char **new_str)
0246 {
0247     if (!*old_str)
0248         goto set_new;
0249 
0250     if (*new_str) { /* Have new string, check with old */
0251         if (strcasecmp(*old_str, *new_str))
0252             pr_debug("alias %s differs in field '%s'\n",
0253                  name, field);
0254         zfree(old_str);
0255     } else      /* Nothing new --> keep old string */
0256         return;
0257 set_new:
0258     *old_str = *new_str;
0259     *new_str = NULL;
0260 }
0261 
0262 static void perf_pmu_update_alias(struct perf_pmu_alias *old,
0263                   struct perf_pmu_alias *newalias)
0264 {
0265     perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc);
0266     perf_pmu_assign_str(old->name, "long_desc", &old->long_desc,
0267                 &newalias->long_desc);
0268     perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic);
0269     perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr,
0270                 &newalias->metric_expr);
0271     perf_pmu_assign_str(old->name, "metric_name", &old->metric_name,
0272                 &newalias->metric_name);
0273     perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str);
0274     old->scale = newalias->scale;
0275     old->per_pkg = newalias->per_pkg;
0276     old->snapshot = newalias->snapshot;
0277     memcpy(old->unit, newalias->unit, sizeof(old->unit));
0278 }
0279 
0280 /* Delete an alias entry. */
0281 void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
0282 {
0283     zfree(&newalias->name);
0284     zfree(&newalias->desc);
0285     zfree(&newalias->long_desc);
0286     zfree(&newalias->topic);
0287     zfree(&newalias->str);
0288     zfree(&newalias->metric_expr);
0289     zfree(&newalias->metric_name);
0290     zfree(&newalias->pmu_name);
0291     parse_events_terms__purge(&newalias->terms);
0292     free(newalias);
0293 }
0294 
0295 /* Merge an alias, search in alias list. If this name is already
0296  * present merge both of them to combine all information.
0297  */
0298 static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias,
0299                  struct list_head *alist)
0300 {
0301     struct perf_pmu_alias *a;
0302 
0303     list_for_each_entry(a, alist, list) {
0304         if (!strcasecmp(newalias->name, a->name)) {
0305             if (newalias->pmu_name && a->pmu_name &&
0306                 !strcasecmp(newalias->pmu_name, a->pmu_name)) {
0307                 continue;
0308             }
0309             perf_pmu_update_alias(a, newalias);
0310             perf_pmu_free_alias(newalias);
0311             return true;
0312         }
0313     }
0314     return false;
0315 }
0316 
0317 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
0318                  char *desc, char *val, const struct pmu_event *pe)
0319 {
0320     struct parse_events_term *term;
0321     struct perf_pmu_alias *alias;
0322     int ret;
0323     int num;
0324     char newval[256];
0325     char *long_desc = NULL, *topic = NULL, *unit = NULL, *perpkg = NULL,
0326          *metric_expr = NULL, *metric_name = NULL, *deprecated = NULL,
0327          *pmu_name = NULL;
0328 
0329     if (pe) {
0330         long_desc = (char *)pe->long_desc;
0331         topic = (char *)pe->topic;
0332         unit = (char *)pe->unit;
0333         perpkg = (char *)pe->perpkg;
0334         metric_expr = (char *)pe->metric_expr;
0335         metric_name = (char *)pe->metric_name;
0336         deprecated = (char *)pe->deprecated;
0337         pmu_name = (char *)pe->pmu;
0338     }
0339 
0340     alias = malloc(sizeof(*alias));
0341     if (!alias)
0342         return -ENOMEM;
0343 
0344     INIT_LIST_HEAD(&alias->terms);
0345     alias->scale = 1.0;
0346     alias->unit[0] = '\0';
0347     alias->per_pkg = false;
0348     alias->snapshot = false;
0349     alias->deprecated = false;
0350 
0351     ret = parse_events_terms(&alias->terms, val);
0352     if (ret) {
0353         pr_err("Cannot parse alias %s: %d\n", val, ret);
0354         free(alias);
0355         return ret;
0356     }
0357 
0358     /* Scan event and remove leading zeroes, spaces, newlines, some
0359      * platforms have terms specified as
0360      * event=0x0091 (read from files ../<PMU>/events/<FILE>
0361      * and terms specified as event=0x91 (read from JSON files).
0362      *
0363      * Rebuild string to make alias->str member comparable.
0364      */
0365     memset(newval, 0, sizeof(newval));
0366     ret = 0;
0367     list_for_each_entry(term, &alias->terms, list) {
0368         if (ret)
0369             ret += scnprintf(newval + ret, sizeof(newval) - ret,
0370                      ",");
0371         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
0372             ret += scnprintf(newval + ret, sizeof(newval) - ret,
0373                      "%s=%#x", term->config, term->val.num);
0374         else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
0375             ret += scnprintf(newval + ret, sizeof(newval) - ret,
0376                      "%s=%s", term->config, term->val.str);
0377     }
0378 
0379     alias->name = strdup(name);
0380     if (dir) {
0381         /*
0382          * load unit name and scale if available
0383          */
0384         perf_pmu__parse_unit(alias, dir, name);
0385         perf_pmu__parse_scale(alias, dir, name);
0386         perf_pmu__parse_per_pkg(alias, dir, name);
0387         perf_pmu__parse_snapshot(alias, dir, name);
0388     }
0389 
0390     alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
0391     alias->metric_name = metric_name ? strdup(metric_name): NULL;
0392     alias->desc = desc ? strdup(desc) : NULL;
0393     alias->long_desc = long_desc ? strdup(long_desc) :
0394                 desc ? strdup(desc) : NULL;
0395     alias->topic = topic ? strdup(topic) : NULL;
0396     if (unit) {
0397         if (perf_pmu__convert_scale(unit, &unit, &alias->scale) < 0)
0398             return -1;
0399         snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
0400     }
0401     alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
0402     alias->str = strdup(newval);
0403     alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL;
0404 
0405     if (deprecated)
0406         alias->deprecated = true;
0407 
0408     if (!perf_pmu_merge_alias(alias, list))
0409         list_add_tail(&alias->list, list);
0410 
0411     return 0;
0412 }
0413 
0414 static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file)
0415 {
0416     char buf[256];
0417     int ret;
0418 
0419     ret = fread(buf, 1, sizeof(buf), file);
0420     if (ret == 0)
0421         return -EINVAL;
0422 
0423     buf[ret] = 0;
0424 
0425     /* Remove trailing newline from sysfs file */
0426     strim(buf);
0427 
0428     return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL);
0429 }
0430 
0431 static inline bool pmu_alias_info_file(char *name)
0432 {
0433     size_t len;
0434 
0435     len = strlen(name);
0436     if (len > 5 && !strcmp(name + len - 5, ".unit"))
0437         return true;
0438     if (len > 6 && !strcmp(name + len - 6, ".scale"))
0439         return true;
0440     if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
0441         return true;
0442     if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
0443         return true;
0444 
0445     return false;
0446 }
0447 
0448 /*
0449  * Process all the sysfs attributes located under the directory
0450  * specified in 'dir' parameter.
0451  */
0452 static int pmu_aliases_parse(char *dir, struct list_head *head)
0453 {
0454     struct dirent *evt_ent;
0455     DIR *event_dir;
0456 
0457     event_dir = opendir(dir);
0458     if (!event_dir)
0459         return -EINVAL;
0460 
0461     while ((evt_ent = readdir(event_dir))) {
0462         char path[PATH_MAX];
0463         char *name = evt_ent->d_name;
0464         FILE *file;
0465 
0466         if (!strcmp(name, ".") || !strcmp(name, ".."))
0467             continue;
0468 
0469         /*
0470          * skip info files parsed in perf_pmu__new_alias()
0471          */
0472         if (pmu_alias_info_file(name))
0473             continue;
0474 
0475         scnprintf(path, PATH_MAX, "%s/%s", dir, name);
0476 
0477         file = fopen(path, "r");
0478         if (!file) {
0479             pr_debug("Cannot open %s\n", path);
0480             continue;
0481         }
0482 
0483         if (perf_pmu__new_alias(head, dir, name, file) < 0)
0484             pr_debug("Cannot set up %s\n", name);
0485         fclose(file);
0486     }
0487 
0488     closedir(event_dir);
0489     return 0;
0490 }
0491 
0492 /*
0493  * Reading the pmu event aliases definition, which should be located at:
0494  * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
0495  */
0496 static int pmu_aliases(const char *name, struct list_head *head)
0497 {
0498     char path[PATH_MAX];
0499     const char *sysfs = sysfs__mountpoint();
0500 
0501     if (!sysfs)
0502         return -1;
0503 
0504     snprintf(path, PATH_MAX,
0505          "%s/bus/event_source/devices/%s/events", sysfs, name);
0506 
0507     if (!file_available(path))
0508         return 0;
0509 
0510     if (pmu_aliases_parse(path, head))
0511         return -1;
0512 
0513     return 0;
0514 }
0515 
0516 static int pmu_alias_terms(struct perf_pmu_alias *alias,
0517                struct list_head *terms)
0518 {
0519     struct parse_events_term *term, *cloned;
0520     LIST_HEAD(list);
0521     int ret;
0522 
0523     list_for_each_entry(term, &alias->terms, list) {
0524         ret = parse_events_term__clone(&cloned, term);
0525         if (ret) {
0526             parse_events_terms__purge(&list);
0527             return ret;
0528         }
0529         /*
0530          * Weak terms don't override command line options,
0531          * which we don't want for implicit terms in aliases.
0532          */
0533         cloned->weak = true;
0534         list_add_tail(&cloned->list, &list);
0535     }
0536     list_splice(&list, terms);
0537     return 0;
0538 }
0539 
0540 /*
0541  * Reading/parsing the default pmu type value, which should be
0542  * located at:
0543  * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
0544  */
0545 static int pmu_type(const char *name, __u32 *type)
0546 {
0547     char path[PATH_MAX];
0548     FILE *file;
0549     int ret = 0;
0550     const char *sysfs = sysfs__mountpoint();
0551 
0552     if (!sysfs)
0553         return -1;
0554 
0555     snprintf(path, PATH_MAX,
0556          "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
0557 
0558     if (access(path, R_OK) < 0)
0559         return -1;
0560 
0561     file = fopen(path, "r");
0562     if (!file)
0563         return -EINVAL;
0564 
0565     if (1 != fscanf(file, "%u", type))
0566         ret = -1;
0567 
0568     fclose(file);
0569     return ret;
0570 }
0571 
0572 /* Add all pmus in sysfs to pmu list: */
0573 static void pmu_read_sysfs(void)
0574 {
0575     char path[PATH_MAX];
0576     DIR *dir;
0577     struct dirent *dent;
0578     const char *sysfs = sysfs__mountpoint();
0579 
0580     if (!sysfs)
0581         return;
0582 
0583     snprintf(path, PATH_MAX,
0584          "%s" EVENT_SOURCE_DEVICE_PATH, sysfs);
0585 
0586     dir = opendir(path);
0587     if (!dir)
0588         return;
0589 
0590     while ((dent = readdir(dir))) {
0591         if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
0592             continue;
0593         /* add to static LIST_HEAD(pmus): */
0594         perf_pmu__find(dent->d_name);
0595     }
0596 
0597     closedir(dir);
0598 }
0599 
0600 static struct perf_cpu_map *__pmu_cpumask(const char *path)
0601 {
0602     FILE *file;
0603     struct perf_cpu_map *cpus;
0604 
0605     file = fopen(path, "r");
0606     if (!file)
0607         return NULL;
0608 
0609     cpus = perf_cpu_map__read(file);
0610     fclose(file);
0611     return cpus;
0612 }
0613 
0614 /*
0615  * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
0616  * may have a "cpus" file.
0617  */
0618 #define SYS_TEMPLATE_ID "./bus/event_source/devices/%s/identifier"
0619 #define CPUS_TEMPLATE_UNCORE    "%s/bus/event_source/devices/%s/cpumask"
0620 
0621 static struct perf_cpu_map *pmu_cpumask(const char *name)
0622 {
0623     char path[PATH_MAX];
0624     struct perf_cpu_map *cpus;
0625     const char *sysfs = sysfs__mountpoint();
0626     const char *templates[] = {
0627         CPUS_TEMPLATE_UNCORE,
0628         CPUS_TEMPLATE_CPU,
0629         NULL
0630     };
0631     const char **template;
0632 
0633     if (!sysfs)
0634         return NULL;
0635 
0636     for (template = templates; *template; template++) {
0637         snprintf(path, PATH_MAX, *template, sysfs, name);
0638         cpus = __pmu_cpumask(path);
0639         if (cpus)
0640             return cpus;
0641     }
0642 
0643     return NULL;
0644 }
0645 
0646 static bool pmu_is_uncore(const char *name)
0647 {
0648     char path[PATH_MAX];
0649     const char *sysfs;
0650 
0651     if (perf_pmu__hybrid_mounted(name))
0652         return false;
0653 
0654     sysfs = sysfs__mountpoint();
0655     snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name);
0656     return file_available(path);
0657 }
0658 
0659 static char *pmu_id(const char *name)
0660 {
0661     char path[PATH_MAX], *str;
0662     size_t len;
0663 
0664     snprintf(path, PATH_MAX, SYS_TEMPLATE_ID, name);
0665 
0666     if (sysfs__read_str(path, &str, &len) < 0)
0667         return NULL;
0668 
0669     str[len - 1] = 0; /* remove line feed */
0670 
0671     return str;
0672 }
0673 
0674 /*
0675  *  PMU CORE devices have different name other than cpu in sysfs on some
0676  *  platforms.
0677  *  Looking for possible sysfs files to identify the arm core device.
0678  */
0679 static int is_arm_pmu_core(const char *name)
0680 {
0681     char path[PATH_MAX];
0682     const char *sysfs = sysfs__mountpoint();
0683 
0684     if (!sysfs)
0685         return 0;
0686 
0687     /* Look for cpu sysfs (specific to arm) */
0688     scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus",
0689                 sysfs, name);
0690     return file_available(path);
0691 }
0692 
0693 char *perf_pmu__getcpuid(struct perf_pmu *pmu)
0694 {
0695     char *cpuid;
0696     static bool printed;
0697 
0698     cpuid = getenv("PERF_CPUID");
0699     if (cpuid)
0700         cpuid = strdup(cpuid);
0701     if (!cpuid)
0702         cpuid = get_cpuid_str(pmu);
0703     if (!cpuid)
0704         return NULL;
0705 
0706     if (!printed) {
0707         pr_debug("Using CPUID %s\n", cpuid);
0708         printed = true;
0709     }
0710     return cpuid;
0711 }
0712 
0713 __weak const struct pmu_events_table *pmu_events_table__find(void)
0714 {
0715     return perf_pmu__find_table(NULL);
0716 }
0717 
0718 /*
0719  * Suffix must be in form tok_{digits}, or tok{digits}, or same as pmu_name
0720  * to be valid.
0721  */
0722 static bool perf_pmu__valid_suffix(const char *pmu_name, char *tok)
0723 {
0724     const char *p;
0725 
0726     if (strncmp(pmu_name, tok, strlen(tok)))
0727         return false;
0728 
0729     p = pmu_name + strlen(tok);
0730     if (*p == 0)
0731         return true;
0732 
0733     if (*p == '_')
0734         ++p;
0735 
0736     /* Ensure we end in a number */
0737     while (1) {
0738         if (!isdigit(*p))
0739             return false;
0740         if (*(++p) == 0)
0741             break;
0742     }
0743 
0744     return true;
0745 }
0746 
0747 bool pmu_uncore_alias_match(const char *pmu_name, const char *name)
0748 {
0749     char *tmp = NULL, *tok, *str;
0750     bool res;
0751 
0752     str = strdup(pmu_name);
0753     if (!str)
0754         return false;
0755 
0756     /*
0757      * uncore alias may be from different PMU with common prefix
0758      */
0759     tok = strtok_r(str, ",", &tmp);
0760     if (strncmp(pmu_name, tok, strlen(tok))) {
0761         res = false;
0762         goto out;
0763     }
0764 
0765     /*
0766      * Match more complex aliases where the alias name is a comma-delimited
0767      * list of tokens, orderly contained in the matching PMU name.
0768      *
0769      * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we
0770      *      match "socket" in "socketX_pmunameY" and then "pmuname" in
0771      *      "pmunameY".
0772      */
0773     while (1) {
0774         char *next_tok = strtok_r(NULL, ",", &tmp);
0775 
0776         name = strstr(name, tok);
0777         if (!name ||
0778             (!next_tok && !perf_pmu__valid_suffix(name, tok))) {
0779             res = false;
0780             goto out;
0781         }
0782         if (!next_tok)
0783             break;
0784         tok = next_tok;
0785         name += strlen(tok);
0786     }
0787 
0788     res = true;
0789 out:
0790     free(str);
0791     return res;
0792 }
0793 
0794 struct pmu_add_cpu_aliases_map_data {
0795     struct list_head *head;
0796     const char *name;
0797     const char *cpu_name;
0798     struct perf_pmu *pmu;
0799 };
0800 
0801 static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,
0802                     const struct pmu_events_table *table __maybe_unused,
0803                     void *vdata)
0804 {
0805     struct pmu_add_cpu_aliases_map_data *data = vdata;
0806     const char *pname = pe->pmu ? pe->pmu : data->cpu_name;
0807 
0808     if (!pe->name)
0809         return 0;
0810 
0811     if (data->pmu->is_uncore && pmu_uncore_alias_match(pname, data->name))
0812         goto new_alias;
0813 
0814     if (strcmp(pname, data->name))
0815         return 0;
0816 
0817 new_alias:
0818     /* need type casts to override 'const' */
0819     __perf_pmu__new_alias(data->head, NULL, (char *)pe->name, (char *)pe->desc,
0820                   (char *)pe->event, pe);
0821     return 0;
0822 }
0823 
0824 /*
0825  * From the pmu_events_map, find the table of PMU events that corresponds
0826  * to the current running CPU. Then, add all PMU events from that table
0827  * as aliases.
0828  */
0829 void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu,
0830                    const struct pmu_events_table *table)
0831 {
0832     struct pmu_add_cpu_aliases_map_data data = {
0833         .head = head,
0834         .name = pmu->name,
0835         .cpu_name = is_arm_pmu_core(pmu->name) ? pmu->name : "cpu",
0836         .pmu = pmu,
0837     };
0838 
0839     pmu_events_table_for_each_event(table, pmu_add_cpu_aliases_map_callback, &data);
0840 }
0841 
0842 static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
0843 {
0844     const struct pmu_events_table *table;
0845 
0846     table = perf_pmu__find_table(pmu);
0847     if (!table)
0848         return;
0849 
0850     pmu_add_cpu_aliases_table(head, pmu, table);
0851 }
0852 
0853 struct pmu_sys_event_iter_data {
0854     struct list_head *head;
0855     struct perf_pmu *pmu;
0856 };
0857 
0858 static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe,
0859                        const struct pmu_events_table *table __maybe_unused,
0860                        void *data)
0861 {
0862     struct pmu_sys_event_iter_data *idata = data;
0863     struct perf_pmu *pmu = idata->pmu;
0864 
0865     if (!pe->name) {
0866         if (pe->metric_group || pe->metric_name)
0867             return 0;
0868         return -EINVAL;
0869     }
0870 
0871     if (!pe->compat || !pe->pmu)
0872         return 0;
0873 
0874     if (!strcmp(pmu->id, pe->compat) &&
0875         pmu_uncore_alias_match(pe->pmu, pmu->name)) {
0876         __perf_pmu__new_alias(idata->head, NULL,
0877                       (char *)pe->name,
0878                       (char *)pe->desc,
0879                       (char *)pe->event,
0880                       pe);
0881     }
0882 
0883     return 0;
0884 }
0885 
0886 void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu)
0887 {
0888     struct pmu_sys_event_iter_data idata = {
0889         .head = head,
0890         .pmu = pmu,
0891     };
0892 
0893     if (!pmu->id)
0894         return;
0895 
0896     pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata);
0897 }
0898 
0899 struct perf_event_attr * __weak
0900 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
0901 {
0902     return NULL;
0903 }
0904 
0905 char * __weak
0906 pmu_find_real_name(const char *name)
0907 {
0908     return (char *)name;
0909 }
0910 
0911 char * __weak
0912 pmu_find_alias_name(const char *name __maybe_unused)
0913 {
0914     return NULL;
0915 }
0916 
0917 static int pmu_max_precise(const char *name)
0918 {
0919     char path[PATH_MAX];
0920     int max_precise = -1;
0921 
0922     scnprintf(path, PATH_MAX,
0923          "bus/event_source/devices/%s/caps/max_precise",
0924          name);
0925 
0926     sysfs__read_int(path, &max_precise);
0927     return max_precise;
0928 }
0929 
0930 static struct perf_pmu *pmu_lookup(const char *lookup_name)
0931 {
0932     struct perf_pmu *pmu;
0933     LIST_HEAD(format);
0934     LIST_HEAD(aliases);
0935     __u32 type;
0936     char *name = pmu_find_real_name(lookup_name);
0937     bool is_hybrid = perf_pmu__hybrid_mounted(name);
0938     char *alias_name;
0939 
0940     /*
0941      * Check pmu name for hybrid and the pmu may be invalid in sysfs
0942      */
0943     if (!strncmp(name, "cpu_", 4) && !is_hybrid)
0944         return NULL;
0945 
0946     /*
0947      * The pmu data we store & need consists of the pmu
0948      * type value and format definitions. Load both right
0949      * now.
0950      */
0951     if (pmu_format(name, &format))
0952         return NULL;
0953 
0954     /*
0955      * Check the type first to avoid unnecessary work.
0956      */
0957     if (pmu_type(name, &type))
0958         return NULL;
0959 
0960     if (pmu_aliases(name, &aliases))
0961         return NULL;
0962 
0963     pmu = zalloc(sizeof(*pmu));
0964     if (!pmu)
0965         return NULL;
0966 
0967     pmu->cpus = pmu_cpumask(name);
0968     pmu->name = strdup(name);
0969     if (!pmu->name)
0970         goto err;
0971 
0972     alias_name = pmu_find_alias_name(name);
0973     if (alias_name) {
0974         pmu->alias_name = strdup(alias_name);
0975         if (!pmu->alias_name)
0976             goto err;
0977     }
0978 
0979     pmu->type = type;
0980     pmu->is_uncore = pmu_is_uncore(name);
0981     if (pmu->is_uncore)
0982         pmu->id = pmu_id(name);
0983     pmu->is_hybrid = is_hybrid;
0984     pmu->max_precise = pmu_max_precise(name);
0985     pmu_add_cpu_aliases(&aliases, pmu);
0986     pmu_add_sys_aliases(&aliases, pmu);
0987 
0988     INIT_LIST_HEAD(&pmu->format);
0989     INIT_LIST_HEAD(&pmu->aliases);
0990     INIT_LIST_HEAD(&pmu->caps);
0991     list_splice(&format, &pmu->format);
0992     list_splice(&aliases, &pmu->aliases);
0993     list_add_tail(&pmu->list, &pmus);
0994 
0995     if (pmu->is_hybrid)
0996         list_add_tail(&pmu->hybrid_list, &perf_pmu__hybrid_pmus);
0997 
0998     pmu->default_config = perf_pmu__get_default_config(pmu);
0999 
1000     return pmu;
1001 err:
1002     if (pmu->name)
1003         free(pmu->name);
1004     free(pmu);
1005     return NULL;
1006 }
1007 
1008 static struct perf_pmu *pmu_find(const char *name)
1009 {
1010     struct perf_pmu *pmu;
1011 
1012     list_for_each_entry(pmu, &pmus, list) {
1013         if (!strcmp(pmu->name, name) ||
1014             (pmu->alias_name && !strcmp(pmu->alias_name, name)))
1015             return pmu;
1016     }
1017 
1018     return NULL;
1019 }
1020 
1021 struct perf_pmu *perf_pmu__find_by_type(unsigned int type)
1022 {
1023     struct perf_pmu *pmu;
1024 
1025     list_for_each_entry(pmu, &pmus, list)
1026         if (pmu->type == type)
1027             return pmu;
1028 
1029     return NULL;
1030 }
1031 
1032 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
1033 {
1034     /*
1035      * pmu iterator: If pmu is NULL, we start at the begin,
1036      * otherwise return the next pmu. Returns NULL on end.
1037      */
1038     if (!pmu) {
1039         pmu_read_sysfs();
1040         pmu = list_prepare_entry(pmu, &pmus, list);
1041     }
1042     list_for_each_entry_continue(pmu, &pmus, list)
1043         return pmu;
1044     return NULL;
1045 }
1046 
1047 struct perf_pmu *evsel__find_pmu(struct evsel *evsel)
1048 {
1049     struct perf_pmu *pmu = NULL;
1050 
1051     while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1052         if (pmu->type == evsel->core.attr.type)
1053             break;
1054     }
1055 
1056     return pmu;
1057 }
1058 
1059 bool evsel__is_aux_event(struct evsel *evsel)
1060 {
1061     struct perf_pmu *pmu = evsel__find_pmu(evsel);
1062 
1063     return pmu && pmu->auxtrace;
1064 }
1065 
1066 struct perf_pmu *perf_pmu__find(const char *name)
1067 {
1068     struct perf_pmu *pmu;
1069 
1070     /*
1071      * Once PMU is loaded it stays in the list,
1072      * so we keep us from multiple reading/parsing
1073      * the pmu format definitions.
1074      */
1075     pmu = pmu_find(name);
1076     if (pmu)
1077         return pmu;
1078 
1079     return pmu_lookup(name);
1080 }
1081 
1082 static struct perf_pmu_format *
1083 pmu_find_format(struct list_head *formats, const char *name)
1084 {
1085     struct perf_pmu_format *format;
1086 
1087     list_for_each_entry(format, formats, list)
1088         if (!strcmp(format->name, name))
1089             return format;
1090 
1091     return NULL;
1092 }
1093 
1094 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
1095 {
1096     struct perf_pmu_format *format = pmu_find_format(formats, name);
1097     __u64 bits = 0;
1098     int fbit;
1099 
1100     if (!format)
1101         return 0;
1102 
1103     for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
1104         bits |= 1ULL << fbit;
1105 
1106     return bits;
1107 }
1108 
1109 int perf_pmu__format_type(struct list_head *formats, const char *name)
1110 {
1111     struct perf_pmu_format *format = pmu_find_format(formats, name);
1112 
1113     if (!format)
1114         return -1;
1115 
1116     return format->value;
1117 }
1118 
1119 /*
1120  * Sets value based on the format definition (format parameter)
1121  * and unformatted value (value parameter).
1122  */
1123 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
1124                  bool zero)
1125 {
1126     unsigned long fbit, vbit;
1127 
1128     for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
1129 
1130         if (!test_bit(fbit, format))
1131             continue;
1132 
1133         if (value & (1llu << vbit++))
1134             *v |= (1llu << fbit);
1135         else if (zero)
1136             *v &= ~(1llu << fbit);
1137     }
1138 }
1139 
1140 static __u64 pmu_format_max_value(const unsigned long *format)
1141 {
1142     int w;
1143 
1144     w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
1145     if (!w)
1146         return 0;
1147     if (w < 64)
1148         return (1ULL << w) - 1;
1149     return -1;
1150 }
1151 
1152 /*
1153  * Term is a string term, and might be a param-term. Try to look up it's value
1154  * in the remaining terms.
1155  * - We have a term like "base-or-format-term=param-term",
1156  * - We need to find the value supplied for "param-term" (with param-term named
1157  *   in a config string) later on in the term list.
1158  */
1159 static int pmu_resolve_param_term(struct parse_events_term *term,
1160                   struct list_head *head_terms,
1161                   __u64 *value)
1162 {
1163     struct parse_events_term *t;
1164 
1165     list_for_each_entry(t, head_terms, list) {
1166         if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM &&
1167             t->config && !strcmp(t->config, term->config)) {
1168             t->used = true;
1169             *value = t->val.num;
1170             return 0;
1171         }
1172     }
1173 
1174     if (verbose > 0)
1175         printf("Required parameter '%s' not specified\n", term->config);
1176 
1177     return -1;
1178 }
1179 
1180 static char *pmu_formats_string(struct list_head *formats)
1181 {
1182     struct perf_pmu_format *format;
1183     char *str = NULL;
1184     struct strbuf buf = STRBUF_INIT;
1185     unsigned i = 0;
1186 
1187     if (!formats)
1188         return NULL;
1189 
1190     /* sysfs exported terms */
1191     list_for_each_entry(format, formats, list)
1192         if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
1193             goto error;
1194 
1195     str = strbuf_detach(&buf, NULL);
1196 error:
1197     strbuf_release(&buf);
1198 
1199     return str;
1200 }
1201 
1202 /*
1203  * Setup one of config[12] attr members based on the
1204  * user input data - term parameter.
1205  */
1206 static int pmu_config_term(const char *pmu_name,
1207                struct list_head *formats,
1208                struct perf_event_attr *attr,
1209                struct parse_events_term *term,
1210                struct list_head *head_terms,
1211                bool zero, struct parse_events_error *err)
1212 {
1213     struct perf_pmu_format *format;
1214     __u64 *vp;
1215     __u64 val, max_val;
1216 
1217     /*
1218      * If this is a parameter we've already used for parameterized-eval,
1219      * skip it in normal eval.
1220      */
1221     if (term->used)
1222         return 0;
1223 
1224     /*
1225      * Hardcoded terms should be already in, so nothing
1226      * to be done for them.
1227      */
1228     if (parse_events__is_hardcoded_term(term))
1229         return 0;
1230 
1231     format = pmu_find_format(formats, term->config);
1232     if (!format) {
1233         char *pmu_term = pmu_formats_string(formats);
1234         char *unknown_term;
1235         char *help_msg;
1236 
1237         if (asprintf(&unknown_term,
1238                 "unknown term '%s' for pmu '%s'",
1239                 term->config, pmu_name) < 0)
1240             unknown_term = NULL;
1241         help_msg = parse_events_formats_error_string(pmu_term);
1242         if (err) {
1243             parse_events_error__handle(err, term->err_term,
1244                            unknown_term,
1245                            help_msg);
1246         } else {
1247             pr_debug("%s (%s)\n", unknown_term, help_msg);
1248             free(unknown_term);
1249         }
1250         free(pmu_term);
1251         return -EINVAL;
1252     }
1253 
1254     switch (format->value) {
1255     case PERF_PMU_FORMAT_VALUE_CONFIG:
1256         vp = &attr->config;
1257         break;
1258     case PERF_PMU_FORMAT_VALUE_CONFIG1:
1259         vp = &attr->config1;
1260         break;
1261     case PERF_PMU_FORMAT_VALUE_CONFIG2:
1262         vp = &attr->config2;
1263         break;
1264     default:
1265         return -EINVAL;
1266     }
1267 
1268     /*
1269      * Either directly use a numeric term, or try to translate string terms
1270      * using event parameters.
1271      */
1272     if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1273         if (term->no_value &&
1274             bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1275             if (err) {
1276                 parse_events_error__handle(err, term->err_val,
1277                        strdup("no value assigned for term"),
1278                        NULL);
1279             }
1280             return -EINVAL;
1281         }
1282 
1283         val = term->val.num;
1284     } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1285         if (strcmp(term->val.str, "?")) {
1286             if (verbose > 0) {
1287                 pr_info("Invalid sysfs entry %s=%s\n",
1288                         term->config, term->val.str);
1289             }
1290             if (err) {
1291                 parse_events_error__handle(err, term->err_val,
1292                     strdup("expected numeric value"),
1293                     NULL);
1294             }
1295             return -EINVAL;
1296         }
1297 
1298         if (pmu_resolve_param_term(term, head_terms, &val))
1299             return -EINVAL;
1300     } else
1301         return -EINVAL;
1302 
1303     max_val = pmu_format_max_value(format->bits);
1304     if (val > max_val) {
1305         if (err) {
1306             char *err_str;
1307 
1308             parse_events_error__handle(err, term->err_val,
1309                 asprintf(&err_str,
1310                     "value too big for format, maximum is %llu",
1311                     (unsigned long long)max_val) < 0
1312                     ? strdup("value too big for format")
1313                     : err_str,
1314                     NULL);
1315             return -EINVAL;
1316         }
1317         /*
1318          * Assume we don't care if !err, in which case the value will be
1319          * silently truncated.
1320          */
1321     }
1322 
1323     pmu_format_value(format->bits, val, vp, zero);
1324     return 0;
1325 }
1326 
1327 int perf_pmu__config_terms(const char *pmu_name, struct list_head *formats,
1328                struct perf_event_attr *attr,
1329                struct list_head *head_terms,
1330                bool zero, struct parse_events_error *err)
1331 {
1332     struct parse_events_term *term;
1333 
1334     list_for_each_entry(term, head_terms, list) {
1335         if (pmu_config_term(pmu_name, formats, attr, term, head_terms,
1336                     zero, err))
1337             return -EINVAL;
1338     }
1339 
1340     return 0;
1341 }
1342 
1343 /*
1344  * Configures event's 'attr' parameter based on the:
1345  * 1) users input - specified in terms parameter
1346  * 2) pmu format definitions - specified by pmu parameter
1347  */
1348 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1349              struct list_head *head_terms,
1350              struct parse_events_error *err)
1351 {
1352     bool zero = !!pmu->default_config;
1353 
1354     attr->type = pmu->type;
1355     return perf_pmu__config_terms(pmu->name, &pmu->format, attr,
1356                       head_terms, zero, err);
1357 }
1358 
1359 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1360                          struct parse_events_term *term)
1361 {
1362     struct perf_pmu_alias *alias;
1363     char *name;
1364 
1365     if (parse_events__is_hardcoded_term(term))
1366         return NULL;
1367 
1368     if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1369         if (term->val.num != 1)
1370             return NULL;
1371         if (pmu_find_format(&pmu->format, term->config))
1372             return NULL;
1373         name = term->config;
1374     } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1375         if (strcasecmp(term->config, "event"))
1376             return NULL;
1377         name = term->val.str;
1378     } else {
1379         return NULL;
1380     }
1381 
1382     list_for_each_entry(alias, &pmu->aliases, list) {
1383         if (!strcasecmp(alias->name, name))
1384             return alias;
1385     }
1386     return NULL;
1387 }
1388 
1389 
1390 static int check_info_data(struct perf_pmu_alias *alias,
1391                struct perf_pmu_info *info)
1392 {
1393     /*
1394      * Only one term in event definition can
1395      * define unit, scale and snapshot, fail
1396      * if there's more than one.
1397      */
1398     if ((info->unit && alias->unit[0]) ||
1399         (info->scale && alias->scale) ||
1400         (info->snapshot && alias->snapshot))
1401         return -EINVAL;
1402 
1403     if (alias->unit[0])
1404         info->unit = alias->unit;
1405 
1406     if (alias->scale)
1407         info->scale = alias->scale;
1408 
1409     if (alias->snapshot)
1410         info->snapshot = alias->snapshot;
1411 
1412     return 0;
1413 }
1414 
1415 /*
1416  * Find alias in the terms list and replace it with the terms
1417  * defined for the alias
1418  */
1419 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1420               struct perf_pmu_info *info)
1421 {
1422     struct parse_events_term *term, *h;
1423     struct perf_pmu_alias *alias;
1424     int ret;
1425 
1426     info->per_pkg = false;
1427 
1428     /*
1429      * Mark unit and scale as not set
1430      * (different from default values, see below)
1431      */
1432     info->unit     = NULL;
1433     info->scale    = 0.0;
1434     info->snapshot = false;
1435     info->metric_expr = NULL;
1436     info->metric_name = NULL;
1437 
1438     list_for_each_entry_safe(term, h, head_terms, list) {
1439         alias = pmu_find_alias(pmu, term);
1440         if (!alias)
1441             continue;
1442         ret = pmu_alias_terms(alias, &term->list);
1443         if (ret)
1444             return ret;
1445 
1446         ret = check_info_data(alias, info);
1447         if (ret)
1448             return ret;
1449 
1450         if (alias->per_pkg)
1451             info->per_pkg = true;
1452         info->metric_expr = alias->metric_expr;
1453         info->metric_name = alias->metric_name;
1454 
1455         list_del_init(&term->list);
1456         parse_events_term__delete(term);
1457     }
1458 
1459     /*
1460      * if no unit or scale found in aliases, then
1461      * set defaults as for evsel
1462      * unit cannot left to NULL
1463      */
1464     if (info->unit == NULL)
1465         info->unit   = "";
1466 
1467     if (info->scale == 0.0)
1468         info->scale  = 1.0;
1469 
1470     return 0;
1471 }
1472 
1473 int perf_pmu__new_format(struct list_head *list, char *name,
1474              int config, unsigned long *bits)
1475 {
1476     struct perf_pmu_format *format;
1477 
1478     format = zalloc(sizeof(*format));
1479     if (!format)
1480         return -ENOMEM;
1481 
1482     format->name = strdup(name);
1483     format->value = config;
1484     memcpy(format->bits, bits, sizeof(format->bits));
1485 
1486     list_add_tail(&format->list, list);
1487     return 0;
1488 }
1489 
1490 void perf_pmu__set_format(unsigned long *bits, long from, long to)
1491 {
1492     long b;
1493 
1494     if (!to)
1495         to = from;
1496 
1497     memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1498     for (b = from; b <= to; b++)
1499         set_bit(b, bits);
1500 }
1501 
1502 void perf_pmu__del_formats(struct list_head *formats)
1503 {
1504     struct perf_pmu_format *fmt, *tmp;
1505 
1506     list_for_each_entry_safe(fmt, tmp, formats, list) {
1507         list_del(&fmt->list);
1508         free(fmt->name);
1509         free(fmt);
1510     }
1511 }
1512 
1513 static int sub_non_neg(int a, int b)
1514 {
1515     if (b > a)
1516         return 0;
1517     return a - b;
1518 }
1519 
1520 static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
1521               struct perf_pmu_alias *alias)
1522 {
1523     struct parse_events_term *term;
1524     int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
1525 
1526     list_for_each_entry(term, &alias->terms, list) {
1527         if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1528             used += snprintf(buf + used, sub_non_neg(len, used),
1529                     ",%s=%s", term->config,
1530                     term->val.str);
1531     }
1532 
1533     if (sub_non_neg(len, used) > 0) {
1534         buf[used] = '/';
1535         used++;
1536     }
1537     if (sub_non_neg(len, used) > 0) {
1538         buf[used] = '\0';
1539         used++;
1540     } else
1541         buf[len - 1] = '\0';
1542 
1543     return buf;
1544 }
1545 
1546 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
1547                  struct perf_pmu_alias *alias)
1548 {
1549     snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
1550     return buf;
1551 }
1552 
1553 struct sevent {
1554     char *name;
1555     char *desc;
1556     char *topic;
1557     char *str;
1558     char *pmu;
1559     char *metric_expr;
1560     char *metric_name;
1561     int is_cpu;
1562 };
1563 
1564 static int cmp_sevent(const void *a, const void *b)
1565 {
1566     const struct sevent *as = a;
1567     const struct sevent *bs = b;
1568     int ret;
1569 
1570     /* Put extra events last */
1571     if (!!as->desc != !!bs->desc)
1572         return !!as->desc - !!bs->desc;
1573     if (as->topic && bs->topic) {
1574         int n = strcmp(as->topic, bs->topic);
1575 
1576         if (n)
1577             return n;
1578     }
1579 
1580     /* Order CPU core events to be first */
1581     if (as->is_cpu != bs->is_cpu)
1582         return bs->is_cpu - as->is_cpu;
1583 
1584     ret = strcmp(as->name, bs->name);
1585     if (!ret) {
1586         if (as->pmu && bs->pmu)
1587             return strcmp(as->pmu, bs->pmu);
1588     }
1589 
1590     return ret;
1591 }
1592 
1593 static void wordwrap(char *s, int start, int max, int corr)
1594 {
1595     int column = start;
1596     int n;
1597 
1598     while (*s) {
1599         int wlen = strcspn(s, " \t");
1600 
1601         if (column + wlen >= max && column > start) {
1602             printf("\n%*s", start, "");
1603             column = start + corr;
1604         }
1605         n = printf("%s%.*s", column > start ? " " : "", wlen, s);
1606         if (n <= 0)
1607             break;
1608         s += wlen;
1609         column += n;
1610         s = skip_spaces(s);
1611     }
1612 }
1613 
1614 bool is_pmu_core(const char *name)
1615 {
1616     return !strcmp(name, "cpu") || is_arm_pmu_core(name);
1617 }
1618 
1619 static bool pmu_alias_is_duplicate(struct sevent *alias_a,
1620                    struct sevent *alias_b)
1621 {
1622     /* Different names -> never duplicates */
1623     if (strcmp(alias_a->name, alias_b->name))
1624         return false;
1625 
1626     /* Don't remove duplicates for hybrid PMUs */
1627     if (perf_pmu__is_hybrid(alias_a->pmu) &&
1628         perf_pmu__is_hybrid(alias_b->pmu))
1629         return false;
1630 
1631     return true;
1632 }
1633 
1634 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
1635             bool long_desc, bool details_flag, bool deprecated,
1636             const char *pmu_name)
1637 {
1638     struct perf_pmu *pmu;
1639     struct perf_pmu_alias *alias;
1640     char buf[1024];
1641     int printed = 0;
1642     int len, j;
1643     struct sevent *aliases;
1644     int numdesc = 0;
1645     int columns = pager_get_columns();
1646     char *topic = NULL;
1647 
1648     pmu = NULL;
1649     len = 0;
1650     while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1651         list_for_each_entry(alias, &pmu->aliases, list)
1652             len++;
1653         if (pmu->selectable)
1654             len++;
1655     }
1656     aliases = zalloc(sizeof(struct sevent) * len);
1657     if (!aliases)
1658         goto out_enomem;
1659     pmu = NULL;
1660     j = 0;
1661     while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1662         if (pmu_name && perf_pmu__is_hybrid(pmu->name) &&
1663             strcmp(pmu_name, pmu->name)) {
1664             continue;
1665         }
1666 
1667         list_for_each_entry(alias, &pmu->aliases, list) {
1668             char *name = alias->desc ? alias->name :
1669                 format_alias(buf, sizeof(buf), pmu, alias);
1670             bool is_cpu = is_pmu_core(pmu->name) ||
1671                       perf_pmu__is_hybrid(pmu->name);
1672 
1673             if (alias->deprecated && !deprecated)
1674                 continue;
1675 
1676             if (event_glob != NULL &&
1677                 !(strglobmatch_nocase(name, event_glob) ||
1678                   (!is_cpu && strglobmatch_nocase(alias->name,
1679                                event_glob)) ||
1680                   (alias->topic &&
1681                    strglobmatch_nocase(alias->topic, event_glob))))
1682                 continue;
1683 
1684             if (is_cpu && !name_only && !alias->desc)
1685                 name = format_alias_or(buf, sizeof(buf), pmu, alias);
1686 
1687             aliases[j].name = name;
1688             if (is_cpu && !name_only && !alias->desc)
1689                 aliases[j].name = format_alias_or(buf,
1690                                   sizeof(buf),
1691                                   pmu, alias);
1692             aliases[j].name = strdup(aliases[j].name);
1693             if (!aliases[j].name)
1694                 goto out_enomem;
1695 
1696             aliases[j].desc = long_desc ? alias->long_desc :
1697                         alias->desc;
1698             aliases[j].topic = alias->topic;
1699             aliases[j].str = alias->str;
1700             aliases[j].pmu = pmu->name;
1701             aliases[j].metric_expr = alias->metric_expr;
1702             aliases[j].metric_name = alias->metric_name;
1703             aliases[j].is_cpu = is_cpu;
1704             j++;
1705         }
1706         if (pmu->selectable &&
1707             (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1708             char *s;
1709             if (asprintf(&s, "%s//", pmu->name) < 0)
1710                 goto out_enomem;
1711             aliases[j].name = s;
1712             j++;
1713         }
1714     }
1715     len = j;
1716     qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1717     for (j = 0; j < len; j++) {
1718         /* Skip duplicates */
1719         if (j > 0 && pmu_alias_is_duplicate(&aliases[j], &aliases[j - 1]))
1720             continue;
1721 
1722         if (name_only) {
1723             printf("%s ", aliases[j].name);
1724             continue;
1725         }
1726         if (aliases[j].desc && !quiet_flag) {
1727             if (numdesc++ == 0)
1728                 printf("\n");
1729             if (aliases[j].topic && (!topic ||
1730                     strcmp(topic, aliases[j].topic))) {
1731                 printf("%s%s:\n", topic ? "\n" : "",
1732                         aliases[j].topic);
1733                 topic = aliases[j].topic;
1734             }
1735             printf("  %-50s\n", aliases[j].name);
1736             printf("%*s", 8, "[");
1737             wordwrap(aliases[j].desc, 8, columns, 0);
1738             printf("]\n");
1739             if (details_flag) {
1740                 printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1741                 if (aliases[j].metric_name)
1742                     printf(" MetricName: %s", aliases[j].metric_name);
1743                 if (aliases[j].metric_expr)
1744                     printf(" MetricExpr: %s", aliases[j].metric_expr);
1745                 putchar('\n');
1746             }
1747         } else
1748             printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1749         printed++;
1750     }
1751     if (printed && pager_in_use())
1752         printf("\n");
1753 out_free:
1754     for (j = 0; j < len; j++)
1755         zfree(&aliases[j].name);
1756     zfree(&aliases);
1757     return;
1758 
1759 out_enomem:
1760     printf("FATAL: not enough memory to print PMU events\n");
1761     if (aliases)
1762         goto out_free;
1763 }
1764 
1765 bool pmu_have_event(const char *pname, const char *name)
1766 {
1767     struct perf_pmu *pmu;
1768     struct perf_pmu_alias *alias;
1769 
1770     pmu = NULL;
1771     while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1772         if (strcmp(pname, pmu->name))
1773             continue;
1774         list_for_each_entry(alias, &pmu->aliases, list)
1775             if (!strcmp(alias->name, name))
1776                 return true;
1777     }
1778     return false;
1779 }
1780 
1781 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1782 {
1783     char path[PATH_MAX];
1784     const char *sysfs;
1785 
1786     sysfs = sysfs__mountpoint();
1787     if (!sysfs)
1788         return NULL;
1789 
1790     snprintf(path, PATH_MAX,
1791          "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
1792     if (!file_available(path))
1793         return NULL;
1794     return fopen(path, "r");
1795 }
1796 
1797 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1798             ...)
1799 {
1800     va_list args;
1801     FILE *file;
1802     int ret = EOF;
1803 
1804     va_start(args, fmt);
1805     file = perf_pmu__open_file(pmu, name);
1806     if (file) {
1807         ret = vfscanf(file, fmt, args);
1808         fclose(file);
1809     }
1810     va_end(args);
1811     return ret;
1812 }
1813 
1814 static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
1815 {
1816     struct perf_pmu_caps *caps = zalloc(sizeof(*caps));
1817 
1818     if (!caps)
1819         return -ENOMEM;
1820 
1821     caps->name = strdup(name);
1822     if (!caps->name)
1823         goto free_caps;
1824     caps->value = strndup(value, strlen(value) - 1);
1825     if (!caps->value)
1826         goto free_name;
1827     list_add_tail(&caps->list, list);
1828     return 0;
1829 
1830 free_name:
1831     zfree(caps->name);
1832 free_caps:
1833     free(caps);
1834 
1835     return -ENOMEM;
1836 }
1837 
1838 /*
1839  * Reading/parsing the given pmu capabilities, which should be located at:
1840  * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes.
1841  * Return the number of capabilities
1842  */
1843 int perf_pmu__caps_parse(struct perf_pmu *pmu)
1844 {
1845     struct stat st;
1846     char caps_path[PATH_MAX];
1847     const char *sysfs = sysfs__mountpoint();
1848     DIR *caps_dir;
1849     struct dirent *evt_ent;
1850 
1851     if (pmu->caps_initialized)
1852         return pmu->nr_caps;
1853 
1854     pmu->nr_caps = 0;
1855 
1856     if (!sysfs)
1857         return -1;
1858 
1859     snprintf(caps_path, PATH_MAX,
1860          "%s" EVENT_SOURCE_DEVICE_PATH "%s/caps", sysfs, pmu->name);
1861 
1862     if (stat(caps_path, &st) < 0) {
1863         pmu->caps_initialized = true;
1864         return 0;   /* no error if caps does not exist */
1865     }
1866 
1867     caps_dir = opendir(caps_path);
1868     if (!caps_dir)
1869         return -EINVAL;
1870 
1871     while ((evt_ent = readdir(caps_dir)) != NULL) {
1872         char path[PATH_MAX + NAME_MAX + 1];
1873         char *name = evt_ent->d_name;
1874         char value[128];
1875         FILE *file;
1876 
1877         if (!strcmp(name, ".") || !strcmp(name, ".."))
1878             continue;
1879 
1880         snprintf(path, sizeof(path), "%s/%s", caps_path, name);
1881 
1882         file = fopen(path, "r");
1883         if (!file)
1884             continue;
1885 
1886         if (!fgets(value, sizeof(value), file) ||
1887             (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {
1888             fclose(file);
1889             continue;
1890         }
1891 
1892         pmu->nr_caps++;
1893         fclose(file);
1894     }
1895 
1896     closedir(caps_dir);
1897 
1898     pmu->caps_initialized = true;
1899     return pmu->nr_caps;
1900 }
1901 
1902 void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
1903                    const char *name)
1904 {
1905     struct perf_pmu_format *format;
1906     __u64 masks = 0, bits;
1907     char buf[100];
1908     unsigned int i;
1909 
1910     list_for_each_entry(format, &pmu->format, list) {
1911         if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG)
1912             continue;
1913 
1914         for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
1915             masks |= 1ULL << i;
1916     }
1917 
1918     /*
1919      * Kernel doesn't export any valid format bits.
1920      */
1921     if (masks == 0)
1922         return;
1923 
1924     bits = config & ~masks;
1925     if (bits == 0)
1926         return;
1927 
1928     bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf));
1929 
1930     pr_warning("WARNING: event '%s' not valid (bits %s of config "
1931            "'%llx' not supported by kernel)!\n",
1932            name ?: "N/A", buf, config);
1933 }
1934 
1935 bool perf_pmu__has_hybrid(void)
1936 {
1937     if (!hybrid_scanned) {
1938         hybrid_scanned = true;
1939         perf_pmu__scan(NULL);
1940     }
1941 
1942     return !list_empty(&perf_pmu__hybrid_pmus);
1943 }
1944 
1945 int perf_pmu__match(char *pattern, char *name, char *tok)
1946 {
1947     if (!name)
1948         return -1;
1949 
1950     if (fnmatch(pattern, name, 0))
1951         return -1;
1952 
1953     if (tok && !perf_pmu__valid_suffix(name, tok))
1954         return -1;
1955 
1956     return 0;
1957 }
1958 
1959 int perf_pmu__cpus_match(struct perf_pmu *pmu, struct perf_cpu_map *cpus,
1960              struct perf_cpu_map **mcpus_ptr,
1961              struct perf_cpu_map **ucpus_ptr)
1962 {
1963     struct perf_cpu_map *pmu_cpus = pmu->cpus;
1964     struct perf_cpu_map *matched_cpus, *unmatched_cpus;
1965     struct perf_cpu cpu;
1966     int i, matched_nr = 0, unmatched_nr = 0;
1967 
1968     matched_cpus = perf_cpu_map__default_new();
1969     if (!matched_cpus)
1970         return -1;
1971 
1972     unmatched_cpus = perf_cpu_map__default_new();
1973     if (!unmatched_cpus) {
1974         perf_cpu_map__put(matched_cpus);
1975         return -1;
1976     }
1977 
1978     perf_cpu_map__for_each_cpu(cpu, i, cpus) {
1979         if (!perf_cpu_map__has(pmu_cpus, cpu))
1980             unmatched_cpus->map[unmatched_nr++] = cpu;
1981         else
1982             matched_cpus->map[matched_nr++] = cpu;
1983     }
1984 
1985     unmatched_cpus->nr = unmatched_nr;
1986     matched_cpus->nr = matched_nr;
1987     *mcpus_ptr = matched_cpus;
1988     *ucpus_ptr = unmatched_cpus;
1989     return 0;
1990 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!