mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

perf/core improvements and fixes: 

User visible:
 
 - Force period term to overload global settings, i.e. previously this
   command line:
 
  $ perf record -e 'cpu/instructions,period=20000/',cycles -c 1000 sleep 1
 
   would result in both events having a period equal to 1000, with the fix we
   get something saner:
 
  $ perf evlist -v | grep period
  cpu/instructions,period=20000/: ... { sample_period, sample_freq }: 20000, ...
  cycles: ... { sample_period, sample_freq }: 1000 ...
  $
 
  (Jiri Olsa)
 
 Infrastructure:
 
 - Use the dummy software event with freq=0 in the twatch.py python
   binding example, to avoid disabling nohz (Arnaldo Carvalho de Melo)
 
 - Add some missing constants to the python binding (Arnaldo Carvalho de Melo)
 
 - Fix mismatched declarations for elf_getphdrnum, that happens
   only in the corner case where this function is not found on
   the system  (Arnaldo Carvalho de Melo).
 
 - Adding build test for having ending double slash (Jiri Olsa)
 
 - Introduce callgraph_set for callgraph option (Kan Liang)
 
 Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJVuk2cAAoJENZQFvNTUqpA15IQAIwfXkfs6we+5+VOXp35bKrl
 EiXVTBZPo1IW+duas0exur8nEmdYV9VMuZE8t5WpldOsARxJKjnKyB+muFCDMKqA
 3yeBXPATawxRKjqIsPVucksFXGHf19v6Nsh2plqY+qqFynKxm7DibcMxIIFMeqY0
 VwdUzHEojIMQ2pzHA7Ef2eSdzSgAUqO06+O9BBB+udizcCAonF5KZh4tw5n2795E
 gz0rvnYVC8q7EU2oSKEWwWyj2Ti07iaC0b/adg6jY9OU0Mnlx0K3MkREmq6KQjoz
 GrayIknp0CoatLPbpuPf9jz3si7lL/WErl3F3Qeg1lfzAPdGDakmfufQmgyHhEfF
 in0qAYxYKMnsgRblTWynOMUWISfdKlhjsofXFv3hXOB2iWbulHLU7WdS8ieyuiGq
 N0jcYEII4+/qk+Wi/XbiCujOmaZdvG+slSmx9JgZwXhj4kRiBkUYeNk/JCdNhzgX
 u6fse5lBQRI+YDmNXe+QQxUTpL+jpx2OnmpD8v2Yx4YvvLN/SU47Y9VYw9YWmkDq
 NySRFn/bBc/zlrT6EnYI7ENpydLIovS+Wa8WSmzQFCDGcbWl2TSKjcVAB1aqhhsk
 IAMnzv5/0ybcx8WiYcGqd6Z4gh+WuUenzHGKE3sSmSqbbRRS1WvBYeyeZaU1IGkW
 8lrAASPd8X3YP76aP8ww
 =XBSW
 -----END PGP SIGNATURE-----

Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

User visible changes:

  - Force period term to overload global settings, i.e. previously this
    command line:

     $ perf record -e 'cpu/instructions,period=20000/',cycles -c 1000 sleep 1

    would result in both events having a period equal to 1000, with the fix we
    get something saner:

     $ perf evlist -v | grep period
     cpu/instructions,period=20000/: ... { sample_period, sample_freq }: 20000, ...
     cycles: ... { sample_period, sample_freq }: 1000 ...
     $

   (Jiri Olsa)

Infrastructure changes:

  - Use the dummy software event with freq=0 in the twatch.py python
    binding example, to avoid disabling nohz. (Arnaldo Carvalho de Melo)

  - Add some missing constants to the python binding. (Arnaldo Carvalho de Melo)

  - Fix mismatched declarations for elf_getphdrnum, that happens
    only in the corner case where this function is not found on
    the system.  (Arnaldo Carvalho de Melo)

  - Add build test for having ending double slash. (Jiri Olsa)

  - Introduce callgraph_set for callgraph option. (Kan Liang)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Ingo Molnar 2015-07-31 09:59:50 +02:00
parent acd632eb64 aa53c09e90
commit 41d279aaf5
15 changed files with 227 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tools/perf/Documentation/perf-record.txt
View File

@ -46,7 +46,7 @@ OPTIONS
/sys/bus/event_sources/devices/<pmu>/format/*
There are also some params which are not defined in .../<pmu>/format/*.
These params can be used to set event defaults.
These params can be used to overload default config values per event.
Here is a list of the params.
- 'period': Set event sampling period

9
tools/perf/builtin-record.c
View File

@ -762,12 +762,14 @@ static void callchain_debug(void)
callchain_param.dump_size);
}
int record_parse_callchain_opt(const struct option *opt __maybe_unused,
int record_parse_callchain_opt(const struct option *opt,
const char *arg,
int unset)
{
int ret;
struct record_opts *record = (struct record_opts *)opt->value;
record->callgraph_set = true;
callchain_param.enabled = !unset;
/* --no-call-graph */
@ -784,10 +786,13 @@ int record_parse_callchain_opt(const struct option *opt __maybe_unused,
return ret;
}
int record_callchain_opt(const struct option *opt __maybe_unused,
int record_callchain_opt(const struct option *opt,
const char *arg __maybe_unused,
int unset __maybe_unused)
{
struct record_opts *record = (struct record_opts *)opt->value;
record->callgraph_set = true;
callchain_param.enabled = true;
if (callchain_param.record_mode == CALLCHAIN_NONE)

2
tools/perf/builtin-trace.c
View File

@ -1489,7 +1489,7 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
if (trace->host == NULL)
return -ENOMEM;
if (trace_event__register_resolver(trace->host) < 0)
if (trace_event__register_resolver(trace->host, machine__resolve_kernel_addr) < 0)
return -errno;
err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,

1
tools/perf/perf.h
View File

@ -52,6 +52,7 @@ struct record_opts {
bool sample_weight;
bool sample_time;
bool sample_time_set;
bool callgraph_set;
bool period;
bool sample_intr_regs;
bool running_time;

12
tools/perf/python/twatch.py
View File

@ -18,10 +18,20 @@ import perf
def main():
cpus = perf.cpu_map()
threads = perf.thread_map()
evsel = perf.evsel(task = 1, comm = 1, mmap = 0,
evsel = perf.evsel(type = perf.TYPE_SOFTWARE,
config = perf.COUNT_SW_DUMMY,
task = 1, comm = 1, mmap = 0, freq = 0,
wakeup_events = 1, watermark = 1,
sample_id_all = 1,
sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU)
"""What we want are just the PERF_RECORD_ lifetime events for threads,
using the default, PERF_TYPE_HARDWARE + PERF_COUNT_HW_CYCLES & freq=1
(the default), makes perf reenable irq_vectors:local_timer_entry, when
disabling nohz, not good for some use cases where all we want is to get
threads comes and goes... So use (perf.TYPE_SOFTWARE, perf_COUNT_SW_DUMMY,
freq=0) instead."""
evsel.open(cpus = cpus, threads = threads);
evlist = perf.evlist(cpus, threads)
evlist.add(evsel)

13
tools/perf/tests/make
View File

@ -58,7 +58,8 @@ make_install_man := install-man
make_install_html := install-html
make_install_info := install-info
make_install_pdf := install-pdf
make_install_prefix := install prefix=/tmp/krava
make_install_prefix := install prefix=/tmp/krava
make_install_prefix_slash := install prefix=/tmp/krava/
make_static := LDFLAGS=-static
# all the NO_* variable combined
@ -101,6 +102,7 @@ run += make_util_pmu_bison_o
run += make_install
run += make_install_bin
run += make_install_prefix
run += make_install_prefix_slash
# FIXME 'install-*' commented out till they're fixed
# run += make_install_doc
# run += make_install_man
@ -175,11 +177,14 @@ test_make_install_O := $(call test_dest_files,$(installed_files_all))
test_make_install_bin := $(call test_dest_files,$(installed_files_bin))
test_make_install_bin_O := $(call test_dest_files,$(installed_files_bin))
# We prefix all installed files for make_install_prefix
# We prefix all installed files for make_install_prefix(_slash)
# with '/tmp/krava' to match installed/prefix-ed files.
installed_files_all_prefix := $(addprefix /tmp/krava/,$(installed_files_all))
test_make_install_prefix := $(call test_dest_files,$(installed_files_all_prefix))
test_make_install_prefix_O := $(call test_dest_files,$(installed_files_all_prefix))
test_make_install_prefix := $(call test_dest_files,$(installed_files_all_prefix))
test_make_install_prefix_O := $(call test_dest_files,$(installed_files_all_prefix))
test_make_install_prefix_slash := $(test_make_install_prefix)
test_make_install_prefix_slash_O := $(test_make_install_prefix_O)
# FIXME nothing gets installed
test_make_install_man := test -f $$TMP_DEST/share/man/man1/perf.1

12
tools/perf/tests/parse-events.c
View File

@ -82,8 +82,12 @@ static int test__checkevent_symbolic_name_config(struct perf_evlist *evlist)
TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
TEST_ASSERT_VAL("wrong config",
PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
/*
* The period value gets configured within perf_evlist__config,
* while this test executes only parse events method.
*/
TEST_ASSERT_VAL("wrong period",
100000 == evsel->attr.sample_period);
0 == evsel->attr.sample_period);
TEST_ASSERT_VAL("wrong config1",
0 == evsel->attr.config1);
TEST_ASSERT_VAL("wrong config2",
@ -406,7 +410,11 @@ static int test__checkevent_pmu(struct perf_evlist *evlist)
TEST_ASSERT_VAL("wrong config", 10 == evsel->attr.config);
TEST_ASSERT_VAL("wrong config1", 1 == evsel->attr.config1);
TEST_ASSERT_VAL("wrong config2", 3 == evsel->attr.config2);
TEST_ASSERT_VAL("wrong period", 1000 == evsel->attr.sample_period);
/*
* The period value gets configured within perf_evlist__config,
* while this test executes only parse events method.
*/
TEST_ASSERT_VAL("wrong period", 0 == evsel->attr.sample_period);
return 0;
}

33
tools/perf/util/evsel.c
View File

@ -207,6 +207,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
evsel->unit = "";
evsel->scale = 1.0;
INIT_LIST_HEAD(&evsel->node);
INIT_LIST_HEAD(&evsel->config_terms);
perf_evsel__object.init(evsel);
evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
perf_evsel__calc_id_pos(evsel);
@ -586,6 +587,21 @@ perf_evsel__config_callgraph(struct perf_evsel *evsel,
}
}
static void apply_config_terms(struct perf_event_attr *attr __maybe_unused,
struct list_head *config_terms)
{
struct perf_evsel_config_term *term;
list_for_each_entry(term, config_terms, list) {
switch (term->type) {
case PERF_EVSEL__CONFIG_TERM_PERIOD:
attr->sample_period = term->val.period;
default:
break;
}
}
}
/*
* The enable_on_exec/disabled value strategy:
*
@ -777,6 +793,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
attr->use_clockid = 1;
attr->clockid = opts->clockid;
}
/*
* Apply event specific term settings,
* it overloads any global configuration.
*/
apply_config_terms(attr, &evsel->config_terms);
}
static int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
@ -900,6 +922,16 @@ static void perf_evsel__free_id(struct perf_evsel *evsel)
zfree(&evsel->id);
}
static void perf_evsel__free_config_terms(struct perf_evsel *evsel)
{
struct perf_evsel_config_term *term, *h;
list_for_each_entry_safe(term, h, &evsel->config_terms, list) {
list_del(&term->list);
free(term);
}
}
void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
{
int cpu, thread;
@ -919,6 +951,7 @@ void perf_evsel__exit(struct perf_evsel *evsel)
assert(list_empty(&evsel->node));
perf_evsel__free_fd(evsel);
perf_evsel__free_id(evsel);
perf_evsel__free_config_terms(evsel);
close_cgroup(evsel->cgrp);
cpu_map__put(evsel->cpus);
thread_map__put(evsel->threads);

20
tools/perf/util/evsel.h
View File

@ -31,6 +31,25 @@ struct perf_sample_id {
struct cgroup_sel;
/*
* The 'struct perf_evsel_config_term' is used to pass event
* specific configuration data to perf_evsel__config routine.
* It is allocated within event parsing and attached to
* perf_evsel::config_terms list head.
*/
enum {
PERF_EVSEL__CONFIG_TERM_PERIOD,
PERF_EVSEL__CONFIG_TERM_MAX,
};
struct perf_evsel_config_term {
struct list_head list;
int type;
union {
u64 period;
} val;
};
/** struct perf_evsel - event selector
*
* @name - Can be set to retain the original event name passed by the user,
@ -87,6 +106,7 @@ struct perf_evsel {
struct perf_evsel *leader;
char *group_name;
bool cmdline_group_boundary;
struct list_head config_terms;
};
union u64_swap {

70
tools/perf/util/parse-events.c
View File

@ -276,7 +276,8 @@ const char *event_type(int type)
static struct perf_evsel *
__add_event(struct list_head *list, int *idx,
struct perf_event_attr *attr,
char *name, struct cpu_map *cpus)
char *name, struct cpu_map *cpus,
struct list_head *config_terms)
{
struct perf_evsel *evsel;
@ -291,14 +292,19 @@ __add_event(struct list_head *list, int *idx,
if (name)
evsel->name = strdup(name);
if (config_terms)
list_splice(config_terms, &evsel->config_terms);
list_add_tail(&evsel->node, list);
return evsel;
}
static int add_event(struct list_head *list, int *idx,
struct perf_event_attr *attr, char *name)
struct perf_event_attr *attr, char *name,
struct list_head *config_terms)
{
return __add_event(list, idx, attr, name, NULL) ? 0 : -ENOMEM;
return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM;
}
static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
@ -377,7 +383,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
memset(&attr, 0, sizeof(attr));
attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
attr.type = PERF_TYPE_HW_CACHE;
return add_event(list, idx, &attr, name);
return add_event(list, idx, &attr, name, NULL);
}
static int add_tracepoint(struct list_head *list, int *idx,
@ -539,7 +545,7 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
attr.type = PERF_TYPE_BREAKPOINT;
attr.sample_period = 1;
return add_event(list, idx, &attr, NULL);
return add_event(list, idx, &attr, NULL, NULL);
}
static int check_type_val(struct parse_events_term *term,
@ -590,7 +596,6 @@ do { \
break;
case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
CHECK_TYPE_VAL(NUM);
attr->sample_period = term->val.num;
break;
case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
/*
@ -622,22 +627,58 @@ static int config_attr(struct perf_event_attr *attr,
return 0;
}
static int get_config_terms(struct list_head *head_config,
struct list_head *head_terms __maybe_unused)
{
#define ADD_CONFIG_TERM(__type, __name, __val) \
do { \
struct perf_evsel_config_term *__t; \
\
__t = zalloc(sizeof(*__t)); \
if (!__t) \
return -ENOMEM; \
\
INIT_LIST_HEAD(&__t->list); \
__t->type = PERF_EVSEL__CONFIG_TERM_ ## __type; \
__t->val.__name = __val; \
list_add_tail(&__t->list, head_terms); \
} while (0)
struct parse_events_term *term;
list_for_each_entry(term, head_config, list) {
switch (term->type_term) {
case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
ADD_CONFIG_TERM(PERIOD, period, term->val.num);
default:
break;
}
}
#undef ADD_EVSEL_CONFIG
return 0;
}
int parse_events_add_numeric(struct parse_events_evlist *data,
struct list_head *list,
u32 type, u64 config,
struct list_head *head_config)
{
struct perf_event_attr attr;
LIST_HEAD(config_terms);
memset(&attr, 0, sizeof(attr));
attr.type = type;
attr.config = config;
if (head_config &&
config_attr(&attr, head_config, data->error))
return -EINVAL;
if (head_config) {
if (config_attr(&attr, head_config, data->error))
return -EINVAL;
return add_event(list, &data->idx, &attr, NULL);
if (get_config_terms(head_config, &config_terms))
return -ENOMEM;
}
return add_event(list, &data->idx, &attr, NULL, &config_terms);
}
static int parse_events__is_name_term(struct parse_events_term *term)
@ -664,6 +705,7 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
struct perf_pmu_info info;
struct perf_pmu *pmu;
struct perf_evsel *evsel;
LIST_HEAD(config_terms);
pmu = perf_pmu__find(name);
if (!pmu)
@ -678,7 +720,7 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
if (!head_config) {
attr.type = pmu->type;
evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus);
evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);
return evsel ? 0 : -ENOMEM;
}
@ -692,11 +734,15 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
if (config_attr(&attr, head_config, data->error))
return -EINVAL;
if (get_config_terms(head_config, &config_terms))
return -ENOMEM;
if (perf_pmu__config(pmu, &attr, head_config, data->error))
return -EINVAL;
evsel = __add_event(list, &data->idx, &attr,
pmu_event_name(head_config), pmu->cpus);
pmu_event_name(head_config), pmu->cpus,
&config_terms);
if (evsel) {
evsel->unit = info.unit;
evsel->scale = info.scale;

128
tools/perf/util/python.c
View File

@ -941,76 +941,84 @@ static int pyrf_evlist__setup_types(void)
return PyType_Ready(&pyrf_evlist__type);
}
#define PERF_CONST(name) { #name, PERF_##name }
static struct {
const char *name;
int value;
} perf__constants[] = {
{ "TYPE_HARDWARE", PERF_TYPE_HARDWARE },
{ "TYPE_SOFTWARE", PERF_TYPE_SOFTWARE },
{ "TYPE_TRACEPOINT", PERF_TYPE_TRACEPOINT },
{ "TYPE_HW_CACHE", PERF_TYPE_HW_CACHE },
{ "TYPE_RAW", PERF_TYPE_RAW },
{ "TYPE_BREAKPOINT", PERF_TYPE_BREAKPOINT },
PERF_CONST(TYPE_HARDWARE),
PERF_CONST(TYPE_SOFTWARE),
PERF_CONST(TYPE_TRACEPOINT),
PERF_CONST(TYPE_HW_CACHE),
PERF_CONST(TYPE_RAW),
PERF_CONST(TYPE_BREAKPOINT),
{ "COUNT_HW_CPU_CYCLES", PERF_COUNT_HW_CPU_CYCLES },
{ "COUNT_HW_INSTRUCTIONS", PERF_COUNT_HW_INSTRUCTIONS },
{ "COUNT_HW_CACHE_REFERENCES", PERF_COUNT_HW_CACHE_REFERENCES },
{ "COUNT_HW_CACHE_MISSES", PERF_COUNT_HW_CACHE_MISSES },
{ "COUNT_HW_BRANCH_INSTRUCTIONS", PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
{ "COUNT_HW_BRANCH_MISSES", PERF_COUNT_HW_BRANCH_MISSES },
{ "COUNT_HW_BUS_CYCLES", PERF_COUNT_HW_BUS_CYCLES },
{ "COUNT_HW_CACHE_L1D", PERF_COUNT_HW_CACHE_L1D },
{ "COUNT_HW_CACHE_L1I", PERF_COUNT_HW_CACHE_L1I },
{ "COUNT_HW_CACHE_LL", PERF_COUNT_HW_CACHE_LL },
{ "COUNT_HW_CACHE_DTLB", PERF_COUNT_HW_CACHE_DTLB },
{ "COUNT_HW_CACHE_ITLB", PERF_COUNT_HW_CACHE_ITLB },
{ "COUNT_HW_CACHE_BPU", PERF_COUNT_HW_CACHE_BPU },
{ "COUNT_HW_CACHE_OP_READ", PERF_COUNT_HW_CACHE_OP_READ },
{ "COUNT_HW_CACHE_OP_WRITE", PERF_COUNT_HW_CACHE_OP_WRITE },
{ "COUNT_HW_CACHE_OP_PREFETCH", PERF_COUNT_HW_CACHE_OP_PREFETCH },
{ "COUNT_HW_CACHE_RESULT_ACCESS", PERF_COUNT_HW_CACHE_RESULT_ACCESS },
{ "COUNT_HW_CACHE_RESULT_MISS", PERF_COUNT_HW_CACHE_RESULT_MISS },
PERF_CONST(COUNT_HW_CPU_CYCLES),
PERF_CONST(COUNT_HW_INSTRUCTIONS),
PERF_CONST(COUNT_HW_CACHE_REFERENCES),
PERF_CONST(COUNT_HW_CACHE_MISSES),
PERF_CONST(COUNT_HW_BRANCH_INSTRUCTIONS),
PERF_CONST(COUNT_HW_BRANCH_MISSES),
PERF_CONST(COUNT_HW_BUS_CYCLES),
PERF_CONST(COUNT_HW_CACHE_L1D),
PERF_CONST(COUNT_HW_CACHE_L1I),
PERF_CONST(COUNT_HW_CACHE_LL),
PERF_CONST(COUNT_HW_CACHE_DTLB),
PERF_CONST(COUNT_HW_CACHE_ITLB),
PERF_CONST(COUNT_HW_CACHE_BPU),
PERF_CONST(COUNT_HW_CACHE_OP_READ),
PERF_CONST(COUNT_HW_CACHE_OP_WRITE),
PERF_CONST(COUNT_HW_CACHE_OP_PREFETCH),
PERF_CONST(COUNT_HW_CACHE_RESULT_ACCESS),
PERF_CONST(COUNT_HW_CACHE_RESULT_MISS),
{ "COUNT_HW_STALLED_CYCLES_FRONTEND", PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
{ "COUNT_HW_STALLED_CYCLES_BACKEND", PERF_COUNT_HW_STALLED_CYCLES_BACKEND },
PERF_CONST(COUNT_HW_STALLED_CYCLES_FRONTEND),
PERF_CONST(COUNT_HW_STALLED_CYCLES_BACKEND),
{ "COUNT_SW_CPU_CLOCK", PERF_COUNT_SW_CPU_CLOCK },
{ "COUNT_SW_TASK_CLOCK", PERF_COUNT_SW_TASK_CLOCK },
{ "COUNT_SW_PAGE_FAULTS", PERF_COUNT_SW_PAGE_FAULTS },
{ "COUNT_SW_CONTEXT_SWITCHES", PERF_COUNT_SW_CONTEXT_SWITCHES },
{ "COUNT_SW_CPU_MIGRATIONS", PERF_COUNT_SW_CPU_MIGRATIONS },
{ "COUNT_SW_PAGE_FAULTS_MIN", PERF_COUNT_SW_PAGE_FAULTS_MIN },
{ "COUNT_SW_PAGE_FAULTS_MAJ", PERF_COUNT_SW_PAGE_FAULTS_MAJ },
{ "COUNT_SW_ALIGNMENT_FAULTS", PERF_COUNT_SW_ALIGNMENT_FAULTS },
{ "COUNT_SW_EMULATION_FAULTS", PERF_COUNT_SW_EMULATION_FAULTS },
{ "COUNT_SW_DUMMY", PERF_COUNT_SW_DUMMY },
PERF_CONST(COUNT_SW_CPU_CLOCK),
PERF_CONST(COUNT_SW_TASK_CLOCK),
PERF_CONST(COUNT_SW_PAGE_FAULTS),
PERF_CONST(COUNT_SW_CONTEXT_SWITCHES),
PERF_CONST(COUNT_SW_CPU_MIGRATIONS),
PERF_CONST(COUNT_SW_PAGE_FAULTS_MIN),
PERF_CONST(COUNT_SW_PAGE_FAULTS_MAJ),
PERF_CONST(COUNT_SW_ALIGNMENT_FAULTS),
PERF_CONST(COUNT_SW_EMULATION_FAULTS),
PERF_CONST(COUNT_SW_DUMMY),
{ "SAMPLE_IP", PERF_SAMPLE_IP },
{ "SAMPLE_TID", PERF_SAMPLE_TID },
{ "SAMPLE_TIME", PERF_SAMPLE_TIME },
{ "SAMPLE_ADDR", PERF_SAMPLE_ADDR },
{ "SAMPLE_READ", PERF_SAMPLE_READ },
{ "SAMPLE_CALLCHAIN", PERF_SAMPLE_CALLCHAIN },
{ "SAMPLE_ID", PERF_SAMPLE_ID },
{ "SAMPLE_CPU", PERF_SAMPLE_CPU },
{ "SAMPLE_PERIOD", PERF_SAMPLE_PERIOD },
{ "SAMPLE_STREAM_ID", PERF_SAMPLE_STREAM_ID },
{ "SAMPLE_RAW", PERF_SAMPLE_RAW },
PERF_CONST(SAMPLE_IP),
PERF_CONST(SAMPLE_TID),
PERF_CONST(SAMPLE_TIME),
PERF_CONST(SAMPLE_ADDR),
PERF_CONST(SAMPLE_READ),
PERF_CONST(SAMPLE_CALLCHAIN),
PERF_CONST(SAMPLE_ID),
PERF_CONST(SAMPLE_CPU),
PERF_CONST(SAMPLE_PERIOD),
PERF_CONST(SAMPLE_STREAM_ID),
PERF_CONST(SAMPLE_RAW),
{ "FORMAT_TOTAL_TIME_ENABLED", PERF_FORMAT_TOTAL_TIME_ENABLED },
{ "FORMAT_TOTAL_TIME_RUNNING", PERF_FORMAT_TOTAL_TIME_RUNNING },
{ "FORMAT_ID", PERF_FORMAT_ID },
{ "FORMAT_GROUP", PERF_FORMAT_GROUP },
PERF_CONST(FORMAT_TOTAL_TIME_ENABLED),
PERF_CONST(FORMAT_TOTAL_TIME_RUNNING),
PERF_CONST(FORMAT_ID),
PERF_CONST(FORMAT_GROUP),
{ "RECORD_MMAP", PERF_RECORD_MMAP },
{ "RECORD_LOST", PERF_RECORD_LOST },
{ "RECORD_COMM", PERF_RECORD_COMM },
{ "RECORD_EXIT", PERF_RECORD_EXIT },
{ "RECORD_THROTTLE", PERF_RECORD_THROTTLE },
{ "RECORD_UNTHROTTLE", PERF_RECORD_UNTHROTTLE },
{ "RECORD_FORK", PERF_RECORD_FORK },
{ "RECORD_READ", PERF_RECORD_READ },
{ "RECORD_SAMPLE", PERF_RECORD_SAMPLE },
PERF_CONST(RECORD_MMAP),
PERF_CONST(RECORD_LOST),
PERF_CONST(RECORD_COMM),
PERF_CONST(RECORD_EXIT),
PERF_CONST(RECORD_THROTTLE),
PERF_CONST(RECORD_UNTHROTTLE),
PERF_CONST(RECORD_FORK),
PERF_CONST(RECORD_READ),
PERF_CONST(RECORD_SAMPLE),
PERF_CONST(RECORD_MMAP2),
PERF_CONST(RECORD_AUX),
PERF_CONST(RECORD_ITRACE_START),
PERF_CONST(RECORD_LOST_SAMPLES),
PERF_CONST(RECORD_SWITCH),
PERF_CONST(RECORD_SWITCH_CPU_WIDE),
{ .name = NULL, },
};

4
tools/perf/util/session.c
View File

@ -170,7 +170,7 @@ static void perf_session__delete_threads(struct perf_session *session)
machine__delete_threads(&session->machines.host);
}
static void perf_session_env__delete(struct perf_session_env *env)
static void perf_session_env__exit(struct perf_session_env *env)
{
zfree(&env->hostname);
zfree(&env->os_release);
@ -193,7 +193,7 @@ void perf_session__delete(struct perf_session *session)
auxtrace_index__free(&session->auxtrace_index);
perf_session__destroy_kernel_maps(session);
perf_session__delete_threads(session);
perf_session_env__delete(&session->header.env);
perf_session_env__exit(&session->header.env);
machines__exit(&session->machines);
if (session->file)
perf_data_file__close(session->file);

2
tools/perf/util/symbol-elf.c
View File

@ -38,7 +38,7 @@ static inline char *bfd_demangle(void __maybe_unused *v,
#endif
#ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
static int elf_getphdrnum(Elf *elf, size_t *dst)
int elf_getphdrnum(Elf *elf, size_t *dst)
{
GElf_Ehdr gehdr;
GElf_Ehdr *ehdr;

7
tools/perf/util/trace-event.c
View File

@ -50,14 +50,13 @@ static int trace_event__init2(void)
return 0;
}
int trace_event__register_resolver(struct machine *machine)
int trace_event__register_resolver(struct machine *machine,
pevent_func_resolver_t *func)
{
if (!tevent_initialized && trace_event__init2())
return -1;
return pevent_set_function_resolver(tevent.pevent,
machine__resolve_kernel_addr,
machine);
return pevent_set_function_resolver(tevent.pevent, func, machine);
}
void trace_event__cleanup(struct trace_event *t)

3
tools/perf/util/trace-event.h
View File

@ -18,7 +18,8 @@ struct trace_event {
int trace_event__init(struct trace_event *t);
void trace_event__cleanup(struct trace_event *t);
int trace_event__register_resolver(struct machine *machine);
int trace_event__register_resolver(struct machine *machine,
pevent_func_resolver_t *func);
struct event_format*
trace_event__tp_format(const char *sys, const char *name);