提交 1b36c03e 编写于 作者: A Adrian Hunter 提交者: Arnaldo Carvalho de Melo

perf record: Add support for using symbols in address filters

Symbols come from either the DSO or /proc/kallsyms for the kernel.
Details of the functionality can be found in Documentation/perf-record.txt.
Signed-off-by: NAdrian Hunter <adrian.hunter@intel.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mathieu Poirier <mathieu.poirier@linaro.org>
Link: http://lkml.kernel.org/r/1474641528-18776-8-git-send-email-adrian.hunter@intel.comSigned-off-by: NArnaldo Carvalho de Melo <acme@redhat.com>
上级 cd67f99f
......@@ -89,9 +89,62 @@ OPTIONS
--filter=<filter>::
Event filter. This option should follow a event selector (-e) which
selects tracepoint event(s). Multiple '--filter' options are combined
selects either tracepoint event(s) or a hardware trace PMU
(e.g. Intel PT or CoreSight).
- tracepoint filters
In the case of tracepoints, multiple '--filter' options are combined
using '&&'.
- address filters
A hardware trace PMU advertises its ability to accept a number of
address filters by specifying a non-zero value in
/sys/bus/event_source/devices/<pmu>/nr_addr_filters.
Address filters have the format:
filter|start|stop|tracestop <start> [/ <size>] [@<file name>]
Where:
- 'filter': defines a region that will be traced.
- 'start': defines an address at which tracing will begin.
- 'stop': defines an address at which tracing will stop.
- 'tracestop': defines a region in which tracing will stop.
<file name> is the name of the object file, <start> is the offset to the
code to trace in that file, and <size> is the size of the region to
trace. 'start' and 'stop' filters need not specify a <size>.
If no object file is specified then the kernel is assumed, in which case
the start address must be a current kernel memory address.
<start> can also be specified by providing the name of a symbol. If the
symbol name is not unique, it can be disambiguated by inserting #n where
'n' selects the n'th symbol in address order. Alternately #0, #g or #G
select only a global symbol. <size> can also be specified by providing
the name of a symbol, in which case the size is calculated to the end
of that symbol. For 'filter' and 'tracestop' filters, if <size> is
omitted and <start> is a symbol, then the size is calculated to the end
of that symbol.
If <size> is omitted and <start> is '*', then the start and size will
be calculated from the first and last symbols, i.e. to trace the whole
file.
If symbol names (or '*') are provided, they must be surrounded by white
space.
The filter passed to the kernel is not necessarily the same as entered.
To see the filter that is passed, use the -v option.
The kernel may not be able to configure a trace region if it is not
within a single mapping. MMAP events (or /proc/<pid>/maps) can be
examined to determine if that is a possibility.
Multiple filters can be separated with space or comma.
--exclude-perf::
Don't record events issued by perf itself. This option should follow
a event selector (-e) which selects tracepoint event(s). It adds a
......
......@@ -1581,6 +1581,18 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
if (err)
goto out;
/*
* Allow aliases to facilitate the lookup of symbols for address
* filters. Refer to auxtrace_parse_filters().
*/
symbol_conf.allow_aliases = true;
symbol__init(NULL);
err = auxtrace_parse_filters(rec->evlist);
if (err)
goto out;
if (dry_run)
goto out;
......@@ -1594,8 +1606,6 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
err = -ENOMEM;
symbol__init(NULL);
if (symbol_conf.kptr_restrict)
pr_warning(
"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
......
......@@ -16,6 +16,10 @@
#include <sys/types.h>
#include <sys/mman.h>
#include <stdbool.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <linux/kernel.h>
#include <linux/perf_event.h>
......@@ -35,9 +39,14 @@
#include "../perf.h"
#include "util.h"
#include "evlist.h"
#include "dso.h"
#include "map.h"
#include "pmu.h"
#include "evsel.h"
#include "cpumap.h"
#include "thread_map.h"
#include "asm/bug.h"
#include "symbol/kallsyms.h"
#include "auxtrace.h"
#include <linux/hash.h>
......@@ -1399,3 +1408,731 @@ void *auxtrace_cache__lookup(struct auxtrace_cache *c, u32 key)
return NULL;
}
static void addr_filter__free_str(struct addr_filter *filt)
{
free(filt->str);
filt->action = NULL;
filt->sym_from = NULL;
filt->sym_to = NULL;
filt->filename = NULL;
filt->str = NULL;
}
static struct addr_filter *addr_filter__new(void)
{
struct addr_filter *filt = zalloc(sizeof(*filt));
if (filt)
INIT_LIST_HEAD(&filt->list);
return filt;
}
static void addr_filter__free(struct addr_filter *filt)
{
if (filt)
addr_filter__free_str(filt);
free(filt);
}
static void addr_filters__add(struct addr_filters *filts,
struct addr_filter *filt)
{
list_add_tail(&filt->list, &filts->head);
filts->cnt += 1;
}
static void addr_filters__del(struct addr_filters *filts,
struct addr_filter *filt)
{
list_del_init(&filt->list);
filts->cnt -= 1;
}
void addr_filters__init(struct addr_filters *filts)
{
INIT_LIST_HEAD(&filts->head);
filts->cnt = 0;
}
void addr_filters__exit(struct addr_filters *filts)
{
struct addr_filter *filt, *n;
list_for_each_entry_safe(filt, n, &filts->head, list) {
addr_filters__del(filts, filt);
addr_filter__free(filt);
}
}
static int parse_num_or_str(char **inp, u64 *num, const char **str,
const char *str_delim)
{
*inp += strspn(*inp, " ");
if (isdigit(**inp)) {
char *endptr;
if (!num)
return -EINVAL;
errno = 0;
*num = strtoull(*inp, &endptr, 0);
if (errno)
return -errno;
if (endptr == *inp)
return -EINVAL;
*inp = endptr;
} else {
size_t n;
if (!str)
return -EINVAL;
*inp += strspn(*inp, " ");
*str = *inp;
n = strcspn(*inp, str_delim);
if (!n)
return -EINVAL;
*inp += n;
if (**inp) {
**inp = '\0';
*inp += 1;
}
}
return 0;
}
static int parse_action(struct addr_filter *filt)
{
if (!strcmp(filt->action, "filter")) {
filt->start = true;
filt->range = true;
} else if (!strcmp(filt->action, "start")) {
filt->start = true;
} else if (!strcmp(filt->action, "stop")) {
filt->start = false;
} else if (!strcmp(filt->action, "tracestop")) {
filt->start = false;
filt->range = true;
filt->action += 5; /* Change 'tracestop' to 'stop' */
} else {
return -EINVAL;
}
return 0;
}
static int parse_sym_idx(char **inp, int *idx)
{
*idx = -1;
*inp += strspn(*inp, " ");
if (**inp != '#')
return 0;
*inp += 1;
if (**inp == 'g' || **inp == 'G') {
*inp += 1;
*idx = 0;
} else {
unsigned long num;
char *endptr;
errno = 0;
num = strtoul(*inp, &endptr, 0);
if (errno)
return -errno;
if (endptr == *inp || num > INT_MAX)
return -EINVAL;
*inp = endptr;
*idx = num;
}
return 0;
}
static int parse_addr_size(char **inp, u64 *num, const char **str, int *idx)
{
int err = parse_num_or_str(inp, num, str, " ");
if (!err && *str)
err = parse_sym_idx(inp, idx);
return err;
}
static int parse_one_filter(struct addr_filter *filt, const char **filter_inp)
{
char *fstr;
int err;
filt->str = fstr = strdup(*filter_inp);
if (!fstr)
return -ENOMEM;
err = parse_num_or_str(&fstr, NULL, &filt->action, " ");
if (err)
goto out_err;
err = parse_action(filt);
if (err)
goto out_err;
err = parse_addr_size(&fstr, &filt->addr, &filt->sym_from,
&filt->sym_from_idx);
if (err)
goto out_err;
fstr += strspn(fstr, " ");
if (*fstr == '/') {
fstr += 1;
err = parse_addr_size(&fstr, &filt->size, &filt->sym_to,
&filt->sym_to_idx);
if (err)
goto out_err;
filt->range = true;
}
fstr += strspn(fstr, " ");
if (*fstr == '@') {
fstr += 1;
err = parse_num_or_str(&fstr, NULL, &filt->filename, " ,");
if (err)
goto out_err;
}
fstr += strspn(fstr, " ,");
*filter_inp += fstr - filt->str;
return 0;
out_err:
addr_filter__free_str(filt);
return err;
}
int addr_filters__parse_bare_filter(struct addr_filters *filts,
const char *filter)
{
struct addr_filter *filt;
const char *fstr = filter;
int err;
while (*fstr) {
filt = addr_filter__new();
err = parse_one_filter(filt, &fstr);
if (err) {
addr_filter__free(filt);
addr_filters__exit(filts);
return err;
}
addr_filters__add(filts, filt);
}
return 0;
}
struct sym_args {
const char *name;
u64 start;
u64 size;
int idx;
int cnt;
bool started;
bool global;
bool selected;
bool duplicate;
bool near;
};
static bool kern_sym_match(struct sym_args *args, const char *name, char type)
{
/* A function with the same name, and global or the n'th found or any */
return symbol_type__is_a(type, MAP__FUNCTION) &&
!strcmp(name, args->name) &&
((args->global && isupper(type)) ||
(args->selected && ++(args->cnt) == args->idx) ||
(!args->global && !args->selected));
}
static int find_kern_sym_cb(void *arg, const char *name, char type, u64 start)
{
struct sym_args *args = arg;
if (args->started) {
if (!args->size)
args->size = start - args->start;
if (args->selected) {
if (args->size)
return 1;
} else if (kern_sym_match(args, name, type)) {
args->duplicate = true;
return 1;
}
} else if (kern_sym_match(args, name, type)) {
args->started = true;
args->start = start;
}
return 0;
}
static int print_kern_sym_cb(void *arg, const char *name, char type, u64 start)
{
struct sym_args *args = arg;
if (kern_sym_match(args, name, type)) {
pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
++args->cnt, start, type, name);
args->near = true;
} else if (args->near) {
args->near = false;
pr_err("\t\twhich is near\t\t%s\n", name);
}
return 0;
}
static int sym_not_found_error(const char *sym_name, int idx)
{
if (idx > 0) {
pr_err("N'th occurrence (N=%d) of symbol '%s' not found.\n",
idx, sym_name);
} else if (!idx) {
pr_err("Global symbol '%s' not found.\n", sym_name);
} else {
pr_err("Symbol '%s' not found.\n", sym_name);
}
pr_err("Note that symbols must be functions.\n");
return -EINVAL;
}
static int find_kern_sym(const char *sym_name, u64 *start, u64 *size, int idx)
{
struct sym_args args = {
.name = sym_name,
.idx = idx,
.global = !idx,
.selected = idx > 0,
};
int err;
*start = 0;
*size = 0;
err = kallsyms__parse("/proc/kallsyms", &args, find_kern_sym_cb);
if (err < 0) {
pr_err("Failed to parse /proc/kallsyms\n");
return err;
}
if (args.duplicate) {
pr_err("Multiple kernel symbols with name '%s'\n", sym_name);
args.cnt = 0;
kallsyms__parse("/proc/kallsyms", &args, print_kern_sym_cb);
pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
sym_name);
pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
return -EINVAL;
}
if (!args.started) {
pr_err("Kernel symbol lookup: ");
return sym_not_found_error(sym_name, idx);
}
*start = args.start;
*size = args.size;
return 0;
}
static int find_entire_kern_cb(void *arg, const char *name __maybe_unused,
char type, u64 start)
{
struct sym_args *args = arg;
if (!symbol_type__is_a(type, MAP__FUNCTION))
return 0;
if (!args->started) {
args->started = true;
args->start = start;
}
/* Don't know exactly where the kernel ends, so we add a page */
args->size = round_up(start, page_size) + page_size - args->start;
return 0;
}
static int addr_filter__entire_kernel(struct addr_filter *filt)
{
struct sym_args args = { .started = false };
int err;
err = kallsyms__parse("/proc/kallsyms", &args, find_entire_kern_cb);
if (err < 0 || !args.started) {
pr_err("Failed to parse /proc/kallsyms\n");
return err;
}
filt->addr = args.start;
filt->size = args.size;
return 0;
}
static int check_end_after_start(struct addr_filter *filt, u64 start, u64 size)
{
if (start + size >= filt->addr)
return 0;
if (filt->sym_from) {
pr_err("Symbol '%s' (0x%"PRIx64") comes before '%s' (0x%"PRIx64")\n",
filt->sym_to, start, filt->sym_from, filt->addr);
} else {
pr_err("Symbol '%s' (0x%"PRIx64") comes before address 0x%"PRIx64")\n",
filt->sym_to, start, filt->addr);
}
return -EINVAL;
}
static int addr_filter__resolve_kernel_syms(struct addr_filter *filt)
{
bool no_size = false;
u64 start, size;
int err;
if (symbol_conf.kptr_restrict) {
pr_err("Kernel addresses are restricted. Unable to resolve kernel symbols.\n");
return -EINVAL;
}
if (filt->sym_from && !strcmp(filt->sym_from, "*"))
return addr_filter__entire_kernel(filt);
if (filt->sym_from) {
err = find_kern_sym(filt->sym_from, &start, &size,
filt->sym_from_idx);
if (err)
return err;
filt->addr = start;
if (filt->range && !filt->size && !filt->sym_to) {
filt->size = size;
no_size = !!size;
}
}
if (filt->sym_to) {
err = find_kern_sym(filt->sym_to, &start, &size,
filt->sym_to_idx);
if (err)
return err;
err = check_end_after_start(filt, start, size);
if (err)
return err;
filt->size = start + size - filt->addr;
no_size = !!size;
}
/* The very last symbol in kallsyms does not imply a particular size */
if (no_size) {
pr_err("Cannot determine size of symbol '%s'\n",
filt->sym_to ? filt->sym_to : filt->sym_from);
return -EINVAL;
}
return 0;
}
static struct dso *load_dso(const char *name)
{
struct map *map;
struct dso *dso;
map = dso__new_map(name);
if (!map)
return NULL;
map__load(map);
dso = dso__get(map->dso);
map__put(map);
return dso;
}
static bool dso_sym_match(struct symbol *sym, const char *name, int *cnt,
int idx)
{
/* Same name, and global or the n'th found or any */
return !arch__compare_symbol_names(name, sym->name) &&
((!idx && sym->binding == STB_GLOBAL) ||
(idx > 0 && ++*cnt == idx) ||
idx < 0);
}
static void print_duplicate_syms(struct dso *dso, const char *sym_name)
{
struct symbol *sym;
bool near = false;
int cnt = 0;
pr_err("Multiple symbols with name '%s'\n", sym_name);
sym = dso__first_symbol(dso, MAP__FUNCTION);
while (sym) {
if (dso_sym_match(sym, sym_name, &cnt, -1)) {
pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
++cnt, sym->start,
sym->binding == STB_GLOBAL ? 'g' :
sym->binding == STB_LOCAL ? 'l' : 'w',
sym->name);
near = true;
} else if (near) {
near = false;
pr_err("\t\twhich is near\t\t%s\n", sym->name);
}
sym = dso__next_symbol(sym);
}
pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
sym_name);
pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
}
static int find_dso_sym(struct dso *dso, const char *sym_name, u64 *start,
u64 *size, int idx)
{
struct symbol *sym;
int cnt = 0;
*start = 0;
*size = 0;
sym = dso__first_symbol(dso, MAP__FUNCTION);
while (sym) {
if (*start) {
if (!*size)
*size = sym->start - *start;
if (idx > 0) {
if (*size)
return 1;
} else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
print_duplicate_syms(dso, sym_name);
return -EINVAL;
}
} else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
*start = sym->start;
*size = sym->end - sym->start;
}
sym = dso__next_symbol(sym);
}
if (!*start)
return sym_not_found_error(sym_name, idx);
return 0;
}
static int addr_filter__entire_dso(struct addr_filter *filt, struct dso *dso)
{
struct symbol *first_sym = dso__first_symbol(dso, MAP__FUNCTION);
struct symbol *last_sym = dso__last_symbol(dso, MAP__FUNCTION);
if (!first_sym || !last_sym) {
pr_err("Failed to determine filter for %s\nNo symbols found.\n",
filt->filename);
return -EINVAL;
}
filt->addr = first_sym->start;
filt->size = last_sym->end - first_sym->start;
return 0;
}
static int addr_filter__resolve_syms(struct addr_filter *filt)
{
u64 start, size;
struct dso *dso;
int err = 0;
if (!filt->sym_from && !filt->sym_to)
return 0;
if (!filt->filename)
return addr_filter__resolve_kernel_syms(filt);
dso = load_dso(filt->filename);
if (!dso) {
pr_err("Failed to load symbols from: %s\n", filt->filename);
return -EINVAL;
}
if (filt->sym_from && !strcmp(filt->sym_from, "*")) {
err = addr_filter__entire_dso(filt, dso);
goto put_dso;
}
if (filt->sym_from) {
err = find_dso_sym(dso, filt->sym_from, &start, &size,
filt->sym_from_idx);
if (err)
goto put_dso;
filt->addr = start;
if (filt->range && !filt->size && !filt->sym_to)
filt->size = size;
}
if (filt->sym_to) {
err = find_dso_sym(dso, filt->sym_to, &start, &size,
filt->sym_to_idx);
if (err)
goto put_dso;
err = check_end_after_start(filt, start, size);
if (err)
return err;
filt->size = start + size - filt->addr;
}
put_dso:
dso__put(dso);
return err;
}
static char *addr_filter__to_str(struct addr_filter *filt)
{
char filename_buf[PATH_MAX];
const char *at = "";
const char *fn = "";
char *filter;
int err;
if (filt->filename) {
at = "@";
fn = realpath(filt->filename, filename_buf);
if (!fn)
return NULL;
}
if (filt->range) {
err = asprintf(&filter, "%s 0x%"PRIx64"/0x%"PRIx64"%s%s",
filt->action, filt->addr, filt->size, at, fn);
} else {
err = asprintf(&filter, "%s 0x%"PRIx64"%s%s",
filt->action, filt->addr, at, fn);
}
return err < 0 ? NULL : filter;
}
static int parse_addr_filter(struct perf_evsel *evsel, const char *filter,
int max_nr)
{
struct addr_filters filts;
struct addr_filter *filt;
int err;
addr_filters__init(&filts);
err = addr_filters__parse_bare_filter(&filts, filter);
if (err)
goto out_exit;
if (filts.cnt > max_nr) {
pr_err("Error: number of address filters (%d) exceeds maximum (%d)\n",
filts.cnt, max_nr);
err = -EINVAL;
goto out_exit;
}
list_for_each_entry(filt, &filts.head, list) {
char *new_filter;
err = addr_filter__resolve_syms(filt);
if (err)
goto out_exit;
new_filter = addr_filter__to_str(filt);
if (!new_filter) {
err = -ENOMEM;
goto out_exit;
}
if (perf_evsel__append_addr_filter(evsel, new_filter)) {
err = -ENOMEM;
goto out_exit;
}
}
out_exit:
addr_filters__exit(&filts);
if (err) {
pr_err("Failed to parse address filter: '%s'\n", filter);
pr_err("Filter format is: filter|start|stop|tracestop <start symbol or address> [/ <end symbol or size>] [@<file name>]\n");
pr_err("Where multiple filters are separated by space or comma.\n");
}
return err;
}
static struct perf_pmu *perf_evsel__find_pmu(struct perf_evsel *evsel)
{
struct perf_pmu *pmu = NULL;
while ((pmu = perf_pmu__scan(pmu)) != NULL) {
if (pmu->type == evsel->attr.type)
break;
}
return pmu;
}
static int perf_evsel__nr_addr_filter(struct perf_evsel *evsel)
{
struct perf_pmu *pmu = perf_evsel__find_pmu(evsel);
int nr_addr_filters = 0;
if (!pmu)
return 0;
perf_pmu__scan_file(pmu, "nr_addr_filters", "%d", &nr_addr_filters);
return nr_addr_filters;
}
int auxtrace_parse_filters(struct perf_evlist *evlist)
{
struct perf_evsel *evsel;
char *filter;
int err, max_nr;
evlist__for_each_entry(evlist, evsel) {
filter = evsel->filter;
max_nr = perf_evsel__nr_addr_filter(evsel);
if (!filter || !max_nr)
continue;
evsel->filter = NULL;
err = parse_addr_filter(evsel, filter, max_nr);
free(filter);
if (err)
return err;
pr_debug("Address filter: %s\n", evsel->filter);
}
return 0;
}
......@@ -318,6 +318,48 @@ struct auxtrace_record {
unsigned int alignment;
};
/**
* struct addr_filter - address filter.
* @list: list node
* @range: true if it is a range filter
* @start: true if action is 'filter' or 'start'
* @action: 'filter', 'start' or 'stop' ('tracestop' is accepted but converted
* to 'stop')
* @sym_from: symbol name for the filter address
* @sym_to: symbol name that determines the filter size
* @sym_from_idx: selects n'th from symbols with the same name (0 means global
* and less than 0 means symbol must be unique)
* @sym_to_idx: same as @sym_from_idx but for @sym_to
* @addr: filter address
* @size: filter region size (for range filters)
* @filename: DSO file name or NULL for the kernel
* @str: allocated string that contains the other string members
*/
struct addr_filter {
struct list_head list;
bool range;
bool start;
const char *action;
const char *sym_from;
const char *sym_to;
int sym_from_idx;
int sym_to_idx;
u64 addr;
u64 size;
const char *filename;
char *str;
};
/**
* struct addr_filters - list of address filters.
* @head: list of address filters
* @cnt: number of address filters
*/
struct addr_filters {
struct list_head head;
int cnt;
};
#ifdef HAVE_AUXTRACE_SUPPORT
/*
......@@ -482,6 +524,12 @@ void perf_session__auxtrace_error_inc(struct perf_session *session,
union perf_event *event);
void events_stats__auxtrace_error_warn(const struct events_stats *stats);
void addr_filters__init(struct addr_filters *filts);
void addr_filters__exit(struct addr_filters *filts);
int addr_filters__parse_bare_filter(struct addr_filters *filts,
const char *filter);
int auxtrace_parse_filters(struct perf_evlist *evlist);
static inline int auxtrace__process_event(struct perf_session *session,
union perf_event *event,
struct perf_sample *sample,
......@@ -640,6 +688,12 @@ void auxtrace_index__free(struct list_head *head __maybe_unused)
{
}
static inline
int auxtrace_parse_filters(struct perf_evlist *evlist __maybe_unused)
{
return 0;
}
int auxtrace_mmap__mmap(struct auxtrace_mmap *mm,
struct auxtrace_mmap_params *mp,
void *userpg, int fd);
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册