2012-10-27 23:18:32 +02:00
|
|
|
#ifndef __PERF_DSO
|
|
|
|
#define __PERF_DSO
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/rbtree.h>
|
2013-08-07 13:38:47 +02:00
|
|
|
#include <stdbool.h>
|
2014-04-25 21:31:02 +02:00
|
|
|
#include <linux/types.h>
|
2014-07-22 15:17:59 +02:00
|
|
|
#include <linux/bitops.h>
|
2012-10-27 23:18:32 +02:00
|
|
|
#include "map.h"
|
2013-09-11 07:09:30 +02:00
|
|
|
#include "build-id.h"
|
2012-10-27 23:18:32 +02:00
|
|
|
|
|
|
|
enum dso_binary_type {
|
|
|
|
DSO_BINARY_TYPE__KALLSYMS = 0,
|
|
|
|
DSO_BINARY_TYPE__GUEST_KALLSYMS,
|
|
|
|
DSO_BINARY_TYPE__VMLINUX,
|
|
|
|
DSO_BINARY_TYPE__GUEST_VMLINUX,
|
|
|
|
DSO_BINARY_TYPE__JAVA_JIT,
|
|
|
|
DSO_BINARY_TYPE__DEBUGLINK,
|
|
|
|
DSO_BINARY_TYPE__BUILD_ID_CACHE,
|
|
|
|
DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
|
|
|
|
DSO_BINARY_TYPE__GUEST_KMODULE,
|
|
|
|
DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
|
2013-08-07 13:38:51 +02:00
|
|
|
DSO_BINARY_TYPE__KCORE,
|
|
|
|
DSO_BINARY_TYPE__GUEST_KCORE,
|
2013-09-18 15:56:14 +02:00
|
|
|
DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
|
2012-10-27 23:18:32 +02:00
|
|
|
DSO_BINARY_TYPE__NOT_FOUND,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum dso_kernel_type {
|
|
|
|
DSO_TYPE_USER = 0,
|
|
|
|
DSO_TYPE_KERNEL,
|
|
|
|
DSO_TYPE_GUEST_KERNEL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum dso_swap_type {
|
|
|
|
DSO_SWAP__UNSET,
|
|
|
|
DSO_SWAP__NO,
|
|
|
|
DSO_SWAP__YES,
|
|
|
|
};
|
|
|
|
|
2014-07-22 15:17:18 +02:00
|
|
|
enum dso_data_status {
|
|
|
|
DSO_DATA_STATUS_ERROR = -1,
|
|
|
|
DSO_DATA_STATUS_UNKNOWN = 0,
|
|
|
|
DSO_DATA_STATUS_OK = 1,
|
|
|
|
};
|
|
|
|
|
2014-07-22 15:17:19 +02:00
|
|
|
enum dso_data_status_seen {
|
|
|
|
DSO_DATA_STATUS_SEEN_ITRACE,
|
|
|
|
};
|
|
|
|
|
2014-07-22 15:17:59 +02:00
|
|
|
enum dso_type {
|
|
|
|
DSO__TYPE_UNKNOWN,
|
|
|
|
DSO__TYPE_64BIT,
|
|
|
|
DSO__TYPE_32BIT,
|
|
|
|
DSO__TYPE_X32BIT,
|
|
|
|
};
|
|
|
|
|
2012-10-27 23:18:32 +02:00
|
|
|
#define DSO__SWAP(dso, type, val) \
|
|
|
|
({ \
|
|
|
|
type ____r = val; \
|
|
|
|
BUG_ON(dso->needs_swap == DSO_SWAP__UNSET); \
|
|
|
|
if (dso->needs_swap == DSO_SWAP__YES) { \
|
|
|
|
switch (sizeof(____r)) { \
|
|
|
|
case 2: \
|
|
|
|
____r = bswap_16(val); \
|
|
|
|
break; \
|
|
|
|
case 4: \
|
|
|
|
____r = bswap_32(val); \
|
|
|
|
break; \
|
|
|
|
case 8: \
|
|
|
|
____r = bswap_64(val); \
|
|
|
|
break; \
|
|
|
|
default: \
|
|
|
|
BUG_ON(1); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
____r; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define DSO__DATA_CACHE_SIZE 4096
|
|
|
|
#define DSO__DATA_CACHE_MASK ~(DSO__DATA_CACHE_SIZE - 1)
|
|
|
|
|
|
|
|
struct dso_cache {
|
|
|
|
struct rb_node rb_node;
|
|
|
|
u64 offset;
|
|
|
|
u64 size;
|
|
|
|
char data[0];
|
|
|
|
};
|
|
|
|
|
2014-09-29 22:07:28 +02:00
|
|
|
/*
|
2014-09-30 19:36:15 +02:00
|
|
|
* DSOs are put into both a list for fast iteration and rbtree for fast
|
|
|
|
* long name lookup.
|
2014-09-29 22:07:28 +02:00
|
|
|
*/
|
|
|
|
struct dsos {
|
|
|
|
struct list_head head;
|
2014-09-30 19:36:15 +02:00
|
|
|
struct rb_root root; /* rbtree root sorted by long name */
|
2014-09-29 22:07:28 +02:00
|
|
|
};
|
|
|
|
|
2012-10-27 23:18:32 +02:00
|
|
|
struct dso {
|
|
|
|
struct list_head node;
|
2014-09-30 19:36:15 +02:00
|
|
|
struct rb_node rb_node; /* rbtree node sorted by long name */
|
2012-10-27 23:18:32 +02:00
|
|
|
struct rb_root symbols[MAP__NR_TYPES];
|
|
|
|
struct rb_root symbol_names[MAP__NR_TYPES];
|
2013-12-03 08:23:07 +01:00
|
|
|
void *a2l;
|
2013-12-03 08:23:08 +01:00
|
|
|
char *symsrc_filename;
|
2013-12-03 08:23:10 +01:00
|
|
|
unsigned int a2l_fails;
|
2012-10-27 23:18:32 +02:00
|
|
|
enum dso_kernel_type kernel;
|
|
|
|
enum dso_swap_type needs_swap;
|
|
|
|
enum dso_binary_type symtab_type;
|
2013-12-17 20:14:07 +01:00
|
|
|
enum dso_binary_type binary_type;
|
2012-10-27 23:18:32 +02:00
|
|
|
u8 adjust_symbols:1;
|
|
|
|
u8 has_build_id:1;
|
2013-09-11 07:09:31 +02:00
|
|
|
u8 has_srcline:1;
|
2012-10-27 23:18:32 +02:00
|
|
|
u8 hit:1;
|
|
|
|
u8 annotate_warned:1;
|
2013-12-10 14:44:37 +01:00
|
|
|
u8 short_name_allocated:1;
|
|
|
|
u8 long_name_allocated:1;
|
2014-07-14 12:02:41 +02:00
|
|
|
u8 is_64_bit:1;
|
2012-10-27 23:18:32 +02:00
|
|
|
u8 sorted_by_name;
|
|
|
|
u8 loaded;
|
2013-08-07 13:38:50 +02:00
|
|
|
u8 rel;
|
2012-10-27 23:18:32 +02:00
|
|
|
u8 build_id[BUILD_ID_SIZE];
|
|
|
|
const char *short_name;
|
2013-12-10 19:19:23 +01:00
|
|
|
const char *long_name;
|
2012-10-27 23:18:32 +02:00
|
|
|
u16 long_name_len;
|
|
|
|
u16 short_name_len;
|
2014-05-07 18:30:45 +02:00
|
|
|
|
|
|
|
/* dso data file */
|
|
|
|
struct {
|
|
|
|
struct rb_root cache;
|
2014-04-28 16:43:43 +02:00
|
|
|
int fd;
|
2014-07-22 15:17:18 +02:00
|
|
|
int status;
|
2014-07-22 15:17:19 +02:00
|
|
|
u32 status_seen;
|
2014-05-07 18:51:41 +02:00
|
|
|
size_t file_size;
|
2014-04-30 15:00:59 +02:00
|
|
|
struct list_head open_entry;
|
2014-05-07 18:30:45 +02:00
|
|
|
} data;
|
|
|
|
|
2012-10-27 23:18:32 +02:00
|
|
|
char name[0];
|
|
|
|
};
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-06 06:32:25 +01:00
|
|
|
/* dso__for_each_symbol - iterate over the symbols of given type
|
|
|
|
*
|
|
|
|
* @dso: the 'struct dso *' in which symbols itereated
|
|
|
|
* @pos: the 'struct symbol *' to use as a loop cursor
|
|
|
|
* @n: the 'struct rb_node *' to use as a temporary storage
|
|
|
|
* @type: the 'enum map_type' type of symbols
|
|
|
|
*/
|
|
|
|
#define dso__for_each_symbol(dso, pos, n, type) \
|
|
|
|
symbols__for_each_entry(&(dso)->symbols[(type)], pos, n)
|
|
|
|
|
2012-10-27 23:18:32 +02:00
|
|
|
static inline void dso__set_loaded(struct dso *dso, enum map_type type)
|
|
|
|
{
|
|
|
|
dso->loaded |= (1 << type);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct dso *dso__new(const char *name);
|
|
|
|
void dso__delete(struct dso *dso);
|
|
|
|
|
2013-12-10 15:11:46 +01:00
|
|
|
void dso__set_short_name(struct dso *dso, const char *name, bool name_allocated);
|
2013-12-10 19:19:23 +01:00
|
|
|
void dso__set_long_name(struct dso *dso, const char *name, bool name_allocated);
|
2012-10-27 23:18:32 +02:00
|
|
|
|
|
|
|
int dso__name_len(const struct dso *dso);
|
|
|
|
|
|
|
|
bool dso__loaded(const struct dso *dso, enum map_type type);
|
|
|
|
|
|
|
|
bool dso__sorted_by_name(const struct dso *dso, enum map_type type);
|
|
|
|
void dso__set_sorted_by_name(struct dso *dso, enum map_type type);
|
|
|
|
void dso__sort_by_name(struct dso *dso, enum map_type type);
|
|
|
|
|
|
|
|
void dso__set_build_id(struct dso *dso, void *build_id);
|
|
|
|
bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
|
|
|
|
void dso__read_running_kernel_build_id(struct dso *dso,
|
|
|
|
struct machine *machine);
|
|
|
|
int dso__kernel_module_get_build_id(struct dso *dso, const char *root_dir);
|
|
|
|
|
|
|
|
char dso__symtab_origin(const struct dso *dso);
|
2013-12-16 21:03:18 +01:00
|
|
|
int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type type,
|
|
|
|
char *root_dir, char *filename, size_t size);
|
2012-10-27 23:18:32 +02:00
|
|
|
|
2014-05-07 21:09:59 +02:00
|
|
|
/*
|
|
|
|
* The dso__data_* external interface provides following functions:
|
|
|
|
* dso__data_fd
|
|
|
|
* dso__data_close
|
2014-07-22 15:17:35 +02:00
|
|
|
* dso__data_size
|
2014-05-07 21:09:59 +02:00
|
|
|
* dso__data_read_offset
|
|
|
|
* dso__data_read_addr
|
|
|
|
*
|
|
|
|
* Please refer to the dso.c object code for each function and
|
|
|
|
* arguments documentation. Following text tries to explain the
|
|
|
|
* dso file descriptor caching.
|
|
|
|
*
|
|
|
|
* The dso__data* interface allows caching of opened file descriptors
|
|
|
|
* to speed up the dso data accesses. The idea is to leave the file
|
|
|
|
* descriptor opened ideally for the whole life of the dso object.
|
|
|
|
*
|
|
|
|
* The current usage of the dso__data_* interface is as follows:
|
|
|
|
*
|
|
|
|
* Get DSO's fd:
|
|
|
|
* int fd = dso__data_fd(dso, machine);
|
|
|
|
* USE 'fd' SOMEHOW
|
|
|
|
*
|
|
|
|
* Read DSO's data:
|
|
|
|
* n = dso__data_read_offset(dso_0, &machine, 0, buf, BUFSIZE);
|
|
|
|
* n = dso__data_read_addr(dso_0, &machine, 0, buf, BUFSIZE);
|
|
|
|
*
|
|
|
|
* Eventually close DSO's fd:
|
|
|
|
* dso__data_close(dso);
|
|
|
|
*
|
|
|
|
* It is not necessary to close the DSO object data file. Each time new
|
|
|
|
* DSO data file is opened, the limit (RLIMIT_NOFILE/2) is checked. Once
|
|
|
|
* it is crossed, the oldest opened DSO object is closed.
|
|
|
|
*
|
|
|
|
* The dso__delete function calls close_dso function to ensure the
|
|
|
|
* data file descriptor gets closed/unmapped before the dso object
|
|
|
|
* is freed.
|
|
|
|
*
|
|
|
|
* TODO
|
|
|
|
*/
|
2012-10-27 23:18:32 +02:00
|
|
|
int dso__data_fd(struct dso *dso, struct machine *machine);
|
2014-04-28 16:43:43 +02:00
|
|
|
void dso__data_close(struct dso *dso);
|
|
|
|
|
2014-07-22 15:17:35 +02:00
|
|
|
off_t dso__data_size(struct dso *dso, struct machine *machine);
|
2012-10-27 23:18:32 +02:00
|
|
|
ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
|
|
|
|
u64 offset, u8 *data, ssize_t size);
|
|
|
|
ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
|
|
|
|
struct machine *machine, u64 addr,
|
|
|
|
u8 *data, ssize_t size);
|
2014-07-22 15:17:19 +02:00
|
|
|
bool dso__data_status_seen(struct dso *dso, enum dso_data_status_seen by);
|
2012-10-27 23:18:32 +02:00
|
|
|
|
|
|
|
struct map *dso__new_map(const char *name);
|
|
|
|
struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
|
|
|
|
const char *short_name, int dso_type);
|
|
|
|
|
2014-09-29 22:07:28 +02:00
|
|
|
void dsos__add(struct dsos *dsos, struct dso *dso);
|
|
|
|
struct dso *dsos__find(const struct dsos *dsos, const char *name,
|
perf symbols: Fix vdso list searching
When "perf record" was used on a large machine with a lot of CPUs, the
perf post-processing time (the time after the workload was done until
the perf command itself exited) could take a lot of minutes and even
hours depending on how large the resulting perf.data file was.
While running AIM7 1500-user high_systime workload on a 80-core x86-64
system with a 3.9 kernel (with only the -s -a options used), the
workload itself took about 2 minutes to run and the perf.data file had a
size of 1108.746 MB. However, the post-processing step took more than 10
minutes.
With a gprof-profiled perf binary, the time spent by perf was as
follows:
% cumulative self self total
time seconds seconds calls s/call s/call name
96.90 822.10 822.10 192156 0.00 0.00 dsos__find
0.81 828.96 6.86 172089958 0.00 0.00 rb_next
0.41 832.44 3.48 48539289 0.00 0.00 rb_erase
So 97% (822 seconds) of the time was spent in a single dsos_find()
function. After analyzing the call-graph data below:
-----------------------------------------------
0.00 822.12 192156/192156 map__new [6]
[7] 96.9 0.00 822.12 192156 vdso__dso_findnew [7]
822.10 0.00 192156/192156 dsos__find [8]
0.01 0.00 192156/192156 dsos__add [62]
0.01 0.00 192156/192366 dso__new [61]
0.00 0.00 1/45282525 memdup [31]
0.00 0.00 192156/192230 dso__set_long_name [91]
-----------------------------------------------
822.10 0.00 192156/192156 vdso__dso_findnew [7]
[8] 96.9 822.10 0.00 192156 dsos__find [8]
-----------------------------------------------
It was found that the vdso__dso_findnew() function failed to locate
VDSO__MAP_NAME ("[vdso]") in the dso list and have to insert a new
entry at the end for 192156 times. This problem is due to the fact that
there are 2 types of name in the dso entry - short name and long name.
The initial dso__new() adds "[vdso]" to both the short and long names.
After that, vdso__dso_findnew() modifies the long name to something
like /tmp/perf-vdso.so-NoXkDj. The dsos__find() function only compares
the long name. As a result, the same vdso entry is duplicated many
time in the dso list. This bug increases memory consumption as well
as slows the symbol processing time to a crawl.
To resolve this problem, the dsos__find() function interface was
modified to enable searching either the long name or the short
name. The vdso__dso_findnew() will now search only the short name
while the other call sites search for the long name as before.
With this change, the cpu time of perf was reduced from 848.38s to
15.77s and dsos__find() only accounted for 0.06% of the total time.
0.06 15.73 0.01 192151 0.00 0.00 dsos__find
Signed-off-by: Waiman Long <Waiman.Long@hp.com>
Acked-by: Ingo Molnar <mingo@kernel.org>
Cc: "Chandramouleeswaran, Aswin" <aswin@hp.com>
Cc: "Norton, Scott J" <scott.norton@hp.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/r/1368110568-64714-1-git-send-email-Waiman.Long@hp.com
[ replaced TRUE/FALSE with stdbool.h equivalents, fixing builds where
those macros are not present (NO_LIBPYTHON=1 NO_LIBPERL=1), fix from Jiri Olsa ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-05-09 16:42:48 +02:00
|
|
|
bool cmp_short);
|
2014-09-29 22:07:28 +02:00
|
|
|
struct dso *__dsos__findnew(struct dsos *dsos, const char *name);
|
2012-10-27 23:18:32 +02:00
|
|
|
bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
|
|
|
|
|
|
|
|
size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
|
2012-12-07 13:53:58 +01:00
|
|
|
bool (skip)(struct dso *dso, int parm), int parm);
|
2012-10-27 23:18:32 +02:00
|
|
|
size_t __dsos__fprintf(struct list_head *head, FILE *fp);
|
|
|
|
|
|
|
|
size_t dso__fprintf_buildid(struct dso *dso, FILE *fp);
|
|
|
|
size_t dso__fprintf_symbols_by_name(struct dso *dso,
|
|
|
|
enum map_type type, FILE *fp);
|
|
|
|
size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp);
|
2013-08-07 13:38:47 +02:00
|
|
|
|
|
|
|
static inline bool dso__is_vmlinux(struct dso *dso)
|
|
|
|
{
|
2013-12-17 20:14:07 +01:00
|
|
|
return dso->binary_type == DSO_BINARY_TYPE__VMLINUX ||
|
|
|
|
dso->binary_type == DSO_BINARY_TYPE__GUEST_VMLINUX;
|
2013-08-07 13:38:47 +02:00
|
|
|
}
|
|
|
|
|
2013-08-07 13:38:51 +02:00
|
|
|
static inline bool dso__is_kcore(struct dso *dso)
|
|
|
|
{
|
2013-12-17 20:14:07 +01:00
|
|
|
return dso->binary_type == DSO_BINARY_TYPE__KCORE ||
|
|
|
|
dso->binary_type == DSO_BINARY_TYPE__GUEST_KCORE;
|
2013-08-07 13:38:51 +02:00
|
|
|
}
|
|
|
|
|
2013-12-03 08:23:07 +01:00
|
|
|
void dso__free_a2l(struct dso *dso);
|
|
|
|
|
2014-07-22 15:17:59 +02:00
|
|
|
enum dso_type dso__type(struct dso *dso, struct machine *machine);
|
|
|
|
|
2012-10-27 23:18:32 +02:00
|
|
|
#endif /* __PERF_DSO */
|