2009-05-29 00:55:04 +07:00
|
|
|
#include "util.h"
|
|
|
|
#include "../perf.h"
|
2009-06-02 03:50:19 +07:00
|
|
|
#include "string.h"
|
2009-05-29 00:55:04 +07:00
|
|
|
#include "symbol.h"
|
2009-10-02 13:29:58 +07:00
|
|
|
#include "thread.h"
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-08-17 03:05:48 +07:00
|
|
|
#include "debug.h"
|
|
|
|
|
2009-11-24 21:05:15 +07:00
|
|
|
#include <asm/bug.h>
|
2009-05-29 00:55:04 +07:00
|
|
|
#include <libelf.h>
|
|
|
|
#include <gelf.h>
|
|
|
|
#include <elf.h>
|
2009-11-19 05:20:52 +07:00
|
|
|
#include <limits.h>
|
2009-10-02 13:29:58 +07:00
|
|
|
#include <sys/utsname.h>
|
2009-08-05 19:05:16 +07:00
|
|
|
|
2009-11-21 23:31:25 +07:00
|
|
|
#ifndef NT_GNU_BUILD_ID
|
|
|
|
#define NT_GNU_BUILD_ID 3
|
|
|
|
#endif
|
|
|
|
|
2009-08-07 00:43:17 +07:00
|
|
|
enum dso_origin {
|
|
|
|
DSO__ORIG_KERNEL = 0,
|
|
|
|
DSO__ORIG_JAVA_JIT,
|
|
|
|
DSO__ORIG_FEDORA,
|
|
|
|
DSO__ORIG_UBUNTU,
|
|
|
|
DSO__ORIG_BUILDID,
|
|
|
|
DSO__ORIG_DSO,
|
2009-10-02 13:29:58 +07:00
|
|
|
DSO__ORIG_KMODULE,
|
2009-08-07 00:43:17 +07:00
|
|
|
DSO__ORIG_NOT_FOUND,
|
|
|
|
};
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
static void dsos__add(struct list_head *head, struct dso *dso);
|
2009-12-11 23:50:36 +07:00
|
|
|
static struct map *map_groups__find_by_name(struct map_groups *self, char *name);
|
2009-11-28 01:29:16 +07:00
|
|
|
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
|
2009-11-28 01:29:17 +07:00
|
|
|
struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
|
2009-11-21 05:51:27 +07:00
|
|
|
static int dso__load_kernel_sym(struct dso *self, struct map *map,
|
2009-12-11 23:50:36 +07:00
|
|
|
struct map_groups *mg, symbol_filter_t filter);
|
2009-10-31 01:28:24 +07:00
|
|
|
unsigned int symbol__priv_size;
|
2009-11-24 01:39:10 +07:00
|
|
|
static int vmlinux_path__nr_entries;
|
|
|
|
static char **vmlinux_path;
|
2009-10-02 13:29:58 +07:00
|
|
|
|
2009-11-24 21:05:15 +07:00
|
|
|
static struct symbol_conf symbol_conf__defaults = {
|
|
|
|
.use_modules = true,
|
|
|
|
.try_vmlinux_path = true,
|
|
|
|
};
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static struct map_groups kmaps_mem;
|
|
|
|
struct map_groups *kmaps = &kmaps_mem;
|
2009-10-06 00:26:17 +07:00
|
|
|
|
2009-11-28 01:29:16 +07:00
|
|
|
bool dso__loaded(const struct dso *self, enum map_type type)
|
|
|
|
{
|
|
|
|
return self->loaded & (1 << type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dso__set_loaded(struct dso *self, enum map_type type)
|
|
|
|
{
|
|
|
|
self->loaded |= (1 << type);
|
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:37 +07:00
|
|
|
static bool symbol_type__is_a(char symbol_type, enum map_type map_type)
|
|
|
|
{
|
|
|
|
switch (map_type) {
|
|
|
|
case MAP__FUNCTION:
|
|
|
|
return symbol_type == 'T' || symbol_type == 'W';
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-24 22:01:52 +07:00
|
|
|
static void symbols__fixup_end(struct rb_root *self)
|
2009-10-06 00:26:17 +07:00
|
|
|
{
|
2009-11-24 22:01:52 +07:00
|
|
|
struct rb_node *nd, *prevnd = rb_first(self);
|
2009-10-07 23:48:56 +07:00
|
|
|
struct symbol *curr, *prev;
|
2009-10-06 00:26:17 +07:00
|
|
|
|
|
|
|
if (prevnd == NULL)
|
|
|
|
return;
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
curr = rb_entry(prevnd, struct symbol, rb_node);
|
|
|
|
|
2009-10-06 00:26:17 +07:00
|
|
|
for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
|
2009-10-07 23:48:56 +07:00
|
|
|
prev = curr;
|
|
|
|
curr = rb_entry(nd, struct symbol, rb_node);
|
2009-10-06 00:26:17 +07:00
|
|
|
|
|
|
|
if (prev->end == prev->start)
|
|
|
|
prev->end = curr->start - 1;
|
|
|
|
}
|
2009-10-07 23:48:56 +07:00
|
|
|
|
|
|
|
/* Last entry */
|
|
|
|
if (curr->end == curr->start)
|
|
|
|
curr->end = roundup(curr->start, 4096);
|
2009-10-06 00:26:17 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
|
2009-10-06 00:26:17 +07:00
|
|
|
{
|
|
|
|
struct map *prev, *curr;
|
2009-11-28 01:29:20 +07:00
|
|
|
struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
|
2009-10-06 00:26:17 +07:00
|
|
|
|
|
|
|
if (prevnd == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
curr = rb_entry(prevnd, struct map, rb_node);
|
|
|
|
|
|
|
|
for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
|
|
|
|
prev = curr;
|
|
|
|
curr = rb_entry(nd, struct map, rb_node);
|
|
|
|
prev->end = curr->start - 1;
|
2009-10-07 23:48:56 +07:00
|
|
|
}
|
2009-11-21 23:31:24 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We still haven't the actual symbols, so guess the
|
|
|
|
* last map final address.
|
|
|
|
*/
|
|
|
|
curr->end = ~0UL;
|
2009-10-06 00:26:17 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static void map_groups__fixup_end(struct map_groups *self)
|
2009-11-28 01:29:19 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < MAP__NR_TYPES; ++i)
|
2009-12-11 23:50:36 +07:00
|
|
|
__map_groups__fixup_end(self, i);
|
2009-11-28 01:29:19 +07:00
|
|
|
}
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
static struct symbol *symbol__new(u64 start, u64 len, const char *name)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-05-29 00:55:13 +07:00
|
|
|
size_t namelen = strlen(name) + 1;
|
2009-11-24 21:05:16 +07:00
|
|
|
struct symbol *self = zalloc(symbol__priv_size +
|
|
|
|
sizeof(*self) + namelen);
|
|
|
|
if (self == NULL)
|
perf_counter tools: Add 'perf annotate' feature
Add new perf sub-command to display annotated source code:
$ perf annotate decode_tree_entry
------------------------------------------------
Percent | Source code & Disassembly of /home/mingo/git/git
------------------------------------------------
:
: /home/mingo/git/git: file format elf64-x86-64
:
:
: Disassembly of section .text:
:
: 00000000004a0da0 <decode_tree_entry>:
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
3.82 : 4a0da0: 41 54 push %r12
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.17 : 4a0da2: 48 83 fa 17 cmp $0x17,%rdx
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
0.00 : 4a0da6: 49 89 fc mov %rdi,%r12
0.00 : 4a0da9: 55 push %rbp
3.37 : 4a0daa: 53 push %rbx
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.08 : 4a0dab: 76 73 jbe 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dad: 80 7c 16 eb 00 cmpb $0x0,-0x15(%rsi,%rdx,1)
3.48 : 4a0db2: 75 6c jne 4a0e20 <decode_tree_entry+0x80>
: static const char *get_mode(const char *str, unsigned int *modep)
: {
: unsigned char c;
: unsigned int mode = 0;
:
: if (*str == ' ')
1.94 : 4a0db4: 0f b6 06 movzbl (%rsi),%eax
0.39 : 4a0db7: 3c 20 cmp $0x20,%al
0.00 : 4a0db9: 74 65 je 4a0e20 <decode_tree_entry+0x80>
: return NULL;
:
: while ((c = *str++) != ' ') {
0.06 : 4a0dbb: 89 c2 mov %eax,%edx
: if (c < '0' || c > '7')
1.99 : 4a0dbd: 31 ed xor %ebp,%ebp
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
1.74 : 4a0dbf: 48 8d 5e 01 lea 0x1(%rsi),%rbx
: if (c < '0' || c > '7')
0.00 : 4a0dc3: 8d 42 d0 lea -0x30(%rdx),%eax
0.17 : 4a0dc6: 3c 07 cmp $0x7,%al
0.00 : 4a0dc8: 76 0d jbe 4a0dd7 <decode_tree_entry+0x37>
0.00 : 4a0dca: eb 54 jmp 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dcc: 0f 1f 40 00 nopl 0x0(%rax)
16.57 : 4a0dd0: 8d 42 d0 lea -0x30(%rdx),%eax
0.14 : 4a0dd3: 3c 07 cmp $0x7,%al
0.00 : 4a0dd5: 77 49 ja 4a0e20 <decode_tree_entry+0x80>
: return NULL;
: mode = (mode << 3) + (c - '0');
3.12 : 4a0dd7: 0f b6 c2 movzbl %dl,%eax
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
0.00 : 4a0dda: 0f b6 13 movzbl (%rbx),%edx
16.74 : 4a0ddd: 48 83 c3 01 add $0x1,%rbx
: if (c < '0' || c > '7')
: return NULL;
: mode = (mode << 3) + (c - '0');
The first column is the percentage of samples that arrived on that
particular line - relative to the total cost of the function.
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-06 20:48:52 +07:00
|
|
|
return NULL;
|
|
|
|
|
2009-11-24 21:05:16 +07:00
|
|
|
if (symbol__priv_size)
|
2009-10-31 01:28:24 +07:00
|
|
|
self = ((void *)self) + symbol__priv_size;
|
2009-11-24 21:05:16 +07:00
|
|
|
|
perf_counter tools: Add 'perf annotate' feature
Add new perf sub-command to display annotated source code:
$ perf annotate decode_tree_entry
------------------------------------------------
Percent | Source code & Disassembly of /home/mingo/git/git
------------------------------------------------
:
: /home/mingo/git/git: file format elf64-x86-64
:
:
: Disassembly of section .text:
:
: 00000000004a0da0 <decode_tree_entry>:
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
3.82 : 4a0da0: 41 54 push %r12
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.17 : 4a0da2: 48 83 fa 17 cmp $0x17,%rdx
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
0.00 : 4a0da6: 49 89 fc mov %rdi,%r12
0.00 : 4a0da9: 55 push %rbp
3.37 : 4a0daa: 53 push %rbx
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.08 : 4a0dab: 76 73 jbe 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dad: 80 7c 16 eb 00 cmpb $0x0,-0x15(%rsi,%rdx,1)
3.48 : 4a0db2: 75 6c jne 4a0e20 <decode_tree_entry+0x80>
: static const char *get_mode(const char *str, unsigned int *modep)
: {
: unsigned char c;
: unsigned int mode = 0;
:
: if (*str == ' ')
1.94 : 4a0db4: 0f b6 06 movzbl (%rsi),%eax
0.39 : 4a0db7: 3c 20 cmp $0x20,%al
0.00 : 4a0db9: 74 65 je 4a0e20 <decode_tree_entry+0x80>
: return NULL;
:
: while ((c = *str++) != ' ') {
0.06 : 4a0dbb: 89 c2 mov %eax,%edx
: if (c < '0' || c > '7')
1.99 : 4a0dbd: 31 ed xor %ebp,%ebp
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
1.74 : 4a0dbf: 48 8d 5e 01 lea 0x1(%rsi),%rbx
: if (c < '0' || c > '7')
0.00 : 4a0dc3: 8d 42 d0 lea -0x30(%rdx),%eax
0.17 : 4a0dc6: 3c 07 cmp $0x7,%al
0.00 : 4a0dc8: 76 0d jbe 4a0dd7 <decode_tree_entry+0x37>
0.00 : 4a0dca: eb 54 jmp 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dcc: 0f 1f 40 00 nopl 0x0(%rax)
16.57 : 4a0dd0: 8d 42 d0 lea -0x30(%rdx),%eax
0.14 : 4a0dd3: 3c 07 cmp $0x7,%al
0.00 : 4a0dd5: 77 49 ja 4a0e20 <decode_tree_entry+0x80>
: return NULL;
: mode = (mode << 3) + (c - '0');
3.12 : 4a0dd7: 0f b6 c2 movzbl %dl,%eax
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
0.00 : 4a0dda: 0f b6 13 movzbl (%rbx),%edx
16.74 : 4a0ddd: 48 83 c3 01 add $0x1,%rbx
: if (c < '0' || c > '7')
: return NULL;
: mode = (mode << 3) + (c - '0');
The first column is the percentage of samples that arrived on that
particular line - relative to the total cost of the function.
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-06 20:48:52 +07:00
|
|
|
self->start = start;
|
2009-07-02 13:08:36 +07:00
|
|
|
self->end = len ? start + len - 1 : start;
|
2009-10-20 23:25:40 +07:00
|
|
|
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_debug3("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
|
2009-10-20 23:25:40 +07:00
|
|
|
|
perf_counter tools: Add 'perf annotate' feature
Add new perf sub-command to display annotated source code:
$ perf annotate decode_tree_entry
------------------------------------------------
Percent | Source code & Disassembly of /home/mingo/git/git
------------------------------------------------
:
: /home/mingo/git/git: file format elf64-x86-64
:
:
: Disassembly of section .text:
:
: 00000000004a0da0 <decode_tree_entry>:
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
3.82 : 4a0da0: 41 54 push %r12
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.17 : 4a0da2: 48 83 fa 17 cmp $0x17,%rdx
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
0.00 : 4a0da6: 49 89 fc mov %rdi,%r12
0.00 : 4a0da9: 55 push %rbp
3.37 : 4a0daa: 53 push %rbx
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.08 : 4a0dab: 76 73 jbe 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dad: 80 7c 16 eb 00 cmpb $0x0,-0x15(%rsi,%rdx,1)
3.48 : 4a0db2: 75 6c jne 4a0e20 <decode_tree_entry+0x80>
: static const char *get_mode(const char *str, unsigned int *modep)
: {
: unsigned char c;
: unsigned int mode = 0;
:
: if (*str == ' ')
1.94 : 4a0db4: 0f b6 06 movzbl (%rsi),%eax
0.39 : 4a0db7: 3c 20 cmp $0x20,%al
0.00 : 4a0db9: 74 65 je 4a0e20 <decode_tree_entry+0x80>
: return NULL;
:
: while ((c = *str++) != ' ') {
0.06 : 4a0dbb: 89 c2 mov %eax,%edx
: if (c < '0' || c > '7')
1.99 : 4a0dbd: 31 ed xor %ebp,%ebp
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
1.74 : 4a0dbf: 48 8d 5e 01 lea 0x1(%rsi),%rbx
: if (c < '0' || c > '7')
0.00 : 4a0dc3: 8d 42 d0 lea -0x30(%rdx),%eax
0.17 : 4a0dc6: 3c 07 cmp $0x7,%al
0.00 : 4a0dc8: 76 0d jbe 4a0dd7 <decode_tree_entry+0x37>
0.00 : 4a0dca: eb 54 jmp 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dcc: 0f 1f 40 00 nopl 0x0(%rax)
16.57 : 4a0dd0: 8d 42 d0 lea -0x30(%rdx),%eax
0.14 : 4a0dd3: 3c 07 cmp $0x7,%al
0.00 : 4a0dd5: 77 49 ja 4a0e20 <decode_tree_entry+0x80>
: return NULL;
: mode = (mode << 3) + (c - '0');
3.12 : 4a0dd7: 0f b6 c2 movzbl %dl,%eax
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
0.00 : 4a0dda: 0f b6 13 movzbl (%rbx),%edx
16.74 : 4a0ddd: 48 83 c3 01 add $0x1,%rbx
: if (c < '0' || c > '7')
: return NULL;
: mode = (mode << 3) + (c - '0');
The first column is the percentage of samples that arrived on that
particular line - relative to the total cost of the function.
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-06 20:48:52 +07:00
|
|
|
memcpy(self->name, name, namelen);
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
static void symbol__delete(struct symbol *self)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-10-31 01:28:24 +07:00
|
|
|
free(((void *)self) - symbol__priv_size);
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static size_t symbol__fprintf(struct symbol *self, FILE *fp)
|
|
|
|
{
|
2009-10-02 13:29:58 +07:00
|
|
|
return fprintf(fp, " %llx-%llx %s\n",
|
2009-05-29 00:55:04 +07:00
|
|
|
self->start, self->end, self->name);
|
|
|
|
}
|
|
|
|
|
2009-11-18 00:40:53 +07:00
|
|
|
static void dso__set_long_name(struct dso *self, char *name)
|
|
|
|
{
|
2009-11-21 05:51:29 +07:00
|
|
|
if (name == NULL)
|
|
|
|
return;
|
2009-11-18 00:40:53 +07:00
|
|
|
self->long_name = name;
|
|
|
|
self->long_name_len = strlen(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dso__set_basename(struct dso *self)
|
|
|
|
{
|
|
|
|
self->short_name = basename(self->long_name);
|
|
|
|
}
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
struct dso *dso__new(const char *name)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
|
|
|
|
|
|
|
|
if (self != NULL) {
|
2009-11-28 01:29:17 +07:00
|
|
|
int i;
|
2009-05-29 00:55:04 +07:00
|
|
|
strcpy(self->name, name);
|
2009-11-18 00:40:53 +07:00
|
|
|
dso__set_long_name(self, self->name);
|
2009-10-02 13:29:58 +07:00
|
|
|
self->short_name = self->name;
|
2009-11-28 01:29:17 +07:00
|
|
|
for (i = 0; i < MAP__NR_TYPES; ++i)
|
|
|
|
self->symbols[i] = RB_ROOT;
|
|
|
|
self->find_symbol = dso__find_symbol;
|
2009-07-11 08:47:28 +07:00
|
|
|
self->slen_calculated = 0;
|
2009-08-07 00:43:17 +07:00
|
|
|
self->origin = DSO__ORIG_NOT_FOUND;
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
self->loaded = 0;
|
|
|
|
self->has_build_id = 0;
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2009-11-24 22:01:52 +07:00
|
|
|
static void symbols__delete(struct rb_root *self)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct symbol *pos;
|
2009-11-24 22:01:52 +07:00
|
|
|
struct rb_node *next = rb_first(self);
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
while (next) {
|
|
|
|
pos = rb_entry(next, struct symbol, rb_node);
|
|
|
|
next = rb_next(&pos->rb_node);
|
2009-11-24 22:01:52 +07:00
|
|
|
rb_erase(&pos->rb_node, self);
|
2009-10-31 01:28:24 +07:00
|
|
|
symbol__delete(pos);
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void dso__delete(struct dso *self)
|
|
|
|
{
|
2009-11-28 01:29:17 +07:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < MAP__NR_TYPES; ++i)
|
|
|
|
symbols__delete(&self->symbols[i]);
|
2009-10-02 13:29:58 +07:00
|
|
|
if (self->long_name != self->name)
|
|
|
|
free(self->long_name);
|
2009-05-29 00:55:04 +07:00
|
|
|
free(self);
|
|
|
|
}
|
|
|
|
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
void dso__set_build_id(struct dso *self, void *build_id)
|
|
|
|
{
|
|
|
|
memcpy(self->build_id, build_id, sizeof(self->build_id));
|
|
|
|
self->has_build_id = 1;
|
|
|
|
}
|
|
|
|
|
2009-11-24 22:01:52 +07:00
|
|
|
static void symbols__insert(struct rb_root *self, struct symbol *sym)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-11-24 22:01:52 +07:00
|
|
|
struct rb_node **p = &self->rb_node;
|
2009-05-29 00:55:04 +07:00
|
|
|
struct rb_node *parent = NULL;
|
perf_counter tools: Define and use our own u64, s64 etc. definitions
On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-19 19:21:42 +07:00
|
|
|
const u64 ip = sym->start;
|
2009-05-29 00:55:04 +07:00
|
|
|
struct symbol *s;
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
s = rb_entry(parent, struct symbol, rb_node);
|
|
|
|
if (ip < s->start)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
rb_link_node(&sym->rb_node, parent, p);
|
2009-11-24 22:01:52 +07:00
|
|
|
rb_insert_color(&sym->rb_node, self);
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2009-11-24 22:01:52 +07:00
|
|
|
static struct symbol *symbols__find(struct rb_root *self, u64 ip)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct rb_node *n;
|
|
|
|
|
|
|
|
if (self == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2009-11-24 22:01:52 +07:00
|
|
|
n = self->rb_node;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
while (n) {
|
|
|
|
struct symbol *s = rb_entry(n, struct symbol, rb_node);
|
|
|
|
|
|
|
|
if (ip < s->start)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (ip > s->end)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:17 +07:00
|
|
|
struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr)
|
2009-11-24 22:01:52 +07:00
|
|
|
{
|
2009-11-28 01:29:17 +07:00
|
|
|
return symbols__find(&self->symbols[type], addr);
|
2009-11-24 22:01:52 +07:00
|
|
|
}
|
|
|
|
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
int build_id__sprintf(u8 *self, int len, char *bf)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
char *bid = bf;
|
|
|
|
u8 *raw = self;
|
|
|
|
int i;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
for (i = 0; i < len; ++i) {
|
|
|
|
sprintf(bid, "%02x", *raw);
|
|
|
|
++raw;
|
|
|
|
bid += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return raw - self;
|
|
|
|
}
|
|
|
|
|
2009-11-17 01:32:44 +07:00
|
|
|
size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
{
|
|
|
|
char sbuild_id[BUILD_ID_SIZE * 2 + 1];
|
|
|
|
|
|
|
|
build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
|
2009-11-17 01:32:44 +07:00
|
|
|
return fprintf(fp, "%s", sbuild_id);
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
|
2009-11-17 01:32:44 +07:00
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
size_t ret = fprintf(fp, "dso: %s (", self->short_name);
|
|
|
|
|
|
|
|
ret += dso__fprintf_buildid(self, fp);
|
2009-11-28 01:29:17 +07:00
|
|
|
ret += fprintf(fp, ")\n");
|
2009-11-28 01:29:20 +07:00
|
|
|
for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
|
|
|
|
struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
|
|
|
|
ret += symbol__fprintf(pos, fp);
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
/*
|
|
|
|
* Loads the function entries in /proc/kallsyms into kernel_map->dso,
|
|
|
|
* so that we can in the next step set the symbol ->end address and then
|
|
|
|
* call kernel_maps__split_kallsyms.
|
|
|
|
*/
|
2009-11-28 01:29:18 +07:00
|
|
|
static int dso__load_all_kallsyms(struct dso *self, struct map *map)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
|
|
|
char *line = NULL;
|
|
|
|
size_t n;
|
2009-11-28 01:29:18 +07:00
|
|
|
struct rb_root *root = &self->symbols[map->type];
|
2009-05-29 00:55:04 +07:00
|
|
|
FILE *file = fopen("/proc/kallsyms", "r");
|
|
|
|
|
|
|
|
if (file == NULL)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
while (!feof(file)) {
|
perf_counter tools: Define and use our own u64, s64 etc. definitions
On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-19 19:21:42 +07:00
|
|
|
u64 start;
|
2009-05-29 00:55:04 +07:00
|
|
|
struct symbol *sym;
|
|
|
|
int line_len, len;
|
|
|
|
char symbol_type;
|
2009-10-07 23:48:56 +07:00
|
|
|
char *symbol_name;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
line_len = getline(&line, &n, file);
|
|
|
|
if (line_len < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!line)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
line[--line_len] = '\0'; /* \n */
|
|
|
|
|
2009-06-02 03:50:19 +07:00
|
|
|
len = hex2u64(line, &start);
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len + 2 >= line_len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
symbol_type = toupper(line[len]);
|
2009-12-11 23:50:37 +07:00
|
|
|
if (!symbol_type__is_a(symbol_type, map->type))
|
2009-05-29 00:55:04 +07:00
|
|
|
continue;
|
2009-10-06 00:26:17 +07:00
|
|
|
|
|
|
|
symbol_name = line + len + 2;
|
2009-10-07 23:48:56 +07:00
|
|
|
/*
|
|
|
|
* Will fix up the end later, when we have all symbols sorted.
|
|
|
|
*/
|
2009-10-31 01:28:24 +07:00
|
|
|
sym = symbol__new(start, 0, symbol_name);
|
2009-10-06 00:26:17 +07:00
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
if (sym == NULL)
|
|
|
|
goto out_delete_line;
|
2009-11-16 22:48:11 +07:00
|
|
|
/*
|
|
|
|
* We will pass the symbols to the filter later, in
|
2009-11-28 01:29:18 +07:00
|
|
|
* map__split_kallsyms, when we have split the maps per module
|
2009-11-16 22:48:11 +07:00
|
|
|
*/
|
2009-11-28 01:29:18 +07:00
|
|
|
symbols__insert(root, sym);
|
2009-10-07 23:48:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
free(line);
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_delete_line:
|
|
|
|
free(line);
|
|
|
|
out_failure:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Split the symbols into maps, making sure there are no overlaps, i.e. the
|
|
|
|
* kernel range is broken in several maps, named [kernel].N, as we don't have
|
|
|
|
* the original ELF section names vmlinux have.
|
|
|
|
*/
|
2009-12-11 23:50:36 +07:00
|
|
|
static int dso__split_kallsyms(struct dso *self, struct map *map,
|
|
|
|
struct map_groups *mg, symbol_filter_t filter)
|
2009-10-07 23:48:56 +07:00
|
|
|
{
|
2009-11-28 01:29:18 +07:00
|
|
|
struct map *curr_map = map;
|
2009-10-07 23:48:56 +07:00
|
|
|
struct symbol *pos;
|
|
|
|
int count = 0;
|
2009-11-28 01:29:18 +07:00
|
|
|
struct rb_root *root = &self->symbols[map->type];
|
|
|
|
struct rb_node *next = rb_first(root);
|
2009-10-07 23:48:56 +07:00
|
|
|
int kernel_range = 0;
|
|
|
|
|
|
|
|
while (next) {
|
|
|
|
char *module;
|
|
|
|
|
|
|
|
pos = rb_entry(next, struct symbol, rb_node);
|
|
|
|
next = rb_next(&pos->rb_node);
|
|
|
|
|
|
|
|
module = strchr(pos->name, '\t');
|
|
|
|
if (module) {
|
2009-12-11 23:50:36 +07:00
|
|
|
if (!mg->use_modules)
|
2009-11-28 01:29:21 +07:00
|
|
|
goto discard_symbol;
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
*module++ = '\0';
|
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
if (strcmp(self->name, module)) {
|
2009-12-11 23:50:36 +07:00
|
|
|
curr_map = map_groups__find_by_name(mg, module);
|
2009-11-28 01:29:18 +07:00
|
|
|
if (curr_map == NULL) {
|
2009-11-28 01:29:20 +07:00
|
|
|
pr_debug("/proc/{kallsyms,modules} "
|
|
|
|
"inconsistency!\n");
|
2009-10-06 00:26:17 +07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2009-10-07 23:48:56 +07:00
|
|
|
/*
|
|
|
|
* So that we look just like we get from .ko files,
|
|
|
|
* i.e. not prelinked, relative to map->start.
|
|
|
|
*/
|
2009-11-28 01:29:18 +07:00
|
|
|
pos->start = curr_map->map_ip(curr_map, pos->start);
|
|
|
|
pos->end = curr_map->map_ip(curr_map, pos->end);
|
|
|
|
} else if (curr_map != map) {
|
2009-10-07 23:48:56 +07:00
|
|
|
char dso_name[PATH_MAX];
|
|
|
|
struct dso *dso;
|
|
|
|
|
|
|
|
snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
|
|
|
|
kernel_range++);
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
dso = dso__new(dso_name);
|
2009-10-07 23:48:56 +07:00
|
|
|
if (dso == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
curr_map = map__new2(pos->start, dso, map->type);
|
2009-10-07 23:48:56 +07:00
|
|
|
if (map == NULL) {
|
|
|
|
dso__delete(dso);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__insert(mg, curr_map);
|
2009-10-07 23:48:56 +07:00
|
|
|
++kernel_range;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
if (filter && filter(curr_map, pos)) {
|
2009-11-28 01:29:21 +07:00
|
|
|
discard_symbol: rb_erase(&pos->rb_node, root);
|
2009-10-31 01:28:24 +07:00
|
|
|
symbol__delete(pos);
|
2009-10-07 23:48:56 +07:00
|
|
|
} else {
|
2009-11-28 01:29:18 +07:00
|
|
|
if (curr_map != map) {
|
|
|
|
rb_erase(&pos->rb_node, root);
|
|
|
|
symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
|
2009-10-07 23:48:56 +07:00
|
|
|
}
|
2009-07-02 13:05:58 +07:00
|
|
|
count++;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2009-07-02 13:05:58 +07:00
|
|
|
return count;
|
2009-10-07 23:48:56 +07:00
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
static int dso__load_kallsyms(struct dso *self, struct map *map,
|
2009-12-11 23:50:36 +07:00
|
|
|
struct map_groups *mg, symbol_filter_t filter)
|
2009-10-07 23:48:56 +07:00
|
|
|
{
|
2009-11-28 01:29:18 +07:00
|
|
|
if (dso__load_all_kallsyms(self, map) < 0)
|
2009-10-07 23:48:56 +07:00
|
|
|
return -1;
|
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
symbols__fixup_end(&self->symbols[map->type]);
|
|
|
|
self->origin = DSO__ORIG_KERNEL;
|
2009-10-07 23:48:56 +07:00
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
return dso__split_kallsyms(self, map, mg, filter);
|
2009-11-28 01:29:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t kernel_maps__fprintf(FILE *fp)
|
|
|
|
{
|
|
|
|
size_t printed = fprintf(fp, "Kernel maps:\n");
|
2009-12-11 23:50:36 +07:00
|
|
|
printed += map_groups__fprintf_maps(kmaps, fp);
|
2009-10-22 02:34:06 +07:00
|
|
|
return printed + fprintf(fp, "END kernel maps\n");
|
2009-10-06 00:26:17 +07:00
|
|
|
}
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
static int dso__load_perf_map(struct dso *self, struct map *map,
|
2009-10-22 02:34:06 +07:00
|
|
|
symbol_filter_t filter)
|
2009-06-09 01:12:48 +07:00
|
|
|
{
|
|
|
|
char *line = NULL;
|
|
|
|
size_t n;
|
|
|
|
FILE *file;
|
|
|
|
int nr_syms = 0;
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
file = fopen(self->long_name, "r");
|
2009-06-09 01:12:48 +07:00
|
|
|
if (file == NULL)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
while (!feof(file)) {
|
perf_counter tools: Define and use our own u64, s64 etc. definitions
On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-19 19:21:42 +07:00
|
|
|
u64 start, size;
|
2009-06-09 01:12:48 +07:00
|
|
|
struct symbol *sym;
|
|
|
|
int line_len, len;
|
|
|
|
|
|
|
|
line_len = getline(&line, &n, file);
|
|
|
|
if (line_len < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!line)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
line[--line_len] = '\0'; /* \n */
|
|
|
|
|
|
|
|
len = hex2u64(line, &start);
|
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len + 2 >= line_len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
len += hex2u64(line + len, &size);
|
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len + 2 >= line_len)
|
|
|
|
continue;
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
sym = symbol__new(start, size, line + len);
|
2009-06-09 01:12:48 +07:00
|
|
|
|
|
|
|
if (sym == NULL)
|
|
|
|
goto out_delete_line;
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
if (filter && filter(map, sym))
|
2009-10-31 01:28:24 +07:00
|
|
|
symbol__delete(sym);
|
2009-06-09 01:12:48 +07:00
|
|
|
else {
|
2009-11-28 01:29:17 +07:00
|
|
|
symbols__insert(&self->symbols[map->type], sym);
|
2009-06-09 01:12:48 +07:00
|
|
|
nr_syms++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(line);
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
return nr_syms;
|
|
|
|
|
|
|
|
out_delete_line:
|
|
|
|
free(line);
|
|
|
|
out_failure:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-29 00:55:04 +07:00
|
|
|
/**
|
|
|
|
* elf_symtab__for_each_symbol - iterate thru all the symbols
|
|
|
|
*
|
|
|
|
* @self: struct elf_symtab instance to iterate
|
2009-08-15 17:26:57 +07:00
|
|
|
* @idx: uint32_t idx
|
2009-05-29 00:55:04 +07:00
|
|
|
* @sym: GElf_Sym iterator
|
|
|
|
*/
|
2009-08-15 17:26:57 +07:00
|
|
|
#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
|
|
|
|
for (idx = 0, gelf_getsym(syms, idx, &sym);\
|
|
|
|
idx < nr_syms; \
|
|
|
|
idx++, gelf_getsym(syms, idx, &sym))
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
static inline uint8_t elf_sym__type(const GElf_Sym *sym)
|
|
|
|
{
|
|
|
|
return GELF_ST_TYPE(sym->st_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int elf_sym__is_function(const GElf_Sym *sym)
|
|
|
|
{
|
|
|
|
return elf_sym__type(sym) == STT_FUNC &&
|
|
|
|
sym->st_name != 0 &&
|
2009-10-06 09:35:03 +07:00
|
|
|
sym->st_shndx != SHN_UNDEF;
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2009-07-02 13:08:36 +07:00
|
|
|
static inline int elf_sym__is_label(const GElf_Sym *sym)
|
|
|
|
{
|
|
|
|
return elf_sym__type(sym) == STT_NOTYPE &&
|
|
|
|
sym->st_name != 0 &&
|
|
|
|
sym->st_shndx != SHN_UNDEF &&
|
|
|
|
sym->st_shndx != SHN_ABS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline const char *elf_sec__name(const GElf_Shdr *shdr,
|
|
|
|
const Elf_Data *secstrs)
|
|
|
|
{
|
|
|
|
return secstrs->d_buf + shdr->sh_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int elf_sec__is_text(const GElf_Shdr *shdr,
|
|
|
|
const Elf_Data *secstrs)
|
|
|
|
{
|
|
|
|
return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
|
|
|
|
}
|
|
|
|
|
2009-05-29 00:55:04 +07:00
|
|
|
static inline const char *elf_sym__name(const GElf_Sym *sym,
|
|
|
|
const Elf_Data *symstrs)
|
|
|
|
{
|
|
|
|
return symstrs->d_buf + sym->st_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
|
|
|
|
GElf_Shdr *shp, const char *name,
|
2009-08-15 17:26:57 +07:00
|
|
|
size_t *idx)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
|
|
|
Elf_Scn *sec = NULL;
|
|
|
|
size_t cnt = 1;
|
|
|
|
|
|
|
|
while ((sec = elf_nextscn(elf, sec)) != NULL) {
|
|
|
|
char *str;
|
|
|
|
|
|
|
|
gelf_getshdr(sec, shp);
|
|
|
|
str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
|
|
|
|
if (!strcmp(name, str)) {
|
2009-08-15 17:26:57 +07:00
|
|
|
if (idx)
|
|
|
|
*idx = cnt;
|
2009-05-29 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
++cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sec;
|
|
|
|
}
|
|
|
|
|
2009-06-03 10:54:33 +07:00
|
|
|
#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
|
|
|
|
for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
|
|
|
|
idx < nr_entries; \
|
|
|
|
++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
|
|
|
|
|
|
|
|
#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
|
|
|
|
for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
|
|
|
|
idx < nr_entries; \
|
|
|
|
++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
|
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
/*
|
|
|
|
* We need to check if we have a .dynsym, so that we can handle the
|
|
|
|
* .plt, synthesizing its symbols, that aren't on the symtabs (be it
|
|
|
|
* .dynsym or .symtab).
|
|
|
|
* And always look at the original dso, not at debuginfo packages, that
|
|
|
|
* have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
|
|
|
|
*/
|
2009-11-16 22:48:11 +07:00
|
|
|
static int dso__synthesize_plt_symbols(struct dso *self, struct map *map,
|
|
|
|
symbol_filter_t filter)
|
2009-06-03 10:54:33 +07:00
|
|
|
{
|
|
|
|
uint32_t nr_rel_entries, idx;
|
|
|
|
GElf_Sym sym;
|
perf_counter tools: Define and use our own u64, s64 etc. definitions
On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-19 19:21:42 +07:00
|
|
|
u64 plt_offset;
|
2009-06-03 10:54:33 +07:00
|
|
|
GElf_Shdr shdr_plt;
|
|
|
|
struct symbol *f;
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
GElf_Shdr shdr_rel_plt, shdr_dynsym;
|
2009-06-03 10:54:33 +07:00
|
|
|
Elf_Data *reldata, *syms, *symstrs;
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
|
|
|
|
size_t dynsym_idx;
|
|
|
|
GElf_Ehdr ehdr;
|
2009-06-03 10:54:33 +07:00
|
|
|
char sympltname[1024];
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
Elf *elf;
|
|
|
|
int nr = 0, symidx, fd, err = 0;
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
fd = open(self->long_name, O_RDONLY);
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
if (fd < 0)
|
|
|
|
goto out;
|
|
|
|
|
2009-10-24 23:10:36 +07:00
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
if (elf == NULL)
|
|
|
|
goto out_close;
|
|
|
|
|
|
|
|
if (gelf_getehdr(elf, &ehdr) == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
|
|
|
scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
|
|
|
|
".dynsym", &dynsym_idx);
|
|
|
|
if (scn_dynsym == NULL)
|
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
|
2009-06-03 10:54:33 +07:00
|
|
|
".rela.plt", NULL);
|
|
|
|
if (scn_plt_rel == NULL) {
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
|
2009-06-03 10:54:33 +07:00
|
|
|
".rel.plt", NULL);
|
|
|
|
if (scn_plt_rel == NULL)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
}
|
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
err = -1;
|
|
|
|
|
2009-06-03 10:54:33 +07:00
|
|
|
if (shdr_rel_plt.sh_link != dynsym_idx)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
|
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
|
|
|
/*
|
2009-08-15 17:26:57 +07:00
|
|
|
* Fetch the relocation section to find the idxes to the GOT
|
2009-06-03 10:54:33 +07:00
|
|
|
* and the symbols in the .dynsym they refer to.
|
|
|
|
*/
|
|
|
|
reldata = elf_getdata(scn_plt_rel, NULL);
|
|
|
|
if (reldata == NULL)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
|
|
|
syms = elf_getdata(scn_dynsym, NULL);
|
|
|
|
if (syms == NULL)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
|
2009-06-03 10:54:33 +07:00
|
|
|
if (scn_symstrs == NULL)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
|
|
|
symstrs = elf_getdata(scn_symstrs, NULL);
|
|
|
|
if (symstrs == NULL)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
|
|
|
nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
|
|
|
|
plt_offset = shdr_plt.sh_offset;
|
|
|
|
|
|
|
|
if (shdr_rel_plt.sh_type == SHT_RELA) {
|
|
|
|
GElf_Rela pos_mem, *pos;
|
|
|
|
|
|
|
|
elf_section__for_each_rela(reldata, pos, pos_mem, idx,
|
|
|
|
nr_rel_entries) {
|
|
|
|
symidx = GELF_R_SYM(pos->r_info);
|
|
|
|
plt_offset += shdr_plt.sh_entsize;
|
|
|
|
gelf_getsym(syms, symidx, &sym);
|
|
|
|
snprintf(sympltname, sizeof(sympltname),
|
|
|
|
"%s@plt", elf_sym__name(&sym, symstrs));
|
|
|
|
|
|
|
|
f = symbol__new(plt_offset, shdr_plt.sh_entsize,
|
2009-10-31 01:28:24 +07:00
|
|
|
sympltname);
|
2009-06-03 10:54:33 +07:00
|
|
|
if (!f)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
2009-11-16 22:48:11 +07:00
|
|
|
if (filter && filter(map, f))
|
|
|
|
symbol__delete(f);
|
|
|
|
else {
|
2009-11-28 01:29:17 +07:00
|
|
|
symbols__insert(&self->symbols[map->type], f);
|
2009-11-16 22:48:11 +07:00
|
|
|
++nr;
|
|
|
|
}
|
2009-06-03 10:54:33 +07:00
|
|
|
}
|
|
|
|
} else if (shdr_rel_plt.sh_type == SHT_REL) {
|
|
|
|
GElf_Rel pos_mem, *pos;
|
|
|
|
elf_section__for_each_rel(reldata, pos, pos_mem, idx,
|
|
|
|
nr_rel_entries) {
|
|
|
|
symidx = GELF_R_SYM(pos->r_info);
|
|
|
|
plt_offset += shdr_plt.sh_entsize;
|
|
|
|
gelf_getsym(syms, symidx, &sym);
|
|
|
|
snprintf(sympltname, sizeof(sympltname),
|
|
|
|
"%s@plt", elf_sym__name(&sym, symstrs));
|
|
|
|
|
|
|
|
f = symbol__new(plt_offset, shdr_plt.sh_entsize,
|
2009-10-31 01:28:24 +07:00
|
|
|
sympltname);
|
2009-06-03 10:54:33 +07:00
|
|
|
if (!f)
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
goto out_elf_end;
|
2009-06-03 10:54:33 +07:00
|
|
|
|
2009-11-16 22:48:11 +07:00
|
|
|
if (filter && filter(map, f))
|
|
|
|
symbol__delete(f);
|
|
|
|
else {
|
2009-11-28 01:29:17 +07:00
|
|
|
symbols__insert(&self->symbols[map->type], f);
|
2009-11-16 22:48:11 +07:00
|
|
|
++nr;
|
|
|
|
}
|
2009-06-03 10:54:33 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
err = 0;
|
|
|
|
out_elf_end:
|
|
|
|
elf_end(elf);
|
|
|
|
out_close:
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
if (err == 0)
|
|
|
|
return nr;
|
|
|
|
out:
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_warning("%s: problems reading %s PLT info.\n",
|
|
|
|
__func__, self->long_name);
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
return 0;
|
2009-06-03 10:54:33 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:38 +07:00
|
|
|
static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case MAP__FUNCTION:
|
|
|
|
return elf_sym__is_function(self);
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case MAP__FUNCTION:
|
|
|
|
return elf_sec__is_text(self, secstrs);
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
static int dso__load_sym(struct dso *self, struct map *map,
|
2009-12-11 23:50:36 +07:00
|
|
|
struct map_groups *mg, const char *name, int fd,
|
2009-11-28 01:29:20 +07:00
|
|
|
symbol_filter_t filter, int kernel, int kmodule)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-10-07 23:48:56 +07:00
|
|
|
struct map *curr_map = map;
|
|
|
|
struct dso *curr_dso = self;
|
|
|
|
size_t dso_name_len = strlen(self->short_name);
|
2009-07-02 13:08:36 +07:00
|
|
|
Elf_Data *symstrs, *secstrs;
|
2009-05-29 00:55:04 +07:00
|
|
|
uint32_t nr_syms;
|
|
|
|
int err = -1;
|
2009-08-15 17:26:57 +07:00
|
|
|
uint32_t idx;
|
2009-05-29 00:55:04 +07:00
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
Elf_Data *syms;
|
|
|
|
GElf_Sym sym;
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
Elf_Scn *sec, *sec_strndx;
|
2009-05-29 00:55:04 +07:00
|
|
|
Elf *elf;
|
2009-10-02 13:29:58 +07:00
|
|
|
int nr = 0;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-10-24 23:10:36 +07:00
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
2009-05-29 00:55:04 +07:00
|
|
|
if (elf == NULL) {
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_err("%s: cannot read %s ELF file.\n", __func__, name);
|
2009-05-29 00:55:04 +07:00
|
|
|
goto out_close;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gelf_getehdr(elf, &ehdr) == NULL) {
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_err("%s: cannot get elf header.\n", __func__);
|
2009-05-29 00:55:04 +07:00
|
|
|
goto out_elf_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
|
2009-06-03 10:54:33 +07:00
|
|
|
if (sec == NULL) {
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
|
|
|
|
if (sec == NULL)
|
2009-06-03 10:54:33 +07:00
|
|
|
goto out_elf_end;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
|
|
|
|
syms = elf_getdata(sec, NULL);
|
|
|
|
if (syms == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
|
|
|
sec = elf_getscn(elf, shdr.sh_link);
|
|
|
|
if (sec == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
|
|
|
symstrs = elf_getdata(sec, NULL);
|
|
|
|
if (symstrs == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
2009-07-02 13:08:36 +07:00
|
|
|
sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
|
|
|
|
if (sec_strndx == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
|
|
|
secstrs = elf_getdata(sec_strndx, NULL);
|
2009-07-30 17:25:29 +07:00
|
|
|
if (secstrs == NULL)
|
2009-07-02 13:08:36 +07:00
|
|
|
goto out_elf_end;
|
|
|
|
|
2009-05-29 00:55:04 +07:00
|
|
|
nr_syms = shdr.sh_size / shdr.sh_entsize;
|
|
|
|
|
2009-06-07 02:22:33 +07:00
|
|
|
memset(&sym, 0, sizeof(sym));
|
2009-07-20 19:01:38 +07:00
|
|
|
if (!kernel) {
|
|
|
|
self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
|
2009-07-03 07:24:14 +07:00
|
|
|
elf_section_by_name(elf, &ehdr, &shdr,
|
|
|
|
".gnu.prelink_undo",
|
|
|
|
NULL) != NULL);
|
2009-07-20 19:01:38 +07:00
|
|
|
} else self->adjust_symbols = 0;
|
|
|
|
|
2009-08-15 17:26:57 +07:00
|
|
|
elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
|
2009-05-29 00:55:04 +07:00
|
|
|
struct symbol *f;
|
2009-08-15 17:26:57 +07:00
|
|
|
const char *elf_name;
|
2009-10-07 23:48:56 +07:00
|
|
|
char *demangled = NULL;
|
2009-07-02 13:08:36 +07:00
|
|
|
int is_label = elf_sym__is_label(&sym);
|
|
|
|
const char *section_name;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-12-11 23:50:38 +07:00
|
|
|
if (!is_label && !elf_sym__is_a(&sym, map->type))
|
2009-05-29 00:55:04 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
sec = elf_getscn(elf, sym.st_shndx);
|
|
|
|
if (!sec)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
|
|
|
gelf_getshdr(sec, &shdr);
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-12-11 23:50:38 +07:00
|
|
|
if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
|
2009-07-02 13:08:36 +07:00
|
|
|
continue;
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
elf_name = elf_sym__name(&sym, symstrs);
|
2009-07-02 13:08:36 +07:00
|
|
|
section_name = elf_sec__name(&shdr, secstrs);
|
perf_counter tools: Add 'perf annotate' feature
Add new perf sub-command to display annotated source code:
$ perf annotate decode_tree_entry
------------------------------------------------
Percent | Source code & Disassembly of /home/mingo/git/git
------------------------------------------------
:
: /home/mingo/git/git: file format elf64-x86-64
:
:
: Disassembly of section .text:
:
: 00000000004a0da0 <decode_tree_entry>:
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
3.82 : 4a0da0: 41 54 push %r12
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.17 : 4a0da2: 48 83 fa 17 cmp $0x17,%rdx
: *modep = mode;
: return str;
: }
:
: static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
: {
0.00 : 4a0da6: 49 89 fc mov %rdi,%r12
0.00 : 4a0da9: 55 push %rbp
3.37 : 4a0daa: 53 push %rbx
: const char *path;
: unsigned int mode, len;
:
: if (size < 24 || buf[size - 21])
0.08 : 4a0dab: 76 73 jbe 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dad: 80 7c 16 eb 00 cmpb $0x0,-0x15(%rsi,%rdx,1)
3.48 : 4a0db2: 75 6c jne 4a0e20 <decode_tree_entry+0x80>
: static const char *get_mode(const char *str, unsigned int *modep)
: {
: unsigned char c;
: unsigned int mode = 0;
:
: if (*str == ' ')
1.94 : 4a0db4: 0f b6 06 movzbl (%rsi),%eax
0.39 : 4a0db7: 3c 20 cmp $0x20,%al
0.00 : 4a0db9: 74 65 je 4a0e20 <decode_tree_entry+0x80>
: return NULL;
:
: while ((c = *str++) != ' ') {
0.06 : 4a0dbb: 89 c2 mov %eax,%edx
: if (c < '0' || c > '7')
1.99 : 4a0dbd: 31 ed xor %ebp,%ebp
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
1.74 : 4a0dbf: 48 8d 5e 01 lea 0x1(%rsi),%rbx
: if (c < '0' || c > '7')
0.00 : 4a0dc3: 8d 42 d0 lea -0x30(%rdx),%eax
0.17 : 4a0dc6: 3c 07 cmp $0x7,%al
0.00 : 4a0dc8: 76 0d jbe 4a0dd7 <decode_tree_entry+0x37>
0.00 : 4a0dca: eb 54 jmp 4a0e20 <decode_tree_entry+0x80>
0.00 : 4a0dcc: 0f 1f 40 00 nopl 0x0(%rax)
16.57 : 4a0dd0: 8d 42 d0 lea -0x30(%rdx),%eax
0.14 : 4a0dd3: 3c 07 cmp $0x7,%al
0.00 : 4a0dd5: 77 49 ja 4a0e20 <decode_tree_entry+0x80>
: return NULL;
: mode = (mode << 3) + (c - '0');
3.12 : 4a0dd7: 0f b6 c2 movzbl %dl,%eax
: unsigned int mode = 0;
:
: if (*str == ' ')
: return NULL;
:
: while ((c = *str++) != ' ') {
0.00 : 4a0dda: 0f b6 13 movzbl (%rbx),%edx
16.74 : 4a0ddd: 48 83 c3 01 add $0x1,%rbx
: if (c < '0' || c > '7')
: return NULL;
: mode = (mode << 3) + (c - '0');
The first column is the percentage of samples that arrived on that
particular line - relative to the total cost of the function.
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-06 20:48:52 +07:00
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
if (kernel || kmodule) {
|
|
|
|
char dso_name[PATH_MAX];
|
|
|
|
|
|
|
|
if (strcmp(section_name,
|
|
|
|
curr_dso->short_name + dso_name_len) == 0)
|
|
|
|
goto new_symbol;
|
|
|
|
|
|
|
|
if (strcmp(section_name, ".text") == 0) {
|
|
|
|
curr_map = map;
|
|
|
|
curr_dso = self;
|
|
|
|
goto new_symbol;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(dso_name, sizeof(dso_name),
|
|
|
|
"%s%s", self->short_name, section_name);
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
curr_map = map_groups__find_by_name(mg, dso_name);
|
2009-10-07 23:48:56 +07:00
|
|
|
if (curr_map == NULL) {
|
|
|
|
u64 start = sym.st_value;
|
|
|
|
|
|
|
|
if (kmodule)
|
|
|
|
start += map->start + shdr.sh_offset;
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
curr_dso = dso__new(dso_name);
|
2009-10-07 23:48:56 +07:00
|
|
|
if (curr_dso == NULL)
|
|
|
|
goto out_elf_end;
|
2009-11-28 01:29:16 +07:00
|
|
|
curr_map = map__new2(start, curr_dso,
|
|
|
|
MAP__FUNCTION);
|
2009-10-07 23:48:56 +07:00
|
|
|
if (curr_map == NULL) {
|
|
|
|
dso__delete(curr_dso);
|
|
|
|
goto out_elf_end;
|
|
|
|
}
|
2009-10-20 02:17:57 +07:00
|
|
|
curr_map->map_ip = identity__map_ip;
|
|
|
|
curr_map->unmap_ip = identity__map_ip;
|
2009-10-07 23:48:56 +07:00
|
|
|
curr_dso->origin = DSO__ORIG_KERNEL;
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__insert(kmaps, curr_map);
|
2009-11-28 01:29:14 +07:00
|
|
|
dsos__add(&dsos__kernel, curr_dso);
|
2009-10-07 23:48:56 +07:00
|
|
|
} else
|
|
|
|
curr_dso = curr_map->dso;
|
|
|
|
|
|
|
|
goto new_symbol;
|
2009-10-06 00:26:17 +07:00
|
|
|
}
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
if (curr_dso->adjust_symbols) {
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
|
|
|
|
"%Lx sh_offset: %Lx\n", (u64)sym.st_value,
|
|
|
|
(u64)shdr.sh_addr, (u64)shdr.sh_offset);
|
2009-06-30 21:43:17 +07:00
|
|
|
sym.st_value -= shdr.sh_addr - shdr.sh_offset;
|
2009-10-06 00:26:17 +07:00
|
|
|
}
|
2009-07-21 00:14:12 +07:00
|
|
|
/*
|
|
|
|
* We need to figure out if the object was created from C++ sources
|
|
|
|
* DWARF DW_compile_unit has this, but we don't always have access
|
|
|
|
* to it...
|
|
|
|
*/
|
2009-08-15 17:26:57 +07:00
|
|
|
demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
|
2009-07-21 00:14:12 +07:00
|
|
|
if (demangled != NULL)
|
2009-08-15 17:26:57 +07:00
|
|
|
elf_name = demangled;
|
2009-10-07 23:48:56 +07:00
|
|
|
new_symbol:
|
2009-10-31 01:28:24 +07:00
|
|
|
f = symbol__new(sym.st_value, sym.st_size, elf_name);
|
2009-07-21 00:14:12 +07:00
|
|
|
free(demangled);
|
2009-05-29 00:55:04 +07:00
|
|
|
if (!f)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
if (filter && filter(curr_map, f))
|
2009-10-31 01:28:24 +07:00
|
|
|
symbol__delete(f);
|
2009-05-29 00:55:26 +07:00
|
|
|
else {
|
2009-11-28 01:29:17 +07:00
|
|
|
symbols__insert(&curr_dso->symbols[curr_map->type], f);
|
2009-05-29 00:55:26 +07:00
|
|
|
nr++;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2009-10-07 23:48:56 +07:00
|
|
|
/*
|
|
|
|
* For misannotated, zeroed, ASM function sizes.
|
|
|
|
*/
|
|
|
|
if (nr > 0)
|
2009-11-28 01:29:17 +07:00
|
|
|
symbols__fixup_end(&self->symbols[map->type]);
|
2009-05-29 00:55:04 +07:00
|
|
|
err = nr;
|
|
|
|
out_elf_end:
|
|
|
|
elf_end(elf);
|
|
|
|
out_close:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-11-21 05:51:26 +07:00
|
|
|
static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
|
|
|
|
{
|
|
|
|
return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
static bool __dsos__read_build_ids(struct list_head *head)
|
2009-11-11 10:51:04 +07:00
|
|
|
{
|
2009-11-19 05:20:51 +07:00
|
|
|
bool have_build_id = false;
|
2009-11-11 10:51:04 +07:00
|
|
|
struct dso *pos;
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
list_for_each_entry(pos, head, node)
|
2009-11-19 05:20:51 +07:00
|
|
|
if (filename__read_build_id(pos->long_name, pos->build_id,
|
|
|
|
sizeof(pos->build_id)) > 0) {
|
|
|
|
have_build_id = true;
|
|
|
|
pos->has_build_id = true;
|
|
|
|
}
|
2009-11-11 10:51:04 +07:00
|
|
|
|
2009-11-19 05:20:51 +07:00
|
|
|
return have_build_id;
|
2009-11-11 10:51:04 +07:00
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
bool dsos__read_build_ids(void)
|
|
|
|
{
|
2009-12-10 05:09:37 +07:00
|
|
|
bool kbuildids = __dsos__read_build_ids(&dsos__kernel),
|
|
|
|
ubuildids = __dsos__read_build_ids(&dsos__user);
|
|
|
|
return kbuildids || ubuildids;
|
2009-11-28 01:29:14 +07:00
|
|
|
}
|
|
|
|
|
2009-11-21 05:51:25 +07:00
|
|
|
/*
|
|
|
|
* Align offset to 4 bytes as needed for note name and descriptor data.
|
|
|
|
*/
|
|
|
|
#define NOTE_ALIGN(n) (((n) + 3) & -4U)
|
|
|
|
|
2009-11-04 06:46:10 +07:00
|
|
|
int filename__read_build_id(const char *filename, void *bf, size_t size)
|
2009-08-06 05:02:49 +07:00
|
|
|
{
|
2009-11-04 06:46:10 +07:00
|
|
|
int fd, err = -1;
|
2009-08-06 05:02:49 +07:00
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
2009-11-21 05:51:25 +07:00
|
|
|
Elf_Data *data;
|
2009-08-06 05:02:49 +07:00
|
|
|
Elf_Scn *sec;
|
2009-11-22 17:29:44 +07:00
|
|
|
Elf_Kind ek;
|
2009-11-21 05:51:25 +07:00
|
|
|
void *ptr;
|
2009-08-06 05:02:49 +07:00
|
|
|
Elf *elf;
|
|
|
|
|
2009-11-04 06:46:10 +07:00
|
|
|
if (size < BUILD_ID_SIZE)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
fd = open(filename, O_RDONLY);
|
2009-08-06 05:02:49 +07:00
|
|
|
if (fd < 0)
|
|
|
|
goto out;
|
|
|
|
|
2009-10-24 23:10:36 +07:00
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
2009-08-06 05:02:49 +07:00
|
|
|
if (elf == NULL) {
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
|
2009-08-06 05:02:49 +07:00
|
|
|
goto out_close;
|
|
|
|
}
|
|
|
|
|
2009-11-22 17:29:44 +07:00
|
|
|
ek = elf_kind(elf);
|
|
|
|
if (ek != ELF_K_ELF)
|
|
|
|
goto out_elf_end;
|
|
|
|
|
2009-08-06 05:02:49 +07:00
|
|
|
if (gelf_getehdr(elf, &ehdr) == NULL) {
|
2009-10-22 02:34:06 +07:00
|
|
|
pr_err("%s: cannot get elf header.\n", __func__);
|
2009-08-06 05:02:49 +07:00
|
|
|
goto out_elf_end;
|
|
|
|
}
|
|
|
|
|
2009-11-04 06:46:10 +07:00
|
|
|
sec = elf_section_by_name(elf, &ehdr, &shdr,
|
|
|
|
".note.gnu.build-id", NULL);
|
2009-11-21 05:51:25 +07:00
|
|
|
if (sec == NULL) {
|
|
|
|
sec = elf_section_by_name(elf, &ehdr, &shdr,
|
|
|
|
".notes", NULL);
|
|
|
|
if (sec == NULL)
|
|
|
|
goto out_elf_end;
|
|
|
|
}
|
2009-08-06 05:02:49 +07:00
|
|
|
|
2009-11-21 05:51:25 +07:00
|
|
|
data = elf_getdata(sec, NULL);
|
|
|
|
if (data == NULL)
|
2009-08-06 05:02:49 +07:00
|
|
|
goto out_elf_end;
|
2009-11-21 05:51:25 +07:00
|
|
|
|
|
|
|
ptr = data->d_buf;
|
|
|
|
while (ptr < (data->d_buf + data->d_size)) {
|
|
|
|
GElf_Nhdr *nhdr = ptr;
|
|
|
|
int namesz = NOTE_ALIGN(nhdr->n_namesz),
|
|
|
|
descsz = NOTE_ALIGN(nhdr->n_descsz);
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
ptr += sizeof(*nhdr);
|
|
|
|
name = ptr;
|
|
|
|
ptr += namesz;
|
|
|
|
if (nhdr->n_type == NT_GNU_BUILD_ID &&
|
|
|
|
nhdr->n_namesz == sizeof("GNU")) {
|
|
|
|
if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
|
|
|
|
memcpy(bf, ptr, BUILD_ID_SIZE);
|
|
|
|
err = BUILD_ID_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ptr += descsz;
|
|
|
|
}
|
2009-11-04 06:46:10 +07:00
|
|
|
out_elf_end:
|
|
|
|
elf_end(elf);
|
|
|
|
out_close:
|
|
|
|
close(fd);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-11-19 05:20:52 +07:00
|
|
|
int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
|
|
|
|
{
|
|
|
|
int fd, err = -1;
|
|
|
|
|
|
|
|
if (size < BUILD_ID_SIZE)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
char bf[BUFSIZ];
|
|
|
|
GElf_Nhdr nhdr;
|
|
|
|
int namesz, descsz;
|
|
|
|
|
|
|
|
if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
|
|
|
|
break;
|
|
|
|
|
2009-11-21 05:51:25 +07:00
|
|
|
namesz = NOTE_ALIGN(nhdr.n_namesz);
|
|
|
|
descsz = NOTE_ALIGN(nhdr.n_descsz);
|
2009-11-19 05:20:52 +07:00
|
|
|
if (nhdr.n_type == NT_GNU_BUILD_ID &&
|
|
|
|
nhdr.n_namesz == sizeof("GNU")) {
|
|
|
|
if (read(fd, bf, namesz) != namesz)
|
|
|
|
break;
|
|
|
|
if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
|
|
|
|
if (read(fd, build_id,
|
|
|
|
BUILD_ID_SIZE) == BUILD_ID_SIZE) {
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (read(fd, bf, descsz) != descsz)
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
int n = namesz + descsz;
|
|
|
|
if (read(fd, bf, n) != n)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-08-07 00:43:17 +07:00
|
|
|
char dso__symtab_origin(const struct dso *self)
|
|
|
|
{
|
|
|
|
static const char origin[] = {
|
|
|
|
[DSO__ORIG_KERNEL] = 'k',
|
|
|
|
[DSO__ORIG_JAVA_JIT] = 'j',
|
|
|
|
[DSO__ORIG_FEDORA] = 'f',
|
|
|
|
[DSO__ORIG_UBUNTU] = 'u',
|
|
|
|
[DSO__ORIG_BUILDID] = 'b',
|
|
|
|
[DSO__ORIG_DSO] = 'd',
|
2009-10-02 13:29:58 +07:00
|
|
|
[DSO__ORIG_KMODULE] = 'K',
|
2009-08-07 00:43:17 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
|
|
|
|
return '!';
|
|
|
|
return origin[self->origin];
|
|
|
|
}
|
|
|
|
|
2009-10-22 02:34:06 +07:00
|
|
|
int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-08-06 05:02:49 +07:00
|
|
|
int size = PATH_MAX;
|
2009-11-21 05:51:27 +07:00
|
|
|
char *name;
|
2009-11-19 05:20:50 +07:00
|
|
|
u8 build_id[BUILD_ID_SIZE];
|
2009-05-29 00:55:04 +07:00
|
|
|
int ret = -1;
|
|
|
|
int fd;
|
|
|
|
|
2009-11-28 01:29:16 +07:00
|
|
|
dso__set_loaded(self, map->type);
|
2009-10-29 06:51:21 +07:00
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
if (self->kernel)
|
2009-12-11 23:50:36 +07:00
|
|
|
return dso__load_kernel_sym(self, map, kmaps, filter);
|
2009-11-21 05:51:27 +07:00
|
|
|
|
|
|
|
name = malloc(size);
|
2009-05-29 00:55:04 +07:00
|
|
|
if (!name)
|
|
|
|
return -1;
|
|
|
|
|
2009-07-03 07:24:14 +07:00
|
|
|
self->adjust_symbols = 0;
|
2009-06-30 21:43:17 +07:00
|
|
|
|
2009-08-07 00:43:17 +07:00
|
|
|
if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
|
2009-10-22 02:34:06 +07:00
|
|
|
ret = dso__load_perf_map(self, map, filter);
|
2009-08-07 00:43:17 +07:00
|
|
|
self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
|
|
|
|
DSO__ORIG_NOT_FOUND;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
self->origin = DSO__ORIG_FEDORA - 1;
|
2009-06-09 01:12:48 +07:00
|
|
|
|
2009-05-29 00:55:04 +07:00
|
|
|
more:
|
|
|
|
do {
|
2009-08-07 00:43:17 +07:00
|
|
|
self->origin++;
|
|
|
|
switch (self->origin) {
|
|
|
|
case DSO__ORIG_FEDORA:
|
2009-10-02 13:29:58 +07:00
|
|
|
snprintf(name, size, "/usr/lib/debug%s.debug",
|
|
|
|
self->long_name);
|
2009-05-29 00:55:04 +07:00
|
|
|
break;
|
2009-08-07 00:43:17 +07:00
|
|
|
case DSO__ORIG_UBUNTU:
|
2009-10-02 13:29:58 +07:00
|
|
|
snprintf(name, size, "/usr/lib/debug%s",
|
|
|
|
self->long_name);
|
2009-05-29 00:55:04 +07:00
|
|
|
break;
|
2009-08-07 00:43:17 +07:00
|
|
|
case DSO__ORIG_BUILDID:
|
2009-11-19 05:20:50 +07:00
|
|
|
if (filename__read_build_id(self->long_name, build_id,
|
|
|
|
sizeof(build_id))) {
|
|
|
|
char build_id_hex[BUILD_ID_SIZE * 2 + 1];
|
|
|
|
|
|
|
|
build_id__sprintf(build_id, sizeof(build_id),
|
|
|
|
build_id_hex);
|
2009-08-06 05:02:49 +07:00
|
|
|
snprintf(name, size,
|
|
|
|
"/usr/lib/debug/.build-id/%.2s/%s.debug",
|
2009-11-19 05:20:50 +07:00
|
|
|
build_id_hex, build_id_hex + 2);
|
|
|
|
if (self->has_build_id)
|
|
|
|
goto compare_build_id;
|
|
|
|
break;
|
2009-08-06 05:02:49 +07:00
|
|
|
}
|
2009-08-07 00:43:17 +07:00
|
|
|
self->origin++;
|
2009-08-06 05:02:49 +07:00
|
|
|
/* Fall thru */
|
2009-08-07 00:43:17 +07:00
|
|
|
case DSO__ORIG_DSO:
|
2009-10-02 13:29:58 +07:00
|
|
|
snprintf(name, size, "%s", self->long_name);
|
2009-05-29 00:55:04 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
if (self->has_build_id) {
|
2009-11-19 05:20:50 +07:00
|
|
|
if (filename__read_build_id(name, build_id,
|
|
|
|
sizeof(build_id)) < 0)
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
goto more;
|
|
|
|
compare_build_id:
|
2009-11-21 05:51:26 +07:00
|
|
|
if (!dso__build_id_equal(self, build_id))
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 03:50:43 +07:00
|
|
|
goto more;
|
|
|
|
}
|
|
|
|
|
2009-05-29 00:55:04 +07:00
|
|
|
fd = open(name, O_RDONLY);
|
|
|
|
} while (fd < 0);
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
ret = dso__load_sym(self, map, NULL, name, fd, filter, 0, 0);
|
2009-05-29 00:55:04 +07:00
|
|
|
close(fd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
|
|
|
|
*/
|
|
|
|
if (!ret)
|
|
|
|
goto more;
|
|
|
|
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
if (ret > 0) {
|
2009-11-16 22:48:11 +07:00
|
|
|
int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
|
perf_counter tools: PLT info is stripped in -debuginfo packages
So we need to get the richer .symtab from the debuginfo
packages but the PLT info from the original DSO where we have
just the leaner .dynsym symtab.
Example:
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > before
| [acme@doppio pahole]$ perf report --sort comm,dso,symbol > after
| [acme@doppio pahole]$ diff -U1 before after
| --- before 2009-07-11 11:04:22.688595741 -0300
| +++ after 2009-07-11 11:04:33.380595676 -0300
| @@ -80,3 +80,2 @@
| 0.07% pahole ./build/pahole [.] pahole_stealer
| - 0.06% pahole /usr/lib64/libdw-0.141.so [.] 0x00000000007140
| 0.06% pahole /usr/lib64/libdw-0.141.so [.] __libdw_getabbrev
| @@ -91,2 +90,3 @@
| 0.06% pahole [kernel] [k] free_hot_cold_page
| + 0.06% pahole /usr/lib64/libdw-0.141.so [.] tfind@plt
| 0.05% pahole ./build/libdwarves.so.1.0.0 [.] ftype__add_parameter
| @@ -242,2 +242,3 @@
| 0.01% pahole [kernel] [k] account_group_user_time
| + 0.01% pahole /usr/lib64/libdw-0.141.so [.] strlen@plt
| 0.01% pahole ./build/pahole [.] strcmp@plt
| [acme@doppio pahole]$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <1247325517-12272-4-git-send-email-acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-07-11 22:18:36 +07:00
|
|
|
if (nr_plt > 0)
|
|
|
|
ret += nr_plt;
|
|
|
|
}
|
2009-05-29 00:55:04 +07:00
|
|
|
out:
|
|
|
|
free(name);
|
2009-08-12 03:04:36 +07:00
|
|
|
if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
|
|
|
|
return 0;
|
2009-05-29 00:55:04 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static struct map *map_groups__find_by_name(struct map_groups *self, char *name)
|
2009-10-02 13:29:58 +07:00
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
for (nd = rb_first(&self->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
|
2009-10-02 13:29:58 +07:00
|
|
|
struct map *map = rb_entry(nd, struct map, rb_node);
|
|
|
|
|
|
|
|
if (map->dso && strcmp(map->dso->name, name) == 0)
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
static int dsos__set_modules_path_dir(char *dirname)
|
2009-07-02 13:08:36 +07:00
|
|
|
{
|
2009-10-02 13:29:58 +07:00
|
|
|
struct dirent *dent;
|
|
|
|
DIR *dir = opendir(dirname);
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
if (!dir) {
|
2009-11-22 22:21:41 +07:00
|
|
|
pr_debug("%s: cannot open %s dir\n", __func__, dirname);
|
2009-10-02 13:29:58 +07:00
|
|
|
return -1;
|
|
|
|
}
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
while ((dent = readdir(dir)) != NULL) {
|
|
|
|
char path[PATH_MAX];
|
|
|
|
|
|
|
|
if (dent->d_type == DT_DIR) {
|
|
|
|
if (!strcmp(dent->d_name, ".") ||
|
|
|
|
!strcmp(dent->d_name, ".."))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
snprintf(path, sizeof(path), "%s/%s",
|
|
|
|
dirname, dent->d_name);
|
2009-11-21 05:51:27 +07:00
|
|
|
if (dsos__set_modules_path_dir(path) < 0)
|
2009-10-02 13:29:58 +07:00
|
|
|
goto failure;
|
|
|
|
} else {
|
|
|
|
char *dot = strrchr(dent->d_name, '.'),
|
|
|
|
dso_name[PATH_MAX];
|
|
|
|
struct map *map;
|
2009-11-18 00:40:53 +07:00
|
|
|
char *long_name;
|
2009-10-02 13:29:58 +07:00
|
|
|
|
|
|
|
if (dot == NULL || strcmp(dot, ".ko"))
|
|
|
|
continue;
|
|
|
|
snprintf(dso_name, sizeof(dso_name), "[%.*s]",
|
|
|
|
(int)(dot - dent->d_name), dent->d_name);
|
|
|
|
|
2009-10-06 00:26:18 +07:00
|
|
|
strxfrchar(dso_name, '-', '_');
|
2009-12-11 23:50:36 +07:00
|
|
|
map = map_groups__find_by_name(kmaps, dso_name);
|
2009-10-02 13:29:58 +07:00
|
|
|
if (map == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
snprintf(path, sizeof(path), "%s/%s",
|
|
|
|
dirname, dent->d_name);
|
|
|
|
|
2009-11-18 00:40:53 +07:00
|
|
|
long_name = strdup(path);
|
|
|
|
if (long_name == NULL)
|
2009-10-02 13:29:58 +07:00
|
|
|
goto failure;
|
2009-11-18 00:40:53 +07:00
|
|
|
dso__set_long_name(map->dso, long_name);
|
2009-10-02 13:29:58 +07:00
|
|
|
}
|
|
|
|
}
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
return 0;
|
2009-10-02 13:29:58 +07:00
|
|
|
failure:
|
|
|
|
closedir(dir);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
static int dsos__set_modules_path(void)
|
2009-10-02 13:29:58 +07:00
|
|
|
{
|
|
|
|
struct utsname uts;
|
|
|
|
char modules_path[PATH_MAX];
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
if (uname(&uts) < 0)
|
|
|
|
return -1;
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
|
|
|
|
uts.release);
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
return dsos__set_modules_path_dir(modules_path);
|
2009-07-02 13:08:36 +07:00
|
|
|
}
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
/*
|
|
|
|
* Constructor variant for modules (where we know from /proc/modules where
|
|
|
|
* they are loaded) and for vmlinux, where only after we load all the
|
|
|
|
* symbols we'll know where it starts and ends.
|
|
|
|
*/
|
2009-11-28 01:29:16 +07:00
|
|
|
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
|
2009-07-02 13:08:36 +07:00
|
|
|
{
|
2009-10-02 13:29:58 +07:00
|
|
|
struct map *self = malloc(sizeof(*self));
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
if (self != NULL) {
|
|
|
|
/*
|
2009-10-31 01:28:23 +07:00
|
|
|
* ->end will be filled after we load all the symbols
|
2009-10-02 13:29:58 +07:00
|
|
|
*/
|
2009-11-28 01:29:16 +07:00
|
|
|
map__init(self, type, start, 0, 0, dso);
|
2009-10-02 13:29:58 +07:00
|
|
|
}
|
2009-10-31 01:28:23 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static int map_groups__create_module_maps(struct map_groups *self)
|
2009-10-02 13:29:58 +07:00
|
|
|
{
|
|
|
|
char *line = NULL;
|
|
|
|
size_t n;
|
|
|
|
FILE *file = fopen("/proc/modules", "r");
|
|
|
|
struct map *map;
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
if (file == NULL)
|
|
|
|
return -1;
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
while (!feof(file)) {
|
|
|
|
char name[PATH_MAX];
|
|
|
|
u64 start;
|
|
|
|
struct dso *dso;
|
|
|
|
char *sep;
|
|
|
|
int line_len;
|
2009-07-02 13:08:36 +07:00
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
line_len = getline(&line, &n, file);
|
|
|
|
if (line_len < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!line)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
line[--line_len] = '\0'; /* \n */
|
|
|
|
|
|
|
|
sep = strrchr(line, 'x');
|
|
|
|
if (sep == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hex2u64(sep + 1, &start);
|
|
|
|
|
|
|
|
sep = strchr(line, ' ');
|
|
|
|
if (sep == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
*sep = '\0';
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "[%s]", line);
|
2009-10-31 01:28:24 +07:00
|
|
|
dso = dso__new(name);
|
2009-10-02 13:29:58 +07:00
|
|
|
|
|
|
|
if (dso == NULL)
|
|
|
|
goto out_delete_line;
|
|
|
|
|
2009-11-28 01:29:16 +07:00
|
|
|
map = map__new2(start, dso, MAP__FUNCTION);
|
2009-10-02 13:29:58 +07:00
|
|
|
if (map == NULL) {
|
|
|
|
dso__delete(dso);
|
|
|
|
goto out_delete_line;
|
2009-07-02 13:08:36 +07:00
|
|
|
}
|
2009-10-02 13:29:58 +07:00
|
|
|
|
2009-11-19 05:20:52 +07:00
|
|
|
snprintf(name, sizeof(name),
|
|
|
|
"/sys/module/%s/notes/.note.gnu.build-id", line);
|
|
|
|
if (sysfs__read_build_id(name, dso->build_id,
|
|
|
|
sizeof(dso->build_id)) == 0)
|
|
|
|
dso->has_build_id = true;
|
|
|
|
|
2009-10-02 13:29:58 +07:00
|
|
|
dso->origin = DSO__ORIG_KMODULE;
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__insert(self, map);
|
2009-11-28 01:29:14 +07:00
|
|
|
dsos__add(&dsos__kernel, dso);
|
2009-07-02 13:08:36 +07:00
|
|
|
}
|
2009-10-02 13:29:58 +07:00
|
|
|
|
|
|
|
free(line);
|
|
|
|
fclose(file);
|
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
return dsos__set_modules_path();
|
2009-10-02 13:29:58 +07:00
|
|
|
|
|
|
|
out_delete_line:
|
|
|
|
free(line);
|
|
|
|
out_failure:
|
|
|
|
return -1;
|
2009-07-02 13:08:36 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static int dso__load_vmlinux(struct dso *self, struct map *map,
|
|
|
|
struct map_groups *mg,
|
2009-10-22 02:34:06 +07:00
|
|
|
const char *vmlinux, symbol_filter_t filter)
|
2009-05-29 00:55:04 +07:00
|
|
|
{
|
2009-11-21 05:51:28 +07:00
|
|
|
int err = -1, fd;
|
2009-05-29 00:55:04 +07:00
|
|
|
|
2009-11-21 05:51:28 +07:00
|
|
|
if (self->has_build_id) {
|
|
|
|
u8 build_id[BUILD_ID_SIZE];
|
|
|
|
|
|
|
|
if (filename__read_build_id(vmlinux, build_id,
|
|
|
|
sizeof(build_id)) < 0) {
|
|
|
|
pr_debug("No build_id in %s, ignoring it\n", vmlinux);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!dso__build_id_equal(self, build_id)) {
|
|
|
|
char expected_build_id[BUILD_ID_SIZE * 2 + 1],
|
|
|
|
vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
|
|
|
|
|
|
|
|
build_id__sprintf(self->build_id,
|
|
|
|
sizeof(self->build_id),
|
|
|
|
expected_build_id);
|
|
|
|
build_id__sprintf(build_id, sizeof(build_id),
|
|
|
|
vmlinux_build_id);
|
|
|
|
pr_debug("build_id in %s is %s while expected is %s, "
|
|
|
|
"ignoring it\n", vmlinux, vmlinux_build_id,
|
|
|
|
expected_build_id);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2009-10-29 06:51:21 +07:00
|
|
|
|
2009-11-21 05:51:28 +07:00
|
|
|
fd = open(vmlinux, O_RDONLY);
|
2009-05-29 00:55:04 +07:00
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
|
2009-11-28 01:29:16 +07:00
|
|
|
dso__set_loaded(self, map->type);
|
2009-12-11 23:50:36 +07:00
|
|
|
err = dso__load_sym(self, map, mg, self->long_name, fd, filter, 1, 0);
|
2009-05-29 00:55:04 +07:00
|
|
|
close(fd);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
static int dso__load_kernel_sym(struct dso *self, struct map *map,
|
2009-12-11 23:50:36 +07:00
|
|
|
struct map_groups *mg, symbol_filter_t filter)
|
2009-05-29 00:55:19 +07:00
|
|
|
{
|
2009-11-24 01:39:10 +07:00
|
|
|
int err;
|
|
|
|
bool is_kallsyms;
|
|
|
|
|
|
|
|
if (vmlinux_path != NULL) {
|
|
|
|
int i;
|
|
|
|
pr_debug("Looking at the vmlinux_path (%d entries long)\n",
|
|
|
|
vmlinux_path__nr_entries);
|
|
|
|
for (i = 0; i < vmlinux_path__nr_entries; ++i) {
|
2009-12-11 23:50:36 +07:00
|
|
|
err = dso__load_vmlinux(self, map, mg,
|
2009-11-28 01:29:20 +07:00
|
|
|
vmlinux_path[i], filter);
|
2009-11-24 01:39:10 +07:00
|
|
|
if (err > 0) {
|
|
|
|
pr_debug("Using %s for symbols\n",
|
|
|
|
vmlinux_path[i]);
|
|
|
|
dso__set_long_name(self,
|
|
|
|
strdup(vmlinux_path[i]));
|
|
|
|
goto out_fixup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
is_kallsyms = self->long_name[0] == '[';
|
|
|
|
if (is_kallsyms)
|
|
|
|
goto do_kallsyms;
|
2009-10-02 13:29:58 +07:00
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
err = dso__load_vmlinux(self, map, mg, self->long_name, filter);
|
2009-11-21 05:51:29 +07:00
|
|
|
if (err <= 0) {
|
2009-11-24 01:39:10 +07:00
|
|
|
pr_info("The file %s cannot be used, "
|
|
|
|
"trying to use /proc/kallsyms...", self->long_name);
|
|
|
|
do_kallsyms:
|
2009-12-11 23:50:36 +07:00
|
|
|
err = dso__load_kallsyms(self, map, mg, filter);
|
2009-11-24 01:39:10 +07:00
|
|
|
if (err > 0 && !is_kallsyms)
|
2009-11-21 05:51:29 +07:00
|
|
|
dso__set_long_name(self, strdup("[kernel.kallsyms]"));
|
|
|
|
}
|
2009-10-02 13:29:58 +07:00
|
|
|
|
|
|
|
if (err > 0) {
|
2009-11-24 01:39:10 +07:00
|
|
|
out_fixup:
|
2009-11-28 01:29:17 +07:00
|
|
|
map__fixup_start(map);
|
|
|
|
map__fixup_end(map);
|
2009-10-02 13:29:58 +07:00
|
|
|
}
|
2009-08-07 00:43:17 +07:00
|
|
|
|
2009-05-29 00:55:19 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
LIST_HEAD(dsos__user);
|
|
|
|
LIST_HEAD(dsos__kernel);
|
2009-11-24 01:39:10 +07:00
|
|
|
struct dso *vdso;
|
2009-08-12 15:03:49 +07:00
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
static void dsos__add(struct list_head *head, struct dso *dso)
|
2009-08-12 15:03:49 +07:00
|
|
|
{
|
2009-11-28 01:29:14 +07:00
|
|
|
list_add_tail(&dso->node, head);
|
2009-08-12 15:03:49 +07:00
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
static struct dso *dsos__find(struct list_head *head, const char *name)
|
2009-08-12 15:03:49 +07:00
|
|
|
{
|
|
|
|
struct dso *pos;
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
list_for_each_entry(pos, head, node)
|
2009-08-12 15:03:49 +07:00
|
|
|
if (strcmp(pos->name, name) == 0)
|
|
|
|
return pos;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
struct dso *dsos__findnew(const char *name)
|
2009-08-12 15:03:49 +07:00
|
|
|
{
|
2009-11-28 01:29:14 +07:00
|
|
|
struct dso *dso = dsos__find(&dsos__user, name);
|
2009-08-12 15:03:49 +07:00
|
|
|
|
2009-10-20 23:25:40 +07:00
|
|
|
if (!dso) {
|
2009-10-31 01:28:24 +07:00
|
|
|
dso = dso__new(name);
|
2009-11-18 00:40:53 +07:00
|
|
|
if (dso != NULL) {
|
2009-11-28 01:29:14 +07:00
|
|
|
dsos__add(&dsos__user, dso);
|
2009-11-18 00:40:53 +07:00
|
|
|
dso__set_basename(dso);
|
|
|
|
}
|
2009-10-29 06:51:21 +07:00
|
|
|
}
|
2009-08-12 15:03:49 +07:00
|
|
|
|
|
|
|
return dso;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
static void __dsos__fprintf(struct list_head *head, FILE *fp)
|
2009-08-12 15:03:49 +07:00
|
|
|
{
|
|
|
|
struct dso *pos;
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
list_for_each_entry(pos, head, node) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < MAP__NR_TYPES; ++i)
|
|
|
|
dso__fprintf(pos, i, fp);
|
|
|
|
}
|
2009-08-12 15:03:49 +07:00
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
void dsos__fprintf(FILE *fp)
|
|
|
|
{
|
|
|
|
__dsos__fprintf(&dsos__kernel, fp);
|
|
|
|
__dsos__fprintf(&dsos__user, fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp)
|
2009-11-17 01:32:44 +07:00
|
|
|
{
|
|
|
|
struct dso *pos;
|
|
|
|
size_t ret = 0;
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
list_for_each_entry(pos, head, node) {
|
2009-11-17 01:32:44 +07:00
|
|
|
ret += dso__fprintf_buildid(pos, fp);
|
2009-11-17 06:45:25 +07:00
|
|
|
ret += fprintf(fp, " %s\n", pos->long_name);
|
2009-11-17 01:32:44 +07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:14 +07:00
|
|
|
size_t dsos__fprintf_buildid(FILE *fp)
|
|
|
|
{
|
|
|
|
return (__dsos__fprintf_buildid(&dsos__kernel, fp) +
|
|
|
|
__dsos__fprintf_buildid(&dsos__user, fp));
|
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
static int map_groups__create_kernel_map(struct map_groups *self, const char *vmlinux)
|
2009-08-12 15:03:49 +07:00
|
|
|
{
|
2009-11-28 01:29:18 +07:00
|
|
|
struct map *kmap;
|
2009-11-28 01:29:20 +07:00
|
|
|
struct dso *kernel = dso__new(vmlinux ?: "[kernel.kallsyms]");
|
2009-08-12 15:03:49 +07:00
|
|
|
|
2009-11-19 05:20:53 +07:00
|
|
|
if (kernel == NULL)
|
2009-11-21 05:51:27 +07:00
|
|
|
return -1;
|
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
kmap = map__new2(0, kernel, MAP__FUNCTION);
|
|
|
|
if (kmap == NULL)
|
2009-11-21 05:51:27 +07:00
|
|
|
goto out_delete_kernel_dso;
|
|
|
|
|
2009-11-28 01:29:18 +07:00
|
|
|
kmap->map_ip = kmap->unmap_ip = identity__map_ip;
|
|
|
|
kernel->short_name = "[kernel]";
|
|
|
|
kernel->kernel = 1;
|
2009-11-19 05:20:53 +07:00
|
|
|
|
2009-10-31 01:28:24 +07:00
|
|
|
vdso = dso__new("[vdso]");
|
2009-11-21 05:51:27 +07:00
|
|
|
if (vdso == NULL)
|
|
|
|
goto out_delete_kernel_map;
|
2009-11-28 01:29:16 +07:00
|
|
|
dso__set_loaded(vdso, MAP__FUNCTION);
|
2009-11-19 05:20:53 +07:00
|
|
|
|
|
|
|
if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
|
|
|
|
sizeof(kernel->build_id)) == 0)
|
|
|
|
kernel->has_build_id = true;
|
2009-08-12 15:03:49 +07:00
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__insert(self, kmap);
|
2009-11-28 01:29:14 +07:00
|
|
|
dsos__add(&dsos__kernel, kernel);
|
|
|
|
dsos__add(&dsos__user, vdso);
|
2009-08-12 15:03:49 +07:00
|
|
|
|
2009-11-21 05:51:27 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_delete_kernel_map:
|
2009-11-28 01:29:18 +07:00
|
|
|
map__delete(kmap);
|
2009-11-21 05:51:27 +07:00
|
|
|
out_delete_kernel_dso:
|
|
|
|
dso__delete(kernel);
|
|
|
|
return -1;
|
2009-11-19 05:20:53 +07:00
|
|
|
}
|
|
|
|
|
2009-11-24 01:39:10 +07:00
|
|
|
static void vmlinux_path__exit(void)
|
|
|
|
{
|
|
|
|
while (--vmlinux_path__nr_entries >= 0) {
|
|
|
|
free(vmlinux_path[vmlinux_path__nr_entries]);
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(vmlinux_path);
|
|
|
|
vmlinux_path = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmlinux_path__init(void)
|
|
|
|
{
|
|
|
|
struct utsname uts;
|
|
|
|
char bf[PATH_MAX];
|
|
|
|
|
|
|
|
if (uname(&uts) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
vmlinux_path = malloc(sizeof(char *) * 5);
|
|
|
|
if (vmlinux_path == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
|
|
|
|
if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
|
|
|
|
goto out_fail;
|
|
|
|
++vmlinux_path__nr_entries;
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
|
|
|
|
if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
|
|
|
|
goto out_fail;
|
|
|
|
++vmlinux_path__nr_entries;
|
|
|
|
snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
|
|
|
|
if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
|
|
|
|
goto out_fail;
|
|
|
|
++vmlinux_path__nr_entries;
|
|
|
|
snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
|
|
|
|
if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
|
|
|
|
goto out_fail;
|
|
|
|
++vmlinux_path__nr_entries;
|
|
|
|
snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
|
|
|
|
uts.release);
|
|
|
|
vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
|
|
|
|
if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
|
|
|
|
goto out_fail;
|
|
|
|
++vmlinux_path__nr_entries;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_fail:
|
|
|
|
vmlinux_path__exit();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
int symbol__init(struct symbol_conf *conf)
|
2009-11-19 05:20:53 +07:00
|
|
|
{
|
2009-11-24 21:05:15 +07:00
|
|
|
const struct symbol_conf *pconf = conf ?: &symbol_conf__defaults;
|
|
|
|
|
2009-11-28 01:29:20 +07:00
|
|
|
elf_version(EV_CURRENT);
|
2009-11-24 21:05:15 +07:00
|
|
|
symbol__priv_size = pconf->priv_size;
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__init(kmaps);
|
2009-11-24 21:05:15 +07:00
|
|
|
|
|
|
|
if (pconf->try_vmlinux_path && vmlinux_path__init() < 0)
|
2009-11-19 05:20:53 +07:00
|
|
|
return -1;
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
if (map_groups__create_kernel_map(kmaps, pconf->vmlinux_name) < 0) {
|
2009-11-24 01:39:10 +07:00
|
|
|
vmlinux_path__exit();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-11 23:50:36 +07:00
|
|
|
kmaps->use_modules = pconf->use_modules;
|
|
|
|
if (pconf->use_modules && map_groups__create_module_maps(kmaps) < 0)
|
2009-11-22 22:21:41 +07:00
|
|
|
pr_debug("Failed to load list of modules in use, "
|
|
|
|
"continuing...\n");
|
2009-11-21 23:31:24 +07:00
|
|
|
/*
|
|
|
|
* Now that we have all the maps created, just set the ->end of them:
|
|
|
|
*/
|
2009-12-11 23:50:36 +07:00
|
|
|
map_groups__fixup_end(kmaps);
|
2009-11-21 05:51:24 +07:00
|
|
|
return 0;
|
2009-08-12 15:03:49 +07:00
|
|
|
}
|