License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 22:07:57 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2012-03-16 03:09:17 +08:00
|
|
|
#include <linux/list.h>
|
2015-06-10 15:25:07 +08:00
|
|
|
#include <linux/compiler.h>
|
2012-03-16 03:09:17 +08:00
|
|
|
#include <sys/types.h>
|
2017-04-18 21:46:11 +08:00
|
|
|
#include <errno.h>
|
2017-09-11 21:50:26 +08:00
|
|
|
#include <fcntl.h>
|
2017-04-20 07:57:47 +08:00
|
|
|
#include <sys/stat.h>
|
2012-03-16 03:09:17 +08:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
2014-07-31 14:00:49 +08:00
|
|
|
#include <stdbool.h>
|
2014-07-31 14:00:50 +08:00
|
|
|
#include <stdarg.h>
|
2012-03-16 03:09:17 +08:00
|
|
|
#include <dirent.h>
|
2013-12-10 00:14:24 +08:00
|
|
|
#include <api/fs/fs.h>
|
2013-11-13 00:58:49 +08:00
|
|
|
#include <locale.h>
|
2017-12-04 22:57:28 +08:00
|
|
|
#include <regex.h>
|
2012-03-16 03:09:17 +08:00
|
|
|
#include "util.h"
|
|
|
|
#include "pmu.h"
|
|
|
|
#include "parse-events.h"
|
2012-09-10 15:53:50 +08:00
|
|
|
#include "cpumap.h"
|
2016-09-16 06:24:40 +08:00
|
|
|
#include "header.h"
|
|
|
|
#include "pmu-events/pmu-events.h"
|
2016-09-16 06:24:44 +08:00
|
|
|
#include "cache.h"
|
2017-04-18 03:51:59 +08:00
|
|
|
#include "string2.h"
|
2012-03-16 03:09:17 +08:00
|
|
|
|
2013-01-19 04:05:09 +08:00
|
|
|
struct perf_pmu_format {
|
|
|
|
char *name;
|
|
|
|
int value;
|
|
|
|
DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2012-08-17 03:10:24 +08:00
|
|
|
#define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/"
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
int perf_pmu_parse(struct list_head *list, char *name);
|
|
|
|
extern FILE *perf_pmu_in;
|
|
|
|
|
|
|
|
static LIST_HEAD(pmus);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse & process all the sysfs attributes located under
|
|
|
|
* the directory specified in 'dir' parameter.
|
|
|
|
*/
|
2012-11-10 08:46:50 +08:00
|
|
|
int perf_pmu__format_parse(char *dir, struct list_head *head)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct dirent *evt_ent;
|
|
|
|
DIR *format_dir;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
format_dir = opendir(dir);
|
|
|
|
if (!format_dir)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
while (!ret && (evt_ent = readdir(format_dir))) {
|
|
|
|
char path[PATH_MAX];
|
|
|
|
char *name = evt_ent->d_name;
|
|
|
|
FILE *file;
|
|
|
|
|
|
|
|
if (!strcmp(name, ".") || !strcmp(name, ".."))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s/%s", dir, name);
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
file = fopen(path, "r");
|
|
|
|
if (!file)
|
|
|
|
break;
|
|
|
|
|
|
|
|
perf_pmu_in = file;
|
|
|
|
ret = perf_pmu_parse(head, name);
|
|
|
|
fclose(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(format_dir);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reading/parsing the default pmu format definition, which should be
|
|
|
|
* located at:
|
|
|
|
* /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
|
|
|
|
*/
|
2013-07-04 21:20:25 +08:00
|
|
|
static int pmu_format(const char *name, struct list_head *format)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char path[PATH_MAX];
|
2013-11-06 01:48:50 +08:00
|
|
|
const char *sysfs = sysfs__mountpoint();
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX,
|
2012-08-17 03:10:24 +08:00
|
|
|
"%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
if (stat(path, &st) < 0)
|
2012-06-15 04:38:37 +08:00
|
|
|
return 0; /* no error if format does not exist */
|
2012-03-16 03:09:17 +08:00
|
|
|
|
2012-11-10 08:46:50 +08:00
|
|
|
if (perf_pmu__format_parse(path, format))
|
2012-03-16 03:09:17 +08:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-03 23:08:23 +08:00
|
|
|
static int convert_scale(const char *scale, char **end, double *sval)
|
2013-11-13 00:58:49 +08:00
|
|
|
{
|
2016-03-09 02:42:30 +08:00
|
|
|
char *lc;
|
2017-01-03 23:08:23 +08:00
|
|
|
int ret = 0;
|
2015-05-31 14:06:23 +08:00
|
|
|
|
2013-11-13 00:58:49 +08:00
|
|
|
/*
|
|
|
|
* save current locale
|
|
|
|
*/
|
|
|
|
lc = setlocale(LC_NUMERIC, NULL);
|
|
|
|
|
perf tools: Fix locale handling in pmu parsing
Ingo reported regression on display format of big numbers, which is
missing separators (in default perf stat output).
triton:~/tip> perf stat -a sleep 1
...
127008602 cycles # 0.011 GHz
279538533 stalled-cycles-frontend # 220.09% frontend cycles idle
119213269 instructions # 0.94 insn per cycle
This is caused by recent change:
perf stat: Check existence of frontend/backed stalled cycles
that added call to pmu_have_event, that subsequently calls
perf_pmu__parse_scale, which has a bug in locale handling.
The lc string returned from setlocale, that we use to store old locale
value, may be allocated in static storage. Getting a dynamic copy to
make it survive another setlocale call.
$ perf stat ls
...
2,360,602 cycles # 3.080 GHz
2,703,090 instructions # 1.15 insn per cycle
546,031 branches # 712.511 M/sec
Committer note:
Since the patch introducing the regression didn't made to perf/core,
move it to just before where the regression was introduced, so that we
don't break bisection for this feature.
Reported-by: Ingo Molnar <mingo@redhat.com>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20160303095348.GA24511@krava.redhat.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-03-03 17:53:48 +08:00
|
|
|
/*
|
|
|
|
* The lc string may be allocated in static storage,
|
|
|
|
* so get a dynamic copy to make it survive setlocale
|
|
|
|
* call below.
|
|
|
|
*/
|
|
|
|
lc = strdup(lc);
|
|
|
|
if (!lc) {
|
|
|
|
ret = -ENOMEM;
|
2017-01-03 23:08:23 +08:00
|
|
|
goto out;
|
perf tools: Fix locale handling in pmu parsing
Ingo reported regression on display format of big numbers, which is
missing separators (in default perf stat output).
triton:~/tip> perf stat -a sleep 1
...
127008602 cycles # 0.011 GHz
279538533 stalled-cycles-frontend # 220.09% frontend cycles idle
119213269 instructions # 0.94 insn per cycle
This is caused by recent change:
perf stat: Check existence of frontend/backed stalled cycles
that added call to pmu_have_event, that subsequently calls
perf_pmu__parse_scale, which has a bug in locale handling.
The lc string returned from setlocale, that we use to store old locale
value, may be allocated in static storage. Getting a dynamic copy to
make it survive another setlocale call.
$ perf stat ls
...
2,360,602 cycles # 3.080 GHz
2,703,090 instructions # 1.15 insn per cycle
546,031 branches # 712.511 M/sec
Committer note:
Since the patch introducing the regression didn't made to perf/core,
move it to just before where the regression was introduced, so that we
don't break bisection for this feature.
Reported-by: Ingo Molnar <mingo@redhat.com>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20160303095348.GA24511@krava.redhat.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-03-03 17:53:48 +08:00
|
|
|
}
|
|
|
|
|
2013-11-13 00:58:49 +08:00
|
|
|
/*
|
|
|
|
* force to C locale to ensure kernel
|
|
|
|
* scale string is converted correctly.
|
|
|
|
* kernel uses default C locale.
|
|
|
|
*/
|
|
|
|
setlocale(LC_NUMERIC, "C");
|
|
|
|
|
2017-01-03 23:08:23 +08:00
|
|
|
*sval = strtod(scale, end);
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2017-01-03 23:08:23 +08:00
|
|
|
out:
|
2013-11-13 00:58:49 +08:00
|
|
|
/* restore locale */
|
|
|
|
setlocale(LC_NUMERIC, lc);
|
2016-03-09 02:42:30 +08:00
|
|
|
free(lc);
|
2017-01-03 23:08:23 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
ssize_t sret;
|
|
|
|
char scale[128];
|
|
|
|
int fd, ret = -1;
|
|
|
|
char path[PATH_MAX];
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s/%s.scale", dir, name);
|
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (fstat(fd, &st) < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
sret = read(fd, scale, sizeof(scale)-1);
|
|
|
|
if (sret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (scale[sret - 1] == '\n')
|
|
|
|
scale[sret - 1] = '\0';
|
|
|
|
else
|
|
|
|
scale[sret] = '\0';
|
perf tools: Fix locale handling in pmu parsing
Ingo reported regression on display format of big numbers, which is
missing separators (in default perf stat output).
triton:~/tip> perf stat -a sleep 1
...
127008602 cycles # 0.011 GHz
279538533 stalled-cycles-frontend # 220.09% frontend cycles idle
119213269 instructions # 0.94 insn per cycle
This is caused by recent change:
perf stat: Check existence of frontend/backed stalled cycles
that added call to pmu_have_event, that subsequently calls
perf_pmu__parse_scale, which has a bug in locale handling.
The lc string returned from setlocale, that we use to store old locale
value, may be allocated in static storage. Getting a dynamic copy to
make it survive another setlocale call.
$ perf stat ls
...
2,360,602 cycles # 3.080 GHz
2,703,090 instructions # 1.15 insn per cycle
546,031 branches # 712.511 M/sec
Committer note:
Since the patch introducing the regression didn't made to perf/core,
move it to just before where the regression was introduced, so that we
don't break bisection for this feature.
Reported-by: Ingo Molnar <mingo@redhat.com>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20160303095348.GA24511@krava.redhat.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-03-03 17:53:48 +08:00
|
|
|
|
2017-01-03 23:08:23 +08:00
|
|
|
ret = convert_scale(scale, NULL, &alias->scale);
|
2013-11-13 00:58:49 +08:00
|
|
|
error:
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
ssize_t sret;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s/%s.unit", dir, name);
|
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
2015-12-14 23:44:40 +08:00
|
|
|
sret = read(fd, alias->unit, UNIT_MAX_LEN);
|
2013-11-13 00:58:49 +08:00
|
|
|
if (sret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
|
2015-05-31 14:06:23 +08:00
|
|
|
if (alias->unit[sret - 1] == '\n')
|
|
|
|
alias->unit[sret - 1] = '\0';
|
|
|
|
else
|
|
|
|
alias->unit[sret] = '\0';
|
2013-11-13 00:58:49 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
close(fd);
|
|
|
|
alias->unit[0] = '\0';
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-11-21 17:31:12 +08:00
|
|
|
static int
|
|
|
|
perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name);
|
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
alias->per_pkg = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-21 17:31:13 +08:00
|
|
|
static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
|
|
|
|
char *dir, char *name)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name);
|
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
alias->snapshot = true;
|
|
|
|
close(fd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-10 15:25:08 +08:00
|
|
|
static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
|
2017-01-28 10:03:37 +08:00
|
|
|
char *desc, char *val,
|
|
|
|
char *long_desc, char *topic,
|
2017-03-21 04:17:07 +08:00
|
|
|
char *unit, char *perpkg,
|
2017-03-21 04:17:10 +08:00
|
|
|
char *metric_expr,
|
|
|
|
char *metric_name)
|
2012-06-15 14:31:41 +08:00
|
|
|
{
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_alias *alias;
|
2012-06-15 14:31:41 +08:00
|
|
|
int ret;
|
2017-01-28 10:03:37 +08:00
|
|
|
int num;
|
2012-06-15 14:31:41 +08:00
|
|
|
|
|
|
|
alias = malloc(sizeof(*alias));
|
|
|
|
if (!alias)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&alias->terms);
|
2013-11-13 00:58:49 +08:00
|
|
|
alias->scale = 1.0;
|
|
|
|
alias->unit[0] = '\0';
|
2014-11-21 17:31:12 +08:00
|
|
|
alias->per_pkg = false;
|
2016-01-07 02:50:01 +08:00
|
|
|
alias->snapshot = false;
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2015-06-10 15:25:08 +08:00
|
|
|
ret = parse_events_terms(&alias->terms, val);
|
2012-06-15 14:31:41 +08:00
|
|
|
if (ret) {
|
2015-06-10 15:25:08 +08:00
|
|
|
pr_err("Cannot parse alias %s: %d\n", val, ret);
|
2012-06-15 14:31:41 +08:00
|
|
|
free(alias);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
alias->name = strdup(name);
|
2015-06-10 15:25:08 +08:00
|
|
|
if (dir) {
|
|
|
|
/*
|
|
|
|
* load unit name and scale if available
|
|
|
|
*/
|
|
|
|
perf_pmu__parse_unit(alias, dir, name);
|
|
|
|
perf_pmu__parse_scale(alias, dir, name);
|
|
|
|
perf_pmu__parse_per_pkg(alias, dir, name);
|
|
|
|
perf_pmu__parse_snapshot(alias, dir, name);
|
|
|
|
}
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2017-03-21 04:17:07 +08:00
|
|
|
alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
|
2017-03-21 04:17:10 +08:00
|
|
|
alias->metric_name = metric_name ? strdup(metric_name): NULL;
|
2016-09-16 06:24:43 +08:00
|
|
|
alias->desc = desc ? strdup(desc) : NULL;
|
2016-09-16 06:24:48 +08:00
|
|
|
alias->long_desc = long_desc ? strdup(long_desc) :
|
|
|
|
desc ? strdup(desc) : NULL;
|
2016-09-16 06:24:50 +08:00
|
|
|
alias->topic = topic ? strdup(topic) : NULL;
|
2017-01-28 10:03:37 +08:00
|
|
|
if (unit) {
|
|
|
|
if (convert_scale(unit, &unit, &alias->scale) < 0)
|
|
|
|
return -1;
|
|
|
|
snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
|
|
|
|
}
|
|
|
|
alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
|
2017-01-28 10:03:40 +08:00
|
|
|
alias->str = strdup(val);
|
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
list_add_tail(&alias->list, list);
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-10 15:25:08 +08:00
|
|
|
static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file)
|
|
|
|
{
|
|
|
|
char buf[256];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = fread(buf, 1, sizeof(buf), file);
|
|
|
|
if (ret == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
buf[ret] = 0;
|
|
|
|
|
2017-01-28 10:03:37 +08:00
|
|
|
return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
|
2017-03-21 04:17:10 +08:00
|
|
|
NULL, NULL, NULL);
|
2015-06-10 15:25:08 +08:00
|
|
|
}
|
|
|
|
|
2014-09-24 22:04:06 +08:00
|
|
|
static inline bool pmu_alias_info_file(char *name)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
len = strlen(name);
|
|
|
|
if (len > 5 && !strcmp(name + len - 5, ".unit"))
|
|
|
|
return true;
|
|
|
|
if (len > 6 && !strcmp(name + len - 6, ".scale"))
|
|
|
|
return true;
|
2014-11-21 17:31:12 +08:00
|
|
|
if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
|
|
|
|
return true;
|
2014-11-21 17:31:13 +08:00
|
|
|
if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
|
|
|
|
return true;
|
2014-09-24 22:04:06 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
/*
|
|
|
|
* Process all the sysfs attributes located under the directory
|
|
|
|
* specified in 'dir' parameter.
|
|
|
|
*/
|
|
|
|
static int pmu_aliases_parse(char *dir, struct list_head *head)
|
|
|
|
{
|
|
|
|
struct dirent *evt_ent;
|
|
|
|
DIR *event_dir;
|
|
|
|
|
|
|
|
event_dir = opendir(dir);
|
|
|
|
if (!event_dir)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-02-18 06:44:55 +08:00
|
|
|
while ((evt_ent = readdir(event_dir))) {
|
2012-06-15 14:31:41 +08:00
|
|
|
char path[PATH_MAX];
|
|
|
|
char *name = evt_ent->d_name;
|
|
|
|
FILE *file;
|
|
|
|
|
|
|
|
if (!strcmp(name, ".") || !strcmp(name, ".."))
|
|
|
|
continue;
|
|
|
|
|
2013-11-13 00:58:49 +08:00
|
|
|
/*
|
2014-09-24 22:04:06 +08:00
|
|
|
* skip info files parsed in perf_pmu__new_alias()
|
2013-11-13 00:58:49 +08:00
|
|
|
*/
|
2014-09-24 22:04:06 +08:00
|
|
|
if (pmu_alias_info_file(name))
|
2013-11-13 00:58:49 +08:00
|
|
|
continue;
|
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
snprintf(path, PATH_MAX, "%s/%s", dir, name);
|
|
|
|
|
|
|
|
file = fopen(path, "r");
|
2016-02-18 06:44:55 +08:00
|
|
|
if (!file) {
|
|
|
|
pr_debug("Cannot open %s\n", path);
|
|
|
|
continue;
|
|
|
|
}
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2016-02-18 06:44:55 +08:00
|
|
|
if (perf_pmu__new_alias(head, dir, name, file) < 0)
|
|
|
|
pr_debug("Cannot set up %s\n", name);
|
2012-06-15 14:31:41 +08:00
|
|
|
fclose(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(event_dir);
|
2016-02-18 06:44:55 +08:00
|
|
|
return 0;
|
2012-06-15 14:31:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reading the pmu event aliases definition, which should be located at:
|
|
|
|
* /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
|
|
|
|
*/
|
2013-07-04 21:20:25 +08:00
|
|
|
static int pmu_aliases(const char *name, struct list_head *head)
|
2012-06-15 14:31:41 +08:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char path[PATH_MAX];
|
2013-11-06 01:48:50 +08:00
|
|
|
const char *sysfs = sysfs__mountpoint();
|
2012-06-15 14:31:41 +08:00
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX,
|
|
|
|
"%s/bus/event_source/devices/%s/events", sysfs, name);
|
|
|
|
|
|
|
|
if (stat(path, &st) < 0)
|
2012-10-10 20:53:16 +08:00
|
|
|
return 0; /* no error if 'events' does not exist */
|
2012-06-15 14:31:41 +08:00
|
|
|
|
|
|
|
if (pmu_aliases_parse(path, head))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-19 03:54:00 +08:00
|
|
|
static int pmu_alias_terms(struct perf_pmu_alias *alias,
|
2012-06-15 14:31:41 +08:00
|
|
|
struct list_head *terms)
|
|
|
|
{
|
2014-04-17 02:49:02 +08:00
|
|
|
struct parse_events_term *term, *cloned;
|
2012-06-15 14:31:41 +08:00
|
|
|
LIST_HEAD(list);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
list_for_each_entry(term, &alias->terms, list) {
|
2014-04-17 02:49:02 +08:00
|
|
|
ret = parse_events_term__clone(&cloned, term);
|
2012-06-15 14:31:41 +08:00
|
|
|
if (ret) {
|
2016-02-13 03:48:00 +08:00
|
|
|
parse_events_terms__purge(&list);
|
2012-06-15 14:31:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2017-10-21 04:27:55 +08:00
|
|
|
/*
|
|
|
|
* Weak terms don't override command line options,
|
|
|
|
* which we don't want for implicit terms in aliases.
|
|
|
|
*/
|
|
|
|
cloned->weak = true;
|
2014-04-17 02:49:02 +08:00
|
|
|
list_add_tail(&cloned->list, &list);
|
2012-06-15 14:31:41 +08:00
|
|
|
}
|
|
|
|
list_splice(&list, terms);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
/*
|
|
|
|
* Reading/parsing the default pmu type value, which should be
|
|
|
|
* located at:
|
|
|
|
* /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
|
|
|
|
*/
|
2013-07-04 21:20:25 +08:00
|
|
|
static int pmu_type(const char *name, __u32 *type)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char path[PATH_MAX];
|
|
|
|
FILE *file;
|
|
|
|
int ret = 0;
|
2013-11-06 01:48:50 +08:00
|
|
|
const char *sysfs = sysfs__mountpoint();
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX,
|
2012-08-17 03:10:24 +08:00
|
|
|
"%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
if (stat(path, &st) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
file = fopen(path, "r");
|
|
|
|
if (!file)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (1 != fscanf(file, "%u", type))
|
|
|
|
ret = -1;
|
|
|
|
|
|
|
|
fclose(file);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-17 03:10:24 +08:00
|
|
|
/* Add all pmus in sysfs to pmu list: */
|
|
|
|
static void pmu_read_sysfs(void)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *dent;
|
2013-11-06 01:48:50 +08:00
|
|
|
const char *sysfs = sysfs__mountpoint();
|
2012-08-17 03:10:24 +08:00
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX,
|
|
|
|
"%s" EVENT_SOURCE_DEVICE_PATH, sysfs);
|
|
|
|
|
|
|
|
dir = opendir(path);
|
|
|
|
if (!dir)
|
|
|
|
return;
|
|
|
|
|
|
|
|
while ((dent = readdir(dir))) {
|
|
|
|
if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
|
|
|
|
continue;
|
|
|
|
/* add to static LIST_HEAD(pmus): */
|
|
|
|
perf_pmu__find(dent->d_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
static struct cpu_map *__pmu_cpumask(const char *path)
|
|
|
|
{
|
|
|
|
FILE *file;
|
|
|
|
struct cpu_map *cpus;
|
|
|
|
|
|
|
|
file = fopen(path, "r");
|
|
|
|
if (!file)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
cpus = cpu_map__read(file);
|
|
|
|
fclose(file);
|
|
|
|
return cpus;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
|
|
|
|
* may have a "cpus" file.
|
|
|
|
*/
|
|
|
|
#define CPUS_TEMPLATE_UNCORE "%s/bus/event_source/devices/%s/cpumask"
|
|
|
|
#define CPUS_TEMPLATE_CPU "%s/bus/event_source/devices/%s/cpus"
|
|
|
|
|
2013-07-04 21:20:25 +08:00
|
|
|
static struct cpu_map *pmu_cpumask(const char *name)
|
2012-09-10 15:53:50 +08:00
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
struct cpu_map *cpus;
|
2013-11-06 01:48:50 +08:00
|
|
|
const char *sysfs = sysfs__mountpoint();
|
perf pmu: Support alternative sysfs cpumask
The perf tools can read a cpumask file for a PMU, describing a subset of
CPUs which that PMU covers. So far this has only been used to cater for
uncore PMUs, which in practice happen to only have a single CPU
described in the mask.
Until recently, the perf tools only correctly handled cpumask containing
a single CPU, and only when monitoring in system-wide mode. For example,
prior to commit 00e727bb389359c8 ("perf stat: Balance opening and
reading events"), a mask with more than a single CPU could cause perf
stat to hang. When a CPU PMU covers a subset of CPUs, but lacks a
cpumask, perf record will fail to open events (on the cores the PMU does
not support), and gives up.
For systems with heterogeneous CPUs such as ARM big.LITTLE systems, this
presents a problem. We have a PMU for each microarchitecture (e.g. a big
PMU and a little PMU), and would like to expose a cpumask for each (so
as to allow perf record and other tools to do the right thing). However,
doing so kernel-side will cause old perf binaries to not function (e.g.
hitting the issue solved by 00e727bb389359c8), and thus commits the
cardinal sin of breaking (existing) userspace.
To address this chicken-and-egg problem, this patch adds support got a
new file, cpus, which is largely identical to the existing cpumask file.
A kernel can expose this file, knowing that new perf binaries will
correctly support it, while old perf binaries will not look for it (and
thus will not be broken).
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will.deacon@arm.com>
Link: http://lkml.kernel.org/r/1473330112-28528-8-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-09-08 18:21:52 +08:00
|
|
|
const char *templates[] = {
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
CPUS_TEMPLATE_UNCORE,
|
|
|
|
CPUS_TEMPLATE_CPU,
|
|
|
|
NULL
|
perf pmu: Support alternative sysfs cpumask
The perf tools can read a cpumask file for a PMU, describing a subset of
CPUs which that PMU covers. So far this has only been used to cater for
uncore PMUs, which in practice happen to only have a single CPU
described in the mask.
Until recently, the perf tools only correctly handled cpumask containing
a single CPU, and only when monitoring in system-wide mode. For example,
prior to commit 00e727bb389359c8 ("perf stat: Balance opening and
reading events"), a mask with more than a single CPU could cause perf
stat to hang. When a CPU PMU covers a subset of CPUs, but lacks a
cpumask, perf record will fail to open events (on the cores the PMU does
not support), and gives up.
For systems with heterogeneous CPUs such as ARM big.LITTLE systems, this
presents a problem. We have a PMU for each microarchitecture (e.g. a big
PMU and a little PMU), and would like to expose a cpumask for each (so
as to allow perf record and other tools to do the right thing). However,
doing so kernel-side will cause old perf binaries to not function (e.g.
hitting the issue solved by 00e727bb389359c8), and thus commits the
cardinal sin of breaking (existing) userspace.
To address this chicken-and-egg problem, this patch adds support got a
new file, cpus, which is largely identical to the existing cpumask file.
A kernel can expose this file, knowing that new perf binaries will
correctly support it, while old perf binaries will not look for it (and
thus will not be broken).
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will.deacon@arm.com>
Link: http://lkml.kernel.org/r/1473330112-28528-8-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-09-08 18:21:52 +08:00
|
|
|
};
|
|
|
|
const char **template;
|
2012-09-10 15:53:50 +08:00
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return NULL;
|
|
|
|
|
perf pmu: Support alternative sysfs cpumask
The perf tools can read a cpumask file for a PMU, describing a subset of
CPUs which that PMU covers. So far this has only been used to cater for
uncore PMUs, which in practice happen to only have a single CPU
described in the mask.
Until recently, the perf tools only correctly handled cpumask containing
a single CPU, and only when monitoring in system-wide mode. For example,
prior to commit 00e727bb389359c8 ("perf stat: Balance opening and
reading events"), a mask with more than a single CPU could cause perf
stat to hang. When a CPU PMU covers a subset of CPUs, but lacks a
cpumask, perf record will fail to open events (on the cores the PMU does
not support), and gives up.
For systems with heterogeneous CPUs such as ARM big.LITTLE systems, this
presents a problem. We have a PMU for each microarchitecture (e.g. a big
PMU and a little PMU), and would like to expose a cpumask for each (so
as to allow perf record and other tools to do the right thing). However,
doing so kernel-side will cause old perf binaries to not function (e.g.
hitting the issue solved by 00e727bb389359c8), and thus commits the
cardinal sin of breaking (existing) userspace.
To address this chicken-and-egg problem, this patch adds support got a
new file, cpus, which is largely identical to the existing cpumask file.
A kernel can expose this file, knowing that new perf binaries will
correctly support it, while old perf binaries will not look for it (and
thus will not be broken).
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will.deacon@arm.com>
Link: http://lkml.kernel.org/r/1473330112-28528-8-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-09-08 18:21:52 +08:00
|
|
|
for (template = templates; *template; template++) {
|
|
|
|
snprintf(path, PATH_MAX, *template, sysfs, name);
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
cpus = __pmu_cpumask(path);
|
|
|
|
if (cpus)
|
|
|
|
return cpus;
|
perf pmu: Support alternative sysfs cpumask
The perf tools can read a cpumask file for a PMU, describing a subset of
CPUs which that PMU covers. So far this has only been used to cater for
uncore PMUs, which in practice happen to only have a single CPU
described in the mask.
Until recently, the perf tools only correctly handled cpumask containing
a single CPU, and only when monitoring in system-wide mode. For example,
prior to commit 00e727bb389359c8 ("perf stat: Balance opening and
reading events"), a mask with more than a single CPU could cause perf
stat to hang. When a CPU PMU covers a subset of CPUs, but lacks a
cpumask, perf record will fail to open events (on the cores the PMU does
not support), and gives up.
For systems with heterogeneous CPUs such as ARM big.LITTLE systems, this
presents a problem. We have a PMU for each microarchitecture (e.g. a big
PMU and a little PMU), and would like to expose a cpumask for each (so
as to allow perf record and other tools to do the right thing). However,
doing so kernel-side will cause old perf binaries to not function (e.g.
hitting the issue solved by 00e727bb389359c8), and thus commits the
cardinal sin of breaking (existing) userspace.
To address this chicken-and-egg problem, this patch adds support got a
new file, cpus, which is largely identical to the existing cpumask file.
A kernel can expose this file, knowing that new perf binaries will
correctly support it, while old perf binaries will not look for it (and
thus will not be broken).
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Will Deacon <will.deacon@arm.com>
Link: http://lkml.kernel.org/r/1473330112-28528-8-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-09-08 18:21:52 +08:00
|
|
|
}
|
2012-09-10 15:53:50 +08:00
|
|
|
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-09-10 15:53:50 +08:00
|
|
|
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
static bool pmu_is_uncore(const char *name)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
struct cpu_map *cpus;
|
|
|
|
const char *sysfs = sysfs__mountpoint();
|
2012-09-10 15:53:50 +08:00
|
|
|
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name);
|
|
|
|
cpus = __pmu_cpumask(path);
|
|
|
|
cpu_map__put(cpus);
|
|
|
|
|
|
|
|
return !!cpus;
|
2012-09-10 15:53:50 +08:00
|
|
|
}
|
|
|
|
|
2017-08-24 19:00:58 +08:00
|
|
|
/*
|
|
|
|
* PMU CORE devices have different name other than cpu in sysfs on some
|
|
|
|
* platforms. looking for possible sysfs files to identify as core device.
|
|
|
|
*/
|
|
|
|
static int is_pmu_core(const char *name)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *sysfs = sysfs__mountpoint();
|
|
|
|
|
|
|
|
if (!sysfs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Look for cpu sysfs (x86 and others) */
|
|
|
|
scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu", sysfs);
|
|
|
|
if ((stat(path, &st) == 0) &&
|
|
|
|
(strncmp(name, "cpu", strlen("cpu")) == 0))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Look for cpu sysfs (specific to arm) */
|
|
|
|
scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus",
|
|
|
|
sysfs, name);
|
|
|
|
if (stat(path, &st) == 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-16 06:24:40 +08:00
|
|
|
/*
|
|
|
|
* Return the CPU id as a raw string.
|
|
|
|
*
|
|
|
|
* Each architecture should provide a more precise id string that
|
|
|
|
* can be use to match the architecture's "mapfile".
|
|
|
|
*/
|
2017-10-17 02:32:18 +08:00
|
|
|
char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused)
|
2016-09-16 06:24:40 +08:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-10-17 02:32:18 +08:00
|
|
|
static char *perf_pmu__getcpuid(struct perf_pmu *pmu)
|
2016-09-16 06:24:40 +08:00
|
|
|
{
|
|
|
|
char *cpuid;
|
2016-10-14 05:15:24 +08:00
|
|
|
static bool printed;
|
2016-09-16 06:24:40 +08:00
|
|
|
|
2016-09-16 06:24:46 +08:00
|
|
|
cpuid = getenv("PERF_CPUID");
|
|
|
|
if (cpuid)
|
|
|
|
cpuid = strdup(cpuid);
|
|
|
|
if (!cpuid)
|
2017-10-17 02:32:18 +08:00
|
|
|
cpuid = get_cpuid_str(pmu);
|
2016-09-16 06:24:40 +08:00
|
|
|
if (!cpuid)
|
2017-09-01 03:40:30 +08:00
|
|
|
return NULL;
|
2016-09-16 06:24:40 +08:00
|
|
|
|
2016-10-14 05:15:24 +08:00
|
|
|
if (!printed) {
|
|
|
|
pr_debug("Using CPUID %s\n", cpuid);
|
|
|
|
printed = true;
|
|
|
|
}
|
2017-09-01 03:40:30 +08:00
|
|
|
return cpuid;
|
|
|
|
}
|
|
|
|
|
2017-10-17 02:32:18 +08:00
|
|
|
struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu)
|
2017-09-01 03:40:30 +08:00
|
|
|
{
|
|
|
|
struct pmu_events_map *map;
|
2017-10-17 02:32:18 +08:00
|
|
|
char *cpuid = perf_pmu__getcpuid(pmu);
|
2017-09-01 03:40:30 +08:00
|
|
|
int i;
|
2016-09-16 06:24:46 +08:00
|
|
|
|
2017-10-17 02:32:22 +08:00
|
|
|
/* on some platforms which uses cpus map, cpuid can be NULL for
|
|
|
|
* PMUs other than CORE PMUs.
|
|
|
|
*/
|
|
|
|
if (!cpuid)
|
|
|
|
return NULL;
|
|
|
|
|
2016-09-16 06:24:40 +08:00
|
|
|
i = 0;
|
2017-09-01 03:40:30 +08:00
|
|
|
for (;;) {
|
2017-12-04 22:57:28 +08:00
|
|
|
regex_t re;
|
|
|
|
regmatch_t pmatch[1];
|
|
|
|
int match;
|
|
|
|
|
2016-09-16 06:24:40 +08:00
|
|
|
map = &pmu_events_map[i++];
|
2017-09-01 03:40:30 +08:00
|
|
|
if (!map->table) {
|
|
|
|
map = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2016-09-16 06:24:40 +08:00
|
|
|
|
2017-12-04 22:57:28 +08:00
|
|
|
if (regcomp(&re, map->cpuid, REG_EXTENDED) != 0) {
|
|
|
|
/* Warn unable to generate match particular string. */
|
|
|
|
pr_info("Invalid regular expression %s\n", map->cpuid);
|
2016-09-16 06:24:40 +08:00
|
|
|
break;
|
2017-12-04 22:57:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
match = !regexec(&re, cpuid, 1, pmatch, 0);
|
|
|
|
regfree(&re);
|
|
|
|
if (match) {
|
|
|
|
size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);
|
|
|
|
|
|
|
|
/* Verify the entire string matched. */
|
|
|
|
if (match_len == strlen(cpuid))
|
|
|
|
break;
|
|
|
|
}
|
2016-09-16 06:24:40 +08:00
|
|
|
}
|
2017-09-01 03:40:30 +08:00
|
|
|
free(cpuid);
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* From the pmu_events_map, find the table of PMU events that corresponds
|
|
|
|
* to the current running CPU. Then, add all PMU events from that table
|
|
|
|
* as aliases.
|
|
|
|
*/
|
2017-10-17 02:32:18 +08:00
|
|
|
static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
|
2017-09-01 03:40:30 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pmu_events_map *map;
|
|
|
|
struct pmu_event *pe;
|
2017-10-17 02:32:18 +08:00
|
|
|
const char *name = pmu->name;
|
2017-09-01 03:40:30 +08:00
|
|
|
|
2017-10-17 02:32:18 +08:00
|
|
|
map = perf_pmu__find_map(pmu);
|
2017-09-01 03:40:30 +08:00
|
|
|
if (!map)
|
|
|
|
return;
|
2016-09-16 06:24:40 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Found a matching PMU events table. Create aliases
|
|
|
|
*/
|
|
|
|
i = 0;
|
|
|
|
while (1) {
|
2017-01-28 10:03:37 +08:00
|
|
|
|
2016-09-16 06:24:40 +08:00
|
|
|
pe = &map->table[i++];
|
2017-09-01 03:40:31 +08:00
|
|
|
if (!pe->name) {
|
|
|
|
if (pe->metric_group || pe->metric_name)
|
|
|
|
continue;
|
2016-09-16 06:24:40 +08:00
|
|
|
break;
|
2017-09-01 03:40:31 +08:00
|
|
|
}
|
2016-09-16 06:24:40 +08:00
|
|
|
|
2017-08-24 19:00:58 +08:00
|
|
|
if (!is_pmu_core(name)) {
|
|
|
|
/* check for uncore devices */
|
|
|
|
if (pe->pmu == NULL)
|
|
|
|
continue;
|
|
|
|
if (strncmp(pe->pmu, name, strlen(pe->pmu)))
|
|
|
|
continue;
|
|
|
|
}
|
2017-01-28 10:03:37 +08:00
|
|
|
|
2016-09-16 06:24:40 +08:00
|
|
|
/* need type casts to override 'const' */
|
|
|
|
__perf_pmu__new_alias(head, NULL, (char *)pe->name,
|
2016-09-16 06:24:48 +08:00
|
|
|
(char *)pe->desc, (char *)pe->event,
|
2017-01-28 10:03:37 +08:00
|
|
|
(char *)pe->long_desc, (char *)pe->topic,
|
2017-03-21 04:17:07 +08:00
|
|
|
(char *)pe->unit, (char *)pe->perpkg,
|
2017-03-21 04:17:10 +08:00
|
|
|
(char *)pe->metric_expr,
|
|
|
|
(char *)pe->metric_name);
|
2016-09-16 06:24:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-10 15:25:07 +08:00
|
|
|
struct perf_event_attr * __weak
|
2014-07-31 14:00:49 +08:00
|
|
|
perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-04 21:20:25 +08:00
|
|
|
static struct perf_pmu *pmu_lookup(const char *name)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct perf_pmu *pmu;
|
|
|
|
LIST_HEAD(format);
|
2012-06-15 14:31:41 +08:00
|
|
|
LIST_HEAD(aliases);
|
2012-03-16 03:09:17 +08:00
|
|
|
__u32 type;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The pmu data we store & need consists of the pmu
|
|
|
|
* type value and format definitions. Load both right
|
|
|
|
* now.
|
|
|
|
*/
|
|
|
|
if (pmu_format(name, &format))
|
|
|
|
return NULL;
|
|
|
|
|
2017-01-28 10:03:38 +08:00
|
|
|
/*
|
|
|
|
* Check the type first to avoid unnecessary work.
|
|
|
|
*/
|
|
|
|
if (pmu_type(name, &type))
|
2012-10-10 20:53:16 +08:00
|
|
|
return NULL;
|
|
|
|
|
2017-01-28 10:03:38 +08:00
|
|
|
if (pmu_aliases(name, &aliases))
|
2012-03-16 03:09:17 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pmu = zalloc(sizeof(*pmu));
|
|
|
|
if (!pmu)
|
|
|
|
return NULL;
|
|
|
|
|
2012-09-10 15:53:50 +08:00
|
|
|
pmu->cpus = pmu_cpumask(name);
|
2017-10-17 02:32:18 +08:00
|
|
|
pmu->name = strdup(name);
|
|
|
|
pmu->type = type;
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
pmu->is_uncore = pmu_is_uncore(name);
|
2017-10-17 02:32:18 +08:00
|
|
|
pmu_add_cpu_aliases(&aliases, pmu);
|
perf pmu: Unbreak perf record for arm/arm64 with events with explicit PMU
Currently, perf record is broken on arm/arm64 systems when the PMU is
specified explicitly as part of the event, e.g.
$ ./perf record -e armv8_cortex_a53/cpu_cycles/u true
In such cases, perf record fails to open events unless
perf_event_paranoid is set to -1, even if the PMU in question supports
mode exclusion. Further, even when perf_event_paranoid is toggled, no
samples are recorded.
This is an unintended side effect of commit:
e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
... which assumes that if a PMU has an associated cpu_map, it is an
uncore PMU, and forces events for such PMUs to be system-wide.
This is not true for arm/arm64 systems, which can have heterogeneous
CPUs. To account for this, multiple CPU PMUs are exposed, each with a
"cpus" field under sysfs, which the perf tool parses into a cpu_map. ARM
PMUs do not have a "cpumask" file, and only have a "cpus" file. For the
gory details as to why, see commit:
7e3fcffe95544010 ("perf pmu: Support alternative sysfs cpumask")
Given all of this, we can instead identify uncore PMUs by explicitly
checking for a "cpumask" file, and restore arm/arm64 PMU support back to
a working state. This patch does so, adding a new perf_pmu::is_uncore
field, and splitting the existing cpumask parsing so that it can be
reused.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Tested-by Will Deacon <will.deacon@arm.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: 4.12+ <stable@vger.kernel.org>
Fixes: e3ba76deef23064f ("perf tools: Force uncore events to system wide monitoring)
Link: http://lkml.kernel.org/r/1507315102-5942-1-git-send-email-mark.rutland@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-10-07 02:38:22 +08:00
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
INIT_LIST_HEAD(&pmu->format);
|
2012-06-15 14:31:41 +08:00
|
|
|
INIT_LIST_HEAD(&pmu->aliases);
|
2012-03-16 03:09:17 +08:00
|
|
|
list_splice(&format, &pmu->format);
|
2012-06-15 14:31:41 +08:00
|
|
|
list_splice(&aliases, &pmu->aliases);
|
2012-06-15 04:38:37 +08:00
|
|
|
list_add_tail(&pmu->list, &pmus);
|
2014-07-31 14:00:49 +08:00
|
|
|
|
|
|
|
pmu->default_config = perf_pmu__get_default_config(pmu);
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
return pmu;
|
|
|
|
}
|
|
|
|
|
2013-07-04 21:20:25 +08:00
|
|
|
static struct perf_pmu *pmu_find(const char *name)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct perf_pmu *pmu;
|
|
|
|
|
|
|
|
list_for_each_entry(pmu, &pmus, list)
|
|
|
|
if (!strcmp(pmu->name, name))
|
|
|
|
return pmu;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-17 03:10:24 +08:00
|
|
|
struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* pmu iterator: If pmu is NULL, we start at the begin,
|
|
|
|
* otherwise return the next pmu. Returns NULL on end.
|
|
|
|
*/
|
|
|
|
if (!pmu) {
|
|
|
|
pmu_read_sysfs();
|
|
|
|
pmu = list_prepare_entry(pmu, &pmus, list);
|
|
|
|
}
|
|
|
|
list_for_each_entry_continue(pmu, &pmus, list)
|
|
|
|
return pmu;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-04 21:20:25 +08:00
|
|
|
struct perf_pmu *perf_pmu__find(const char *name)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
struct perf_pmu *pmu;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Once PMU is loaded it stays in the list,
|
|
|
|
* so we keep us from multiple reading/parsing
|
|
|
|
* the pmu format definitions.
|
|
|
|
*/
|
|
|
|
pmu = pmu_find(name);
|
|
|
|
if (pmu)
|
|
|
|
return pmu;
|
|
|
|
|
|
|
|
return pmu_lookup(name);
|
|
|
|
}
|
|
|
|
|
2013-01-19 03:54:00 +08:00
|
|
|
static struct perf_pmu_format *
|
2015-07-18 00:33:49 +08:00
|
|
|
pmu_find_format(struct list_head *formats, const char *name)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_format *format;
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
list_for_each_entry(format, formats, list)
|
|
|
|
if (!strcmp(format->name, name))
|
|
|
|
return format;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-18 00:33:49 +08:00
|
|
|
__u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
|
|
|
|
{
|
|
|
|
struct perf_pmu_format *format = pmu_find_format(formats, name);
|
|
|
|
__u64 bits = 0;
|
|
|
|
int fbit;
|
|
|
|
|
|
|
|
if (!format)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
|
|
|
|
bits |= 1ULL << fbit;
|
|
|
|
|
|
|
|
return bits;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
/*
|
2014-07-31 14:00:49 +08:00
|
|
|
* Sets value based on the format definition (format parameter)
|
2012-03-16 03:09:17 +08:00
|
|
|
* and unformated value (value parameter).
|
|
|
|
*/
|
2014-07-31 14:00:49 +08:00
|
|
|
static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
|
|
|
|
bool zero)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
|
|
|
unsigned long fbit, vbit;
|
|
|
|
|
|
|
|
for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
|
|
|
|
|
|
|
|
if (!test_bit(fbit, format))
|
|
|
|
continue;
|
|
|
|
|
2014-07-31 14:00:49 +08:00
|
|
|
if (value & (1llu << vbit++))
|
|
|
|
*v |= (1llu << fbit);
|
|
|
|
else if (zero)
|
|
|
|
*v &= ~(1llu << fbit);
|
2012-03-16 03:09:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-18 00:33:50 +08:00
|
|
|
static __u64 pmu_format_max_value(const unsigned long *format)
|
|
|
|
{
|
2016-03-31 03:16:15 +08:00
|
|
|
__u64 w = 0;
|
|
|
|
int fbit;
|
2015-07-18 00:33:50 +08:00
|
|
|
|
2016-03-31 03:16:15 +08:00
|
|
|
for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
|
|
|
|
w |= (1ULL << fbit);
|
|
|
|
|
|
|
|
return w;
|
2015-07-18 00:33:50 +08:00
|
|
|
}
|
|
|
|
|
2015-01-08 09:13:50 +08:00
|
|
|
/*
|
|
|
|
* Term is a string term, and might be a param-term. Try to look up it's value
|
|
|
|
* in the remaining terms.
|
|
|
|
* - We have a term like "base-or-format-term=param-term",
|
|
|
|
* - We need to find the value supplied for "param-term" (with param-term named
|
|
|
|
* in a config string) later on in the term list.
|
|
|
|
*/
|
|
|
|
static int pmu_resolve_param_term(struct parse_events_term *term,
|
|
|
|
struct list_head *head_terms,
|
|
|
|
__u64 *value)
|
|
|
|
{
|
|
|
|
struct parse_events_term *t;
|
|
|
|
|
|
|
|
list_for_each_entry(t, head_terms, list) {
|
|
|
|
if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
|
|
|
|
if (!strcmp(t->config, term->config)) {
|
|
|
|
t->used = true;
|
|
|
|
*value = t->val.num;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-17 16:17:38 +08:00
|
|
|
if (verbose > 0)
|
2015-01-08 09:13:50 +08:00
|
|
|
printf("Required parameter '%s' not specified\n", term->config);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
static char *pmu_formats_string(struct list_head *formats)
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
{
|
|
|
|
struct perf_pmu_format *format;
|
2016-05-10 13:47:44 +08:00
|
|
|
char *str = NULL;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
unsigned i = 0;
|
|
|
|
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
if (!formats)
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* sysfs exported terms */
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
list_for_each_entry(format, formats, list)
|
2016-05-10 13:47:44 +08:00
|
|
|
if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
|
|
|
|
goto error;
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
str = strbuf_detach(&buf, NULL);
|
2016-05-10 13:47:44 +08:00
|
|
|
error:
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
strbuf_release(&buf);
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
/*
|
|
|
|
* Setup one of config[12] attr members based on the
|
2014-01-09 00:43:51 +08:00
|
|
|
* user input data - term parameter.
|
2012-03-16 03:09:17 +08:00
|
|
|
*/
|
|
|
|
static int pmu_config_term(struct list_head *formats,
|
|
|
|
struct perf_event_attr *attr,
|
2014-07-31 14:00:49 +08:00
|
|
|
struct parse_events_term *term,
|
2015-01-08 09:13:50 +08:00
|
|
|
struct list_head *head_terms,
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
bool zero, struct parse_events_error *err)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_format *format;
|
2012-03-16 03:09:17 +08:00
|
|
|
__u64 *vp;
|
2015-07-18 00:33:50 +08:00
|
|
|
__u64 val, max_val;
|
2015-01-08 09:13:50 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a parameter we've already used for parameterized-eval,
|
|
|
|
* skip it in normal eval.
|
|
|
|
*/
|
|
|
|
if (term->used)
|
|
|
|
return 0;
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hardcoded terms should be already in, so nothing
|
|
|
|
* to be done for them.
|
|
|
|
*/
|
|
|
|
if (parse_events__is_hardcoded_term(term))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
format = pmu_find_format(formats, term->config);
|
2015-01-08 09:13:50 +08:00
|
|
|
if (!format) {
|
2017-02-17 16:17:38 +08:00
|
|
|
if (verbose > 0)
|
2015-01-08 09:13:50 +08:00
|
|
|
printf("Invalid event/parameter '%s'\n", term->config);
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
if (err) {
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
char *pmu_term = pmu_formats_string(formats);
|
|
|
|
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
err->idx = term->err_term;
|
|
|
|
err->str = strdup("unknown term");
|
perf tools: Show proper error message for wrong terms of hw/sw events
Show proper error message and show valid terms when wrong config terms
is specified for hw/sw type perf events.
This patch makes the original error format function formats_error_string()
more generic, which only outputs the static config terms for hw/sw perf
events, and prepends pmu formats for pmu events.
Before this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
invalid or unsupported event: 'cpu-clock/freqx=200/'
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
After this patch:
$ perf record -e 'cpu-clock/freqx=200/' -a sleep 1
event syntax error: 'cpu-clock/freqx=200/'
\___ unknown term
valid terms: config,config1,config2,name,period,freq,branch_type,time,call-graph,stack-size
Run 'perf list' for a list of valid events
usage: perf record [<options>] [<command>]
or: perf record [<options>] -- <command> [<options>]
-e, --event <event> event selector. use 'perf list' to list available events
Signed-off-by: He Kuang <hekuang@huawei.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Wang Nan <wangnan0@huawei.com>
Cc: pi3orama@163.com
Link: http://lkml.kernel.org/r/1443412336-120050-2-git-send-email-hekuang@huawei.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-09-28 11:52:14 +08:00
|
|
|
err->help = parse_events_formats_error_string(pmu_term);
|
|
|
|
free(pmu_term);
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
}
|
2012-03-16 03:09:17 +08:00
|
|
|
return -EINVAL;
|
2015-01-08 09:13:50 +08:00
|
|
|
}
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
switch (format->value) {
|
|
|
|
case PERF_PMU_FORMAT_VALUE_CONFIG:
|
|
|
|
vp = &attr->config;
|
|
|
|
break;
|
|
|
|
case PERF_PMU_FORMAT_VALUE_CONFIG1:
|
|
|
|
vp = &attr->config1;
|
|
|
|
break;
|
|
|
|
case PERF_PMU_FORMAT_VALUE_CONFIG2:
|
|
|
|
vp = &attr->config2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-04-26 00:24:57 +08:00
|
|
|
/*
|
2015-01-08 09:13:50 +08:00
|
|
|
* Either directly use a numeric term, or try to translate string terms
|
|
|
|
* using event parameters.
|
2012-04-26 00:24:57 +08:00
|
|
|
*/
|
2017-02-17 22:00:56 +08:00
|
|
|
if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
|
|
|
|
if (term->no_value &&
|
|
|
|
bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
|
|
|
|
if (err) {
|
|
|
|
err->idx = term->err_val;
|
|
|
|
err->str = strdup("no value assigned for term");
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-01-08 09:13:50 +08:00
|
|
|
val = term->val.num;
|
2017-02-17 22:00:56 +08:00
|
|
|
} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
|
2015-01-08 09:13:50 +08:00
|
|
|
if (strcmp(term->val.str, "?")) {
|
2017-02-17 16:17:38 +08:00
|
|
|
if (verbose > 0) {
|
2015-01-08 09:13:50 +08:00
|
|
|
pr_info("Invalid sysfs entry %s=%s\n",
|
|
|
|
term->config, term->val.str);
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
}
|
|
|
|
if (err) {
|
|
|
|
err->idx = term->err_val;
|
|
|
|
err->str = strdup("expected numeric value");
|
|
|
|
}
|
2015-01-08 09:13:50 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmu_resolve_param_term(term, head_terms, &val))
|
|
|
|
return -EINVAL;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-07-18 00:33:50 +08:00
|
|
|
max_val = pmu_format_max_value(format->bits);
|
|
|
|
if (val > max_val) {
|
|
|
|
if (err) {
|
|
|
|
err->idx = term->err_val;
|
|
|
|
if (asprintf(&err->str,
|
|
|
|
"value too big for format, maximum is %llu",
|
|
|
|
(unsigned long long)max_val) < 0)
|
|
|
|
err->str = strdup("value too big for format");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Assume we don't care if !err, in which case the value will be
|
|
|
|
* silently truncated.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2015-01-08 09:13:50 +08:00
|
|
|
pmu_format_value(format->bits, val, vp, zero);
|
2012-03-16 03:09:17 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-10 08:46:50 +08:00
|
|
|
int perf_pmu__config_terms(struct list_head *formats,
|
|
|
|
struct perf_event_attr *attr,
|
2014-07-31 14:00:49 +08:00
|
|
|
struct list_head *head_terms,
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
bool zero, struct parse_events_error *err)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
2013-01-19 03:29:49 +08:00
|
|
|
struct parse_events_term *term;
|
2012-03-16 03:09:17 +08:00
|
|
|
|
2015-01-08 09:13:50 +08:00
|
|
|
list_for_each_entry(term, head_terms, list) {
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
if (pmu_config_term(formats, attr, term, head_terms,
|
|
|
|
zero, err))
|
2012-03-16 03:09:17 +08:00
|
|
|
return -EINVAL;
|
2015-01-08 09:13:50 +08:00
|
|
|
}
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configures event's 'attr' parameter based on the:
|
|
|
|
* 1) users input - specified in terms parameter
|
|
|
|
* 2) pmu format definitions - specified by pmu parameter
|
|
|
|
*/
|
|
|
|
int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
struct list_head *head_terms,
|
|
|
|
struct parse_events_error *err)
|
2012-03-16 03:09:17 +08:00
|
|
|
{
|
2014-07-31 14:00:49 +08:00
|
|
|
bool zero = !!pmu->default_config;
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
attr->type = pmu->type;
|
perf tools: Add term support for parse_events_error
Allowing event's term processing to report back error, like:
$ perf record -e 'cpu/even=0x1/' ls
event syntax error: 'cpu/even=0x1/'
\___ unknown term
valid terms: pc,any,inv,edge,cmask,event,in_tx,ldlat,umask,in_tx_cp,offcore_rsp,config,config1,config2,name,period,branch_type
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1429729824-13932-7-git-send-email-jolsa@kernel.org
[ Renamed 'error' variables to 'err', not to clash with util.h error() ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-23 03:10:21 +08:00
|
|
|
return perf_pmu__config_terms(&pmu->format, attr, head_terms,
|
|
|
|
zero, err);
|
2012-03-16 03:09:17 +08:00
|
|
|
}
|
|
|
|
|
2013-01-19 03:54:00 +08:00
|
|
|
static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
|
|
|
|
struct parse_events_term *term)
|
2012-06-15 14:31:41 +08:00
|
|
|
{
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_alias *alias;
|
2012-06-15 14:31:41 +08:00
|
|
|
char *name;
|
|
|
|
|
|
|
|
if (parse_events__is_hardcoded_term(term))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
|
|
|
|
if (term->val.num != 1)
|
|
|
|
return NULL;
|
|
|
|
if (pmu_find_format(&pmu->format, term->config))
|
|
|
|
return NULL;
|
|
|
|
name = term->config;
|
|
|
|
} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
|
|
|
|
if (strcasecmp(term->config, "event"))
|
|
|
|
return NULL;
|
|
|
|
name = term->val.str;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(alias, &pmu->aliases, list) {
|
|
|
|
if (!strcasecmp(alias->name, name))
|
|
|
|
return alias;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2014-11-21 17:31:13 +08:00
|
|
|
static int check_info_data(struct perf_pmu_alias *alias,
|
|
|
|
struct perf_pmu_info *info)
|
2013-11-13 00:58:49 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Only one term in event definition can
|
2014-11-21 17:31:13 +08:00
|
|
|
* define unit, scale and snapshot, fail
|
|
|
|
* if there's more than one.
|
2013-11-13 00:58:49 +08:00
|
|
|
*/
|
2017-02-15 21:06:20 +08:00
|
|
|
if ((info->unit && alias->unit[0]) ||
|
2014-11-21 17:31:13 +08:00
|
|
|
(info->scale && alias->scale) ||
|
|
|
|
(info->snapshot && alias->snapshot))
|
2013-11-13 00:58:49 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-02-15 21:06:20 +08:00
|
|
|
if (alias->unit[0])
|
2014-11-21 17:31:13 +08:00
|
|
|
info->unit = alias->unit;
|
2013-11-13 00:58:49 +08:00
|
|
|
|
|
|
|
if (alias->scale)
|
2014-11-21 17:31:13 +08:00
|
|
|
info->scale = alias->scale;
|
|
|
|
|
|
|
|
if (alias->snapshot)
|
|
|
|
info->snapshot = alias->snapshot;
|
2013-11-13 00:58:49 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
/*
|
|
|
|
* Find alias in the terms list and replace it with the terms
|
|
|
|
* defined for the alias
|
|
|
|
*/
|
2013-11-13 00:58:49 +08:00
|
|
|
int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
|
2014-09-24 22:04:06 +08:00
|
|
|
struct perf_pmu_info *info)
|
2012-06-15 14:31:41 +08:00
|
|
|
{
|
2013-01-19 03:29:49 +08:00
|
|
|
struct parse_events_term *term, *h;
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_alias *alias;
|
2012-06-15 14:31:41 +08:00
|
|
|
int ret;
|
|
|
|
|
2014-11-21 17:31:12 +08:00
|
|
|
info->per_pkg = false;
|
|
|
|
|
2014-01-17 23:34:05 +08:00
|
|
|
/*
|
|
|
|
* Mark unit and scale as not set
|
|
|
|
* (different from default values, see below)
|
|
|
|
*/
|
2014-11-21 17:31:13 +08:00
|
|
|
info->unit = NULL;
|
|
|
|
info->scale = 0.0;
|
|
|
|
info->snapshot = false;
|
perf stat: Output JSON MetricExpr metric
Add generic infrastructure to perf stat to output ratios for
"MetricExpr" entries in the event lists. Many events are more useful as
ratios than in raw form, typically some count in relation to total
ticks.
Transfer the MetricExpr information from the alias to the evsel.
We mark the events that need to be collected for MetricExpr, and also
link the events using them with a pointer. The code is careful to always
prefer the right event in the same group to minimize multiplexing
errors. At the moment only a single relation is supported.
Then add a rblist to the stat shadow code that remembers stats based on
the cpu and context.
Then finally update and retrieve and print these values similarly to the
existing hardcoded perf metrics. We use the simple expression parser
added earlier to evaluate the expression.
Normally we just output the result without further commentary, but for
--metric-only this would lead to empty columns. So for this case use the
original event as description.
There is no attempt to automatically add the MetricExpr event, if it is
missing, however we suggest it to the user, because the user tool
doesn't have enough information to reliably construct a group that is
guaranteed to schedule. So we leave that to the user.
% perf stat -a -I 1000 -e '{unc_p_clockticks,unc_p_freq_max_os_cycles}'
1.000147889 800,085,181 unc_p_clockticks
1.000147889 93,126,241 unc_p_freq_max_os_cycles # 11.6
2.000448381 800,218,217 unc_p_clockticks
2.000448381 142,516,095 unc_p_freq_max_os_cycles # 17.8
3.000639852 800,243,057 unc_p_clockticks
3.000639852 162,292,689 unc_p_freq_max_os_cycles # 20.3
% perf stat -a -I 1000 -e '{unc_p_clockticks,unc_p_freq_max_os_cycles}' --metric-only
# time freq_max_os_cycles %
1.000127077 0.9
2.000301436 0.7
3.000456379 0.0
v2: Change from DivideBy to MetricExpr
v3: Use expr__ prefix. Support more than one other event.
v4: Update description
v5: Only print warning message once for multiple PMUs.
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: http://lkml.kernel.org/r/20170320201711.14142-11-andi@firstfloor.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-03-21 04:17:08 +08:00
|
|
|
info->metric_expr = NULL;
|
2017-03-21 04:17:10 +08:00
|
|
|
info->metric_name = NULL;
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
list_for_each_entry_safe(term, h, head_terms, list) {
|
|
|
|
alias = pmu_find_alias(pmu, term);
|
|
|
|
if (!alias)
|
|
|
|
continue;
|
|
|
|
ret = pmu_alias_terms(alias, &term->list);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-11-13 00:58:49 +08:00
|
|
|
|
2014-11-21 17:31:13 +08:00
|
|
|
ret = check_info_data(alias, info);
|
2013-11-13 00:58:49 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-11-21 17:31:12 +08:00
|
|
|
if (alias->per_pkg)
|
|
|
|
info->per_pkg = true;
|
perf stat: Output JSON MetricExpr metric
Add generic infrastructure to perf stat to output ratios for
"MetricExpr" entries in the event lists. Many events are more useful as
ratios than in raw form, typically some count in relation to total
ticks.
Transfer the MetricExpr information from the alias to the evsel.
We mark the events that need to be collected for MetricExpr, and also
link the events using them with a pointer. The code is careful to always
prefer the right event in the same group to minimize multiplexing
errors. At the moment only a single relation is supported.
Then add a rblist to the stat shadow code that remembers stats based on
the cpu and context.
Then finally update and retrieve and print these values similarly to the
existing hardcoded perf metrics. We use the simple expression parser
added earlier to evaluate the expression.
Normally we just output the result without further commentary, but for
--metric-only this would lead to empty columns. So for this case use the
original event as description.
There is no attempt to automatically add the MetricExpr event, if it is
missing, however we suggest it to the user, because the user tool
doesn't have enough information to reliably construct a group that is
guaranteed to schedule. So we leave that to the user.
% perf stat -a -I 1000 -e '{unc_p_clockticks,unc_p_freq_max_os_cycles}'
1.000147889 800,085,181 unc_p_clockticks
1.000147889 93,126,241 unc_p_freq_max_os_cycles # 11.6
2.000448381 800,218,217 unc_p_clockticks
2.000448381 142,516,095 unc_p_freq_max_os_cycles # 17.8
3.000639852 800,243,057 unc_p_clockticks
3.000639852 162,292,689 unc_p_freq_max_os_cycles # 20.3
% perf stat -a -I 1000 -e '{unc_p_clockticks,unc_p_freq_max_os_cycles}' --metric-only
# time freq_max_os_cycles %
1.000127077 0.9
2.000301436 0.7
3.000456379 0.0
v2: Change from DivideBy to MetricExpr
v3: Use expr__ prefix. Support more than one other event.
v4: Update description
v5: Only print warning message once for multiple PMUs.
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: http://lkml.kernel.org/r/20170320201711.14142-11-andi@firstfloor.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-03-21 04:17:08 +08:00
|
|
|
info->metric_expr = alias->metric_expr;
|
2017-03-21 04:17:10 +08:00
|
|
|
info->metric_name = alias->metric_name;
|
2014-11-21 17:31:12 +08:00
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
list_del(&term->list);
|
|
|
|
free(term);
|
|
|
|
}
|
2014-01-17 23:34:05 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if no unit or scale foundin aliases, then
|
|
|
|
* set defaults as for evsel
|
|
|
|
* unit cannot left to NULL
|
|
|
|
*/
|
2014-09-24 22:04:06 +08:00
|
|
|
if (info->unit == NULL)
|
|
|
|
info->unit = "";
|
2014-01-17 23:34:05 +08:00
|
|
|
|
2014-09-24 22:04:06 +08:00
|
|
|
if (info->scale == 0.0)
|
|
|
|
info->scale = 1.0;
|
2014-01-17 23:34:05 +08:00
|
|
|
|
2012-06-15 14:31:41 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:09:17 +08:00
|
|
|
int perf_pmu__new_format(struct list_head *list, char *name,
|
|
|
|
int config, unsigned long *bits)
|
|
|
|
{
|
2013-01-19 03:54:00 +08:00
|
|
|
struct perf_pmu_format *format;
|
2012-03-16 03:09:17 +08:00
|
|
|
|
|
|
|
format = zalloc(sizeof(*format));
|
|
|
|
if (!format)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
format->name = strdup(name);
|
|
|
|
format->value = config;
|
|
|
|
memcpy(format->bits, bits, sizeof(format->bits));
|
|
|
|
|
|
|
|
list_add_tail(&format->list, list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void perf_pmu__set_format(unsigned long *bits, long from, long to)
|
|
|
|
{
|
|
|
|
long b;
|
|
|
|
|
|
|
|
if (!to)
|
|
|
|
to = from;
|
|
|
|
|
2013-01-18 01:11:30 +08:00
|
|
|
memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
|
2012-03-16 03:09:17 +08:00
|
|
|
for (b = from; b <= to; b++)
|
|
|
|
set_bit(b, bits);
|
|
|
|
}
|
2013-04-21 02:02:29 +08:00
|
|
|
|
2015-01-08 09:13:51 +08:00
|
|
|
static int sub_non_neg(int a, int b)
|
|
|
|
{
|
|
|
|
if (b > a)
|
|
|
|
return 0;
|
|
|
|
return a - b;
|
|
|
|
}
|
|
|
|
|
2013-04-21 02:02:29 +08:00
|
|
|
static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
|
|
|
|
struct perf_pmu_alias *alias)
|
|
|
|
{
|
2015-01-08 09:13:51 +08:00
|
|
|
struct parse_events_term *term;
|
|
|
|
int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
|
|
|
|
|
|
|
|
list_for_each_entry(term, &alias->terms, list) {
|
|
|
|
if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
|
|
|
|
used += snprintf(buf + used, sub_non_neg(len, used),
|
|
|
|
",%s=%s", term->config,
|
|
|
|
term->val.str);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sub_non_neg(len, used) > 0) {
|
|
|
|
buf[used] = '/';
|
|
|
|
used++;
|
|
|
|
}
|
|
|
|
if (sub_non_neg(len, used) > 0) {
|
|
|
|
buf[used] = '\0';
|
|
|
|
used++;
|
|
|
|
} else
|
|
|
|
buf[len - 1] = '\0';
|
|
|
|
|
2013-04-21 02:02:29 +08:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
|
|
|
|
struct perf_pmu_alias *alias)
|
|
|
|
{
|
|
|
|
snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2016-09-16 06:24:50 +08:00
|
|
|
struct sevent {
|
2016-09-16 06:24:43 +08:00
|
|
|
char *name;
|
|
|
|
char *desc;
|
2016-09-16 06:24:50 +08:00
|
|
|
char *topic;
|
2017-01-28 10:03:40 +08:00
|
|
|
char *str;
|
|
|
|
char *pmu;
|
2017-03-21 04:17:09 +08:00
|
|
|
char *metric_expr;
|
2017-03-21 04:17:10 +08:00
|
|
|
char *metric_name;
|
2016-09-16 06:24:43 +08:00
|
|
|
};
|
|
|
|
|
2016-09-16 06:24:50 +08:00
|
|
|
static int cmp_sevent(const void *a, const void *b)
|
2016-09-16 06:24:43 +08:00
|
|
|
{
|
2016-09-16 06:24:50 +08:00
|
|
|
const struct sevent *as = a;
|
|
|
|
const struct sevent *bs = b;
|
2016-09-16 06:24:43 +08:00
|
|
|
|
|
|
|
/* Put extra events last */
|
|
|
|
if (!!as->desc != !!bs->desc)
|
|
|
|
return !!as->desc - !!bs->desc;
|
2016-09-16 06:24:50 +08:00
|
|
|
if (as->topic && bs->topic) {
|
|
|
|
int n = strcmp(as->topic, bs->topic);
|
|
|
|
|
|
|
|
if (n)
|
|
|
|
return n;
|
|
|
|
}
|
2016-09-16 06:24:43 +08:00
|
|
|
return strcmp(as->name, bs->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wordwrap(char *s, int start, int max, int corr)
|
2013-04-21 02:02:29 +08:00
|
|
|
{
|
2016-09-16 06:24:43 +08:00
|
|
|
int column = start;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
while (*s) {
|
|
|
|
int wlen = strcspn(s, " \t");
|
|
|
|
|
|
|
|
if (column + wlen >= max && column > start) {
|
|
|
|
printf("\n%*s", start, "");
|
|
|
|
column = start + corr;
|
|
|
|
}
|
|
|
|
n = printf("%s%.*s", column > start ? " " : "", wlen, s);
|
|
|
|
if (n <= 0)
|
|
|
|
break;
|
|
|
|
s += wlen;
|
|
|
|
column += n;
|
2017-04-07 22:24:20 +08:00
|
|
|
s = ltrim(s);
|
2016-09-16 06:24:43 +08:00
|
|
|
}
|
2013-04-21 02:02:29 +08:00
|
|
|
}
|
|
|
|
|
2016-09-16 06:24:48 +08:00
|
|
|
void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
|
2017-03-21 04:17:11 +08:00
|
|
|
bool long_desc, bool details_flag)
|
2013-04-21 02:02:29 +08:00
|
|
|
{
|
|
|
|
struct perf_pmu *pmu;
|
|
|
|
struct perf_pmu_alias *alias;
|
|
|
|
char buf[1024];
|
|
|
|
int printed = 0;
|
|
|
|
int len, j;
|
2016-09-16 06:24:50 +08:00
|
|
|
struct sevent *aliases;
|
2016-09-16 06:24:43 +08:00
|
|
|
int numdesc = 0;
|
2016-09-16 06:24:44 +08:00
|
|
|
int columns = pager_get_columns();
|
2016-09-16 06:24:50 +08:00
|
|
|
char *topic = NULL;
|
2013-04-21 02:02:29 +08:00
|
|
|
|
|
|
|
pmu = NULL;
|
|
|
|
len = 0;
|
2014-10-23 18:45:10 +08:00
|
|
|
while ((pmu = perf_pmu__scan(pmu)) != NULL) {
|
2013-04-21 02:02:29 +08:00
|
|
|
list_for_each_entry(alias, &pmu->aliases, list)
|
|
|
|
len++;
|
2014-10-23 18:45:10 +08:00
|
|
|
if (pmu->selectable)
|
|
|
|
len++;
|
|
|
|
}
|
2016-09-16 06:24:50 +08:00
|
|
|
aliases = zalloc(sizeof(struct sevent) * len);
|
2013-04-21 02:02:29 +08:00
|
|
|
if (!aliases)
|
2014-10-24 21:25:09 +08:00
|
|
|
goto out_enomem;
|
2013-04-21 02:02:29 +08:00
|
|
|
pmu = NULL;
|
|
|
|
j = 0;
|
2014-10-23 18:45:10 +08:00
|
|
|
while ((pmu = perf_pmu__scan(pmu)) != NULL) {
|
2013-04-21 02:02:29 +08:00
|
|
|
list_for_each_entry(alias, &pmu->aliases, list) {
|
2016-09-16 06:24:43 +08:00
|
|
|
char *name = alias->desc ? alias->name :
|
|
|
|
format_alias(buf, sizeof(buf), pmu, alias);
|
2013-04-21 02:02:29 +08:00
|
|
|
bool is_cpu = !strcmp(pmu->name, "cpu");
|
|
|
|
|
|
|
|
if (event_glob != NULL &&
|
2016-10-20 01:50:01 +08:00
|
|
|
!(strglobmatch_nocase(name, event_glob) ||
|
|
|
|
(!is_cpu && strglobmatch_nocase(alias->name,
|
2016-10-20 02:45:23 +08:00
|
|
|
event_glob)) ||
|
|
|
|
(alias->topic &&
|
|
|
|
strglobmatch_nocase(alias->topic, event_glob))))
|
2013-04-21 02:02:29 +08:00
|
|
|
continue;
|
2014-10-24 21:25:09 +08:00
|
|
|
|
2016-09-16 06:24:43 +08:00
|
|
|
if (is_cpu && !name_only && !alias->desc)
|
2014-10-24 21:25:09 +08:00
|
|
|
name = format_alias_or(buf, sizeof(buf), pmu, alias);
|
|
|
|
|
2016-09-16 06:24:43 +08:00
|
|
|
aliases[j].name = name;
|
|
|
|
if (is_cpu && !name_only && !alias->desc)
|
|
|
|
aliases[j].name = format_alias_or(buf,
|
|
|
|
sizeof(buf),
|
|
|
|
pmu, alias);
|
|
|
|
aliases[j].name = strdup(aliases[j].name);
|
|
|
|
if (!aliases[j].name)
|
2014-10-24 21:25:09 +08:00
|
|
|
goto out_enomem;
|
2016-09-16 06:24:43 +08:00
|
|
|
|
2016-09-16 06:24:48 +08:00
|
|
|
aliases[j].desc = long_desc ? alias->long_desc :
|
|
|
|
alias->desc;
|
2016-09-16 06:24:50 +08:00
|
|
|
aliases[j].topic = alias->topic;
|
2017-01-28 10:03:40 +08:00
|
|
|
aliases[j].str = alias->str;
|
|
|
|
aliases[j].pmu = pmu->name;
|
2017-03-21 04:17:09 +08:00
|
|
|
aliases[j].metric_expr = alias->metric_expr;
|
2017-03-21 04:17:10 +08:00
|
|
|
aliases[j].metric_name = alias->metric_name;
|
2013-04-21 02:02:29 +08:00
|
|
|
j++;
|
|
|
|
}
|
2015-10-03 02:28:16 +08:00
|
|
|
if (pmu->selectable &&
|
|
|
|
(event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
|
2014-10-24 21:25:09 +08:00
|
|
|
char *s;
|
|
|
|
if (asprintf(&s, "%s//", pmu->name) < 0)
|
|
|
|
goto out_enomem;
|
2016-09-16 06:24:43 +08:00
|
|
|
aliases[j].name = s;
|
2014-10-23 18:45:10 +08:00
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
2013-04-21 02:02:29 +08:00
|
|
|
len = j;
|
2016-09-16 06:24:50 +08:00
|
|
|
qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
|
2013-04-21 02:02:29 +08:00
|
|
|
for (j = 0; j < len; j++) {
|
2017-01-28 10:03:38 +08:00
|
|
|
/* Skip duplicates */
|
|
|
|
if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name))
|
|
|
|
continue;
|
2013-04-21 02:02:29 +08:00
|
|
|
if (name_only) {
|
2016-09-16 06:24:43 +08:00
|
|
|
printf("%s ", aliases[j].name);
|
2013-04-21 02:02:29 +08:00
|
|
|
continue;
|
|
|
|
}
|
2016-09-16 06:24:45 +08:00
|
|
|
if (aliases[j].desc && !quiet_flag) {
|
2016-09-16 06:24:43 +08:00
|
|
|
if (numdesc++ == 0)
|
|
|
|
printf("\n");
|
2016-09-16 06:24:50 +08:00
|
|
|
if (aliases[j].topic && (!topic ||
|
|
|
|
strcmp(topic, aliases[j].topic))) {
|
|
|
|
printf("%s%s:\n", topic ? "\n" : "",
|
|
|
|
aliases[j].topic);
|
|
|
|
topic = aliases[j].topic;
|
|
|
|
}
|
2016-09-16 06:24:43 +08:00
|
|
|
printf(" %-50s\n", aliases[j].name);
|
|
|
|
printf("%*s", 8, "[");
|
|
|
|
wordwrap(aliases[j].desc, 8, columns, 0);
|
|
|
|
printf("]\n");
|
2017-03-21 04:17:11 +08:00
|
|
|
if (details_flag) {
|
2017-03-21 04:17:09 +08:00
|
|
|
printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
|
2017-03-21 04:17:10 +08:00
|
|
|
if (aliases[j].metric_name)
|
|
|
|
printf(" MetricName: %s", aliases[j].metric_name);
|
2017-03-21 04:17:09 +08:00
|
|
|
if (aliases[j].metric_expr)
|
|
|
|
printf(" MetricExpr: %s", aliases[j].metric_expr);
|
|
|
|
putchar('\n');
|
|
|
|
}
|
2016-09-16 06:24:43 +08:00
|
|
|
} else
|
|
|
|
printf(" %-50s [Kernel PMU event]\n", aliases[j].name);
|
2013-04-21 02:02:29 +08:00
|
|
|
printed++;
|
|
|
|
}
|
2015-10-01 04:13:26 +08:00
|
|
|
if (printed && pager_in_use())
|
2013-04-21 02:02:29 +08:00
|
|
|
printf("\n");
|
2014-10-24 21:25:09 +08:00
|
|
|
out_free:
|
|
|
|
for (j = 0; j < len; j++)
|
2016-09-16 06:24:43 +08:00
|
|
|
zfree(&aliases[j].name);
|
2014-10-24 21:25:09 +08:00
|
|
|
zfree(&aliases);
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_enomem:
|
|
|
|
printf("FATAL: not enough memory to print PMU events\n");
|
|
|
|
if (aliases)
|
|
|
|
goto out_free;
|
2013-04-21 02:02:29 +08:00
|
|
|
}
|
2013-08-22 07:47:26 +08:00
|
|
|
|
|
|
|
bool pmu_have_event(const char *pname, const char *name)
|
|
|
|
{
|
|
|
|
struct perf_pmu *pmu;
|
|
|
|
struct perf_pmu_alias *alias;
|
|
|
|
|
|
|
|
pmu = NULL;
|
|
|
|
while ((pmu = perf_pmu__scan(pmu)) != NULL) {
|
|
|
|
if (strcmp(pname, pmu->name))
|
|
|
|
continue;
|
|
|
|
list_for_each_entry(alias, &pmu->aliases, list)
|
|
|
|
if (!strcmp(alias->name, name))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2014-07-31 14:00:50 +08:00
|
|
|
|
|
|
|
static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *sysfs;
|
|
|
|
|
|
|
|
sysfs = sysfs__mountpoint();
|
|
|
|
if (!sysfs)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
snprintf(path, PATH_MAX,
|
|
|
|
"%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
|
|
|
|
|
|
|
|
if (stat(path, &st) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return fopen(path, "r");
|
|
|
|
}
|
|
|
|
|
|
|
|
int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
FILE *file;
|
|
|
|
int ret = EOF;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
file = perf_pmu__open_file(pmu, name);
|
|
|
|
if (file) {
|
|
|
|
ret = vfscanf(file, fmt, args);
|
|
|
|
fclose(file);
|
|
|
|
}
|
|
|
|
va_end(args);
|
|
|
|
return ret;
|
|
|
|
}
|