2009-10-09 01:17:38 +04:00
|
|
|
/*
|
|
|
|
* probe-finder.c : C expression to kprobe event converter
|
|
|
|
*
|
|
|
|
* Written by Masami Hiramatsu <mhiramat@redhat.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/utsname.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdarg.h>
|
2010-04-20 10:58:32 +04:00
|
|
|
#include <dwarf-regs.h>
|
2009-10-17 04:08:01 +04:00
|
|
|
|
2011-02-04 15:52:11 +03:00
|
|
|
#include <linux/bitops.h>
|
2009-10-17 04:08:10 +04:00
|
|
|
#include "event.h"
|
2014-02-06 09:32:27 +04:00
|
|
|
#include "dso.h"
|
2009-10-17 04:08:10 +04:00
|
|
|
#include "debug.h"
|
2014-02-06 09:32:09 +04:00
|
|
|
#include "intlist.h"
|
2009-10-17 04:08:01 +04:00
|
|
|
#include "util.h"
|
2010-06-14 23:26:30 +04:00
|
|
|
#include "symbol.h"
|
2009-10-09 01:17:38 +04:00
|
|
|
#include "probe-finder.h"
|
|
|
|
|
2010-04-12 21:17:15 +04:00
|
|
|
/* Kprobe tracer basic type is up to u64 */
|
|
|
|
#define MAX_BASIC_TYPE_BITS 64
|
|
|
|
|
2010-10-21 14:13:41 +04:00
|
|
|
/* Dwarf FL wrappers */
|
|
|
|
static char *debuginfo_path; /* Currently dummy */
|
|
|
|
|
|
|
|
static const Dwfl_Callbacks offline_callbacks = {
|
|
|
|
.find_debuginfo = dwfl_standard_find_debuginfo,
|
|
|
|
.debuginfo_path = &debuginfo_path,
|
|
|
|
|
|
|
|
.section_address = dwfl_offline_section_address,
|
|
|
|
|
|
|
|
/* We use this table for core files too. */
|
|
|
|
.find_elf = dwfl_build_id_find_elf,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Get a Dwarf from offline image */
|
2013-11-05 22:32:36 +04:00
|
|
|
static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
|
2011-06-27 11:27:39 +04:00
|
|
|
const char *path)
|
2010-10-21 14:13:41 +04:00
|
|
|
{
|
2011-06-27 11:27:39 +04:00
|
|
|
int fd;
|
2010-10-21 14:13:41 +04:00
|
|
|
|
2011-06-27 11:27:39 +04:00
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return fd;
|
2010-10-21 14:13:41 +04:00
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
dbg->dwfl = dwfl_begin(&offline_callbacks);
|
|
|
|
if (!dbg->dwfl)
|
2011-06-27 11:27:39 +04:00
|
|
|
goto error;
|
2010-10-21 14:13:41 +04:00
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
|
|
|
|
if (!dbg->mod)
|
2010-10-21 14:13:41 +04:00
|
|
|
goto error;
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
|
|
|
|
if (!dbg->dbg)
|
2011-06-27 11:27:39 +04:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
return 0;
|
2010-10-21 14:13:41 +04:00
|
|
|
error:
|
2013-11-05 22:32:36 +04:00
|
|
|
if (dbg->dwfl)
|
|
|
|
dwfl_end(dbg->dwfl);
|
2011-06-27 11:27:39 +04:00
|
|
|
else
|
|
|
|
close(fd);
|
2013-11-05 22:32:36 +04:00
|
|
|
memset(dbg, 0, sizeof(*dbg));
|
2011-06-27 11:27:39 +04:00
|
|
|
|
|
|
|
return -ENOENT;
|
2010-10-21 14:13:41 +04:00
|
|
|
}
|
|
|
|
|
2014-02-06 09:32:27 +04:00
|
|
|
static struct debuginfo *__debuginfo__new(const char *path)
|
2011-06-27 11:27:39 +04:00
|
|
|
{
|
2013-11-05 22:32:36 +04:00
|
|
|
struct debuginfo *dbg = zalloc(sizeof(*dbg));
|
|
|
|
if (!dbg)
|
2010-12-17 16:12:18 +03:00
|
|
|
return NULL;
|
|
|
|
|
2013-12-27 00:41:15 +04:00
|
|
|
if (debuginfo__init_offline_dwarf(dbg, path) < 0)
|
|
|
|
zfree(&dbg);
|
2014-02-06 09:32:27 +04:00
|
|
|
if (dbg)
|
|
|
|
pr_debug("Open Debuginfo file: %s\n", path);
|
2013-11-05 22:32:36 +04:00
|
|
|
return dbg;
|
2011-06-27 11:27:39 +04:00
|
|
|
}
|
|
|
|
|
2014-02-06 09:32:27 +04:00
|
|
|
enum dso_binary_type distro_dwarf_types[] = {
|
|
|
|
DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
|
|
|
|
DSO_BINARY_TYPE__NOT_FOUND,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct debuginfo *debuginfo__new(const char *path)
|
|
|
|
{
|
|
|
|
enum dso_binary_type *type;
|
|
|
|
char buf[PATH_MAX], nil = '\0';
|
|
|
|
struct dso *dso;
|
|
|
|
struct debuginfo *dinfo = NULL;
|
|
|
|
|
|
|
|
/* Try to open distro debuginfo files */
|
|
|
|
dso = dso__new(path);
|
|
|
|
if (!dso)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (type = distro_dwarf_types;
|
|
|
|
!dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
|
|
|
|
type++) {
|
|
|
|
if (dso__read_binary_type_filename(dso, *type, &nil,
|
|
|
|
buf, PATH_MAX) < 0)
|
|
|
|
continue;
|
|
|
|
dinfo = __debuginfo__new(buf);
|
|
|
|
}
|
|
|
|
dso__delete(dso);
|
|
|
|
|
|
|
|
out:
|
|
|
|
/* if failed to open all distro debuginfo, open given binary */
|
|
|
|
return dinfo ? : __debuginfo__new(path);
|
|
|
|
}
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
void debuginfo__delete(struct debuginfo *dbg)
|
2011-06-27 11:27:39 +04:00
|
|
|
{
|
2013-11-05 22:32:36 +04:00
|
|
|
if (dbg) {
|
|
|
|
if (dbg->dwfl)
|
|
|
|
dwfl_end(dbg->dwfl);
|
|
|
|
free(dbg);
|
2011-06-27 11:27:39 +04:00
|
|
|
}
|
2010-12-17 16:12:18 +03:00
|
|
|
}
|
2010-10-21 14:13:41 +04:00
|
|
|
|
2009-10-09 01:17:38 +04:00
|
|
|
/*
|
|
|
|
* Probe finder related functions
|
|
|
|
*/
|
|
|
|
|
2010-07-29 18:13:51 +04:00
|
|
|
static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
|
2010-05-19 23:57:49 +04:00
|
|
|
{
|
2010-07-29 18:13:51 +04:00
|
|
|
struct probe_trace_arg_ref *ref;
|
|
|
|
ref = zalloc(sizeof(struct probe_trace_arg_ref));
|
2010-05-19 23:57:49 +04:00
|
|
|
if (ref != NULL)
|
|
|
|
ref->offset = offs;
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
/*
|
|
|
|
* Convert a location into trace_arg.
|
|
|
|
* If tvar == NULL, this just checks variable can be converted.
|
2013-10-11 11:10:26 +04:00
|
|
|
* If fentry == true and vr_die is a parameter, do huristic search
|
|
|
|
* for the location fuzzed by function entry mcount.
|
2010-10-21 14:13:23 +04:00
|
|
|
*/
|
|
|
|
static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
|
2013-10-11 11:10:26 +04:00
|
|
|
Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
|
2010-10-21 14:13:23 +04:00
|
|
|
struct probe_trace_arg *tvar)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2010-05-19 23:57:49 +04:00
|
|
|
Dwarf_Attribute attr;
|
2013-10-11 11:10:26 +04:00
|
|
|
Dwarf_Addr tmp = 0;
|
2010-05-19 23:57:49 +04:00
|
|
|
Dwarf_Op *op;
|
|
|
|
size_t nops;
|
2010-02-25 16:35:42 +03:00
|
|
|
unsigned int regn;
|
|
|
|
Dwarf_Word offs = 0;
|
2010-03-17 01:06:12 +03:00
|
|
|
bool ref = false;
|
2009-10-09 01:17:38 +04:00
|
|
|
const char *regs;
|
2010-05-19 23:57:49 +04:00
|
|
|
int ret;
|
|
|
|
|
2010-10-21 14:13:16 +04:00
|
|
|
if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
|
|
|
|
goto static_var;
|
|
|
|
|
2010-05-19 23:57:49 +04:00
|
|
|
/* TODO: handle more than 1 exprs */
|
2013-10-11 11:10:26 +04:00
|
|
|
if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
|
|
|
|
return -EINVAL; /* Broken DIE ? */
|
|
|
|
if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
|
|
|
|
ret = dwarf_entrypc(sp_die, &tmp);
|
|
|
|
if (ret || addr != tmp ||
|
|
|
|
dwarf_tag(vr_die) != DW_TAG_formal_parameter ||
|
|
|
|
dwarf_highpc(sp_die, &tmp))
|
|
|
|
return -ENOENT;
|
|
|
|
/*
|
|
|
|
* This is fuzzed by fentry mcount. We try to find the
|
|
|
|
* parameter location at the earliest address.
|
|
|
|
*/
|
|
|
|
for (addr += 1; addr <= tmp; addr++) {
|
|
|
|
if (dwarf_getlocation_addr(&attr, addr, &op,
|
|
|
|
&nops, 1) > 0)
|
|
|
|
goto found;
|
|
|
|
}
|
2010-05-19 23:57:49 +04:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
2013-10-11 11:10:26 +04:00
|
|
|
found:
|
|
|
|
if (nops == 0)
|
|
|
|
/* TODO: Support const_value */
|
|
|
|
return -ENOENT;
|
2010-05-19 23:57:49 +04:00
|
|
|
|
|
|
|
if (op->atom == DW_OP_addr) {
|
2010-10-21 14:13:16 +04:00
|
|
|
static_var:
|
2010-10-21 14:13:23 +04:00
|
|
|
if (!tvar)
|
|
|
|
return 0;
|
2010-05-19 23:57:49 +04:00
|
|
|
/* Static variables on memory (not stack), make @varname */
|
|
|
|
ret = strlen(dwarf_diename(vr_die));
|
|
|
|
tvar->value = zalloc(ret + 2);
|
|
|
|
if (tvar->value == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
|
|
|
|
tvar->ref = alloc_trace_arg_ref((long)offs);
|
|
|
|
if (tvar->ref == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-09 01:17:38 +04:00
|
|
|
|
|
|
|
/* If this is based on frame buffer, set the offset */
|
2010-02-25 16:35:42 +03:00
|
|
|
if (op->atom == DW_OP_fbreg) {
|
2010-10-21 14:13:23 +04:00
|
|
|
if (fb_ops == NULL)
|
2010-04-12 21:17:35 +04:00
|
|
|
return -ENOTSUP;
|
2010-03-17 01:06:12 +03:00
|
|
|
ref = true;
|
2010-02-25 16:35:42 +03:00
|
|
|
offs = op->number;
|
2010-10-21 14:13:23 +04:00
|
|
|
op = &fb_ops[0];
|
2010-02-25 16:35:42 +03:00
|
|
|
}
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-02-25 16:35:42 +03:00
|
|
|
if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
|
|
|
|
regn = op->atom - DW_OP_breg0;
|
|
|
|
offs += op->number;
|
2010-03-17 01:06:12 +03:00
|
|
|
ref = true;
|
2010-02-25 16:35:42 +03:00
|
|
|
} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
|
|
|
|
regn = op->atom - DW_OP_reg0;
|
|
|
|
} else if (op->atom == DW_OP_bregx) {
|
|
|
|
regn = op->number;
|
|
|
|
offs += op->number2;
|
2010-03-17 01:06:12 +03:00
|
|
|
ref = true;
|
2010-02-25 16:35:42 +03:00
|
|
|
} else if (op->atom == DW_OP_regx) {
|
|
|
|
regn = op->number;
|
2010-04-12 21:17:35 +04:00
|
|
|
} else {
|
2010-10-21 14:13:23 +04:00
|
|
|
pr_debug("DW_OP %x is not supported.\n", op->atom);
|
2010-04-12 21:17:35 +04:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
if (!tvar)
|
|
|
|
return 0;
|
|
|
|
|
2009-10-09 01:17:38 +04:00
|
|
|
regs = get_arch_regstr(regn);
|
2010-04-12 21:17:35 +04:00
|
|
|
if (!regs) {
|
2010-10-21 14:13:23 +04:00
|
|
|
/* This should be a bug in DWARF or this tool */
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_warning("Mapping for the register number %u "
|
|
|
|
"missing on this architecture.\n", regn);
|
2010-04-12 21:17:35 +04:00
|
|
|
return -ERANGE;
|
|
|
|
}
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-04-12 21:17:56 +04:00
|
|
|
tvar->value = strdup(regs);
|
|
|
|
if (tvar->value == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-03-17 01:06:12 +03:00
|
|
|
if (ref) {
|
2010-05-19 23:57:49 +04:00
|
|
|
tvar->ref = alloc_trace_arg_ref((long)offs);
|
2010-04-12 21:17:49 +04:00
|
|
|
if (tvar->ref == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-17 01:06:12 +03:00
|
|
|
}
|
2010-04-12 21:17:35 +04:00
|
|
|
return 0;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2011-02-04 15:52:11 +03:00
|
|
|
#define BYTES_TO_BITS(nb) ((nb) * BITS_PER_LONG / sizeof(long))
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
static int convert_variable_type(Dwarf_Die *vr_die,
|
2010-07-29 18:13:51 +04:00
|
|
|
struct probe_trace_arg *tvar,
|
2010-05-19 23:57:35 +04:00
|
|
|
const char *cast)
|
2010-04-12 21:17:15 +04:00
|
|
|
{
|
2010-07-29 18:13:51 +04:00
|
|
|
struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
|
2010-04-12 21:17:15 +04:00
|
|
|
Dwarf_Die type;
|
|
|
|
char buf[16];
|
2011-06-27 11:27:21 +04:00
|
|
|
int bsize, boffs, total;
|
2010-04-12 21:17:15 +04:00
|
|
|
int ret;
|
|
|
|
|
2010-05-19 23:57:35 +04:00
|
|
|
/* TODO: check all types */
|
|
|
|
if (cast && strcmp(cast, "string") != 0) {
|
|
|
|
/* Non string type is OK */
|
|
|
|
tvar->type = strdup(cast);
|
|
|
|
return (tvar->type == NULL) ? -ENOMEM : 0;
|
|
|
|
}
|
|
|
|
|
2011-06-27 11:27:21 +04:00
|
|
|
bsize = dwarf_bitsize(vr_die);
|
|
|
|
if (bsize > 0) {
|
2011-02-04 15:52:11 +03:00
|
|
|
/* This is a bitfield */
|
2011-06-27 11:27:21 +04:00
|
|
|
boffs = dwarf_bitoffset(vr_die);
|
|
|
|
total = dwarf_bytesize(vr_die);
|
|
|
|
if (boffs < 0 || total < 0)
|
|
|
|
return -ENOENT;
|
|
|
|
ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs,
|
|
|
|
BYTES_TO_BITS(total));
|
2011-02-04 15:52:11 +03:00
|
|
|
goto formatted;
|
|
|
|
}
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
if (die_get_real_type(vr_die, &type) == NULL) {
|
|
|
|
pr_warning("Failed to get a type information of %s.\n",
|
|
|
|
dwarf_diename(vr_die));
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2010-04-12 21:17:15 +04:00
|
|
|
|
2010-05-19 23:57:42 +04:00
|
|
|
pr_debug("%s type is %s.\n",
|
|
|
|
dwarf_diename(vr_die), dwarf_diename(&type));
|
|
|
|
|
2010-05-19 23:57:35 +04:00
|
|
|
if (cast && strcmp(cast, "string") == 0) { /* String type */
|
|
|
|
ret = dwarf_tag(&type);
|
|
|
|
if (ret != DW_TAG_pointer_type &&
|
|
|
|
ret != DW_TAG_array_type) {
|
|
|
|
pr_warning("Failed to cast into string: "
|
2010-12-17 16:12:11 +03:00
|
|
|
"%s(%s) is not a pointer nor array.\n",
|
2010-05-19 23:57:35 +04:00
|
|
|
dwarf_diename(vr_die), dwarf_diename(&type));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-09-11 11:57:28 +04:00
|
|
|
if (die_get_real_type(&type, &type) == NULL) {
|
|
|
|
pr_warning("Failed to get a type"
|
|
|
|
" information.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2010-05-19 23:57:35 +04:00
|
|
|
if (ret == DW_TAG_pointer_type) {
|
|
|
|
while (*ref_ptr)
|
|
|
|
ref_ptr = &(*ref_ptr)->next;
|
|
|
|
/* Add new reference with offset +0 */
|
2010-07-29 18:13:51 +04:00
|
|
|
*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
|
2010-05-19 23:57:35 +04:00
|
|
|
if (*ref_ptr == NULL) {
|
|
|
|
pr_warning("Out of memory error\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
2010-07-09 13:29:17 +04:00
|
|
|
if (!die_compare_name(&type, "char") &&
|
|
|
|
!die_compare_name(&type, "unsigned char")) {
|
2010-05-19 23:57:35 +04:00
|
|
|
pr_warning("Failed to cast into string: "
|
2010-12-17 16:12:11 +03:00
|
|
|
"%s is not (unsigned) char *.\n",
|
2010-05-19 23:57:35 +04:00
|
|
|
dwarf_diename(vr_die));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
tvar->type = strdup(cast);
|
|
|
|
return (tvar->type == NULL) ? -ENOMEM : 0;
|
|
|
|
}
|
|
|
|
|
2011-06-27 11:27:21 +04:00
|
|
|
ret = dwarf_bytesize(&type);
|
|
|
|
if (ret <= 0)
|
2011-02-04 15:52:11 +03:00
|
|
|
/* No size ... try to use default type */
|
|
|
|
return 0;
|
2011-06-27 11:27:21 +04:00
|
|
|
ret = BYTES_TO_BITS(ret);
|
2010-04-12 21:17:15 +04:00
|
|
|
|
2011-02-04 15:52:11 +03:00
|
|
|
/* Check the bitwidth */
|
|
|
|
if (ret > MAX_BASIC_TYPE_BITS) {
|
|
|
|
pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
|
|
|
|
dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
|
|
|
|
ret = MAX_BASIC_TYPE_BITS;
|
2010-04-12 21:17:15 +04:00
|
|
|
}
|
2011-02-04 15:52:11 +03:00
|
|
|
ret = snprintf(buf, 16, "%c%d",
|
|
|
|
die_is_signed_type(&type) ? 's' : 'u', ret);
|
|
|
|
|
|
|
|
formatted:
|
|
|
|
if (ret < 0 || ret >= 16) {
|
|
|
|
if (ret >= 16)
|
|
|
|
ret = -E2BIG;
|
|
|
|
pr_warning("Failed to convert variable type: %s\n",
|
|
|
|
strerror(-ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
tvar->type = strdup(buf);
|
|
|
|
if (tvar->type == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 21:17:35 +04:00
|
|
|
return 0;
|
2010-04-12 21:17:15 +04:00
|
|
|
}
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
|
2010-03-17 01:06:26 +03:00
|
|
|
struct perf_probe_arg_field *field,
|
2010-07-29 18:13:51 +04:00
|
|
|
struct probe_trace_arg_ref **ref_ptr,
|
2010-04-12 21:17:15 +04:00
|
|
|
Dwarf_Die *die_mem)
|
2010-03-17 01:06:26 +03:00
|
|
|
{
|
2010-07-29 18:13:51 +04:00
|
|
|
struct probe_trace_arg_ref *ref = *ref_ptr;
|
2010-03-17 01:06:26 +03:00
|
|
|
Dwarf_Die type;
|
|
|
|
Dwarf_Word offs;
|
2010-05-19 23:57:42 +04:00
|
|
|
int ret, tag;
|
2010-03-17 01:06:26 +03:00
|
|
|
|
|
|
|
pr_debug("converting %s in %s\n", field->name, varname);
|
2010-04-12 21:17:35 +04:00
|
|
|
if (die_get_real_type(vr_die, &type) == NULL) {
|
|
|
|
pr_warning("Failed to get the type of %s.\n", varname);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2010-05-19 23:57:42 +04:00
|
|
|
pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
|
|
|
|
tag = dwarf_tag(&type);
|
|
|
|
|
|
|
|
if (field->name[0] == '[' &&
|
|
|
|
(tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
|
|
|
|
if (field->next)
|
|
|
|
/* Save original type for next field */
|
|
|
|
memcpy(die_mem, &type, sizeof(*die_mem));
|
|
|
|
/* Get the type of this array */
|
|
|
|
if (die_get_real_type(&type, &type) == NULL) {
|
|
|
|
pr_warning("Failed to get the type of %s.\n", varname);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
pr_debug2("Array real type: (%x)\n",
|
|
|
|
(unsigned)dwarf_dieoffset(&type));
|
|
|
|
if (tag == DW_TAG_pointer_type) {
|
2010-07-29 18:13:51 +04:00
|
|
|
ref = zalloc(sizeof(struct probe_trace_arg_ref));
|
2010-05-19 23:57:42 +04:00
|
|
|
if (ref == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (*ref_ptr)
|
|
|
|
(*ref_ptr)->next = ref;
|
|
|
|
else
|
|
|
|
*ref_ptr = ref;
|
|
|
|
}
|
2011-06-27 11:27:21 +04:00
|
|
|
ref->offset += dwarf_bytesize(&type) * field->index;
|
2010-05-19 23:57:42 +04:00
|
|
|
if (!field->next)
|
|
|
|
/* Save vr_die for converting types */
|
|
|
|
memcpy(die_mem, vr_die, sizeof(*die_mem));
|
|
|
|
goto next;
|
|
|
|
} else if (tag == DW_TAG_pointer_type) {
|
|
|
|
/* Check the pointer and dereference */
|
2010-04-12 21:17:35 +04:00
|
|
|
if (!field->ref) {
|
|
|
|
pr_err("Semantic error: %s must be referred by '->'\n",
|
|
|
|
field->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-03-17 01:06:26 +03:00
|
|
|
/* Get the type pointed by this pointer */
|
2010-04-12 21:17:35 +04:00
|
|
|
if (die_get_real_type(&type, &type) == NULL) {
|
|
|
|
pr_warning("Failed to get the type of %s.\n", varname);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2010-04-02 20:50:53 +04:00
|
|
|
/* Verify it is a data structure */
|
2012-09-12 11:57:45 +04:00
|
|
|
tag = dwarf_tag(&type);
|
|
|
|
if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
|
|
|
|
pr_warning("%s is not a data structure nor an union.\n",
|
|
|
|
varname);
|
2010-04-12 21:17:35 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-04-02 20:50:53 +04:00
|
|
|
|
2010-07-29 18:13:51 +04:00
|
|
|
ref = zalloc(sizeof(struct probe_trace_arg_ref));
|
2010-04-12 21:17:49 +04:00
|
|
|
if (ref == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-17 01:06:26 +03:00
|
|
|
if (*ref_ptr)
|
|
|
|
(*ref_ptr)->next = ref;
|
|
|
|
else
|
|
|
|
*ref_ptr = ref;
|
|
|
|
} else {
|
2010-04-02 20:50:53 +04:00
|
|
|
/* Verify it is a data structure */
|
2012-09-12 11:57:45 +04:00
|
|
|
if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
|
|
|
|
pr_warning("%s is not a data structure nor an union.\n",
|
|
|
|
varname);
|
2010-04-12 21:17:35 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-05-19 23:57:42 +04:00
|
|
|
if (field->name[0] == '[') {
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_err("Semantic error: %s is not a pointor"
|
|
|
|
" nor array.\n", varname);
|
2010-05-19 23:57:42 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-04-12 21:17:35 +04:00
|
|
|
if (field->ref) {
|
|
|
|
pr_err("Semantic error: %s must be referred by '.'\n",
|
|
|
|
field->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (!ref) {
|
|
|
|
pr_warning("Structure on a register is not "
|
|
|
|
"supported yet.\n");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2010-03-17 01:06:26 +03:00
|
|
|
}
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
if (die_find_member(&type, field->name, die_mem) == NULL) {
|
2013-10-25 00:36:31 +04:00
|
|
|
pr_warning("%s(type:%s) has no member %s.\n", varname,
|
2010-04-12 21:17:35 +04:00
|
|
|
dwarf_diename(&type), field->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-03-17 01:06:26 +03:00
|
|
|
|
|
|
|
/* Get the offset of the field */
|
2012-09-12 11:57:45 +04:00
|
|
|
if (tag == DW_TAG_union_type) {
|
|
|
|
offs = 0;
|
|
|
|
} else {
|
|
|
|
ret = die_get_data_member_location(die_mem, &offs);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_warning("Failed to get the offset of %s.\n",
|
|
|
|
field->name);
|
|
|
|
return ret;
|
|
|
|
}
|
2010-04-12 21:17:35 +04:00
|
|
|
}
|
2010-03-17 01:06:26 +03:00
|
|
|
ref->offset += (long)offs;
|
|
|
|
|
2010-05-19 23:57:42 +04:00
|
|
|
next:
|
2010-03-17 01:06:26 +03:00
|
|
|
/* Converting next field */
|
|
|
|
if (field->next)
|
2010-04-12 21:17:35 +04:00
|
|
|
return convert_variable_fields(die_mem, field->name,
|
2010-04-15 00:44:00 +04:00
|
|
|
field->next, &ref, die_mem);
|
2010-04-12 21:17:35 +04:00
|
|
|
else
|
|
|
|
return 0;
|
2010-03-17 01:06:26 +03:00
|
|
|
}
|
|
|
|
|
2009-10-09 01:17:38 +04:00
|
|
|
/* Show a variables in kprobe event format */
|
2010-04-12 21:17:35 +04:00
|
|
|
static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2010-04-12 21:17:15 +04:00
|
|
|
Dwarf_Die die_mem;
|
2009-10-09 01:17:38 +04:00
|
|
|
int ret;
|
|
|
|
|
2010-05-19 23:57:49 +04:00
|
|
|
pr_debug("Converting variable %s into trace event.\n",
|
|
|
|
dwarf_diename(vr_die));
|
2010-02-25 16:35:42 +03:00
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
|
2013-10-11 11:10:26 +04:00
|
|
|
&pf->sp_die, pf->tvar);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret == -ENOENT)
|
|
|
|
pr_err("Failed to find the location of %s at this address.\n"
|
|
|
|
" Perhaps, it has been optimized out.\n", pf->pvar->var);
|
|
|
|
else if (ret == -ENOTSUP)
|
|
|
|
pr_err("Sorry, we don't support this variable location yet.\n");
|
|
|
|
else if (pf->pvar->field) {
|
2010-04-12 21:17:35 +04:00
|
|
|
ret = convert_variable_fields(vr_die, pf->pvar->var,
|
|
|
|
pf->pvar->field, &pf->tvar->ref,
|
|
|
|
&die_mem);
|
2010-04-12 21:17:15 +04:00
|
|
|
vr_die = &die_mem;
|
|
|
|
}
|
2010-05-19 23:57:35 +04:00
|
|
|
if (ret == 0)
|
|
|
|
ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
|
2010-02-25 16:35:42 +03:00
|
|
|
/* *expr will be cached in libdw. Don't free it. */
|
2010-04-12 21:17:35 +04:00
|
|
|
return ret;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Find a variable in a scope DIE */
|
|
|
|
static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
Dwarf_Die vr_die;
|
2010-04-12 21:17:22 +04:00
|
|
|
char buf[32], *ptr;
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
int ret = 0;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-08-27 15:38:59 +04:00
|
|
|
if (!is_c_varname(pf->pvar->var)) {
|
|
|
|
/* Copy raw parameters */
|
|
|
|
pf->tvar->value = strdup(pf->pvar->var);
|
|
|
|
if (pf->tvar->value == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (pf->pvar->type) {
|
|
|
|
pf->tvar->type = strdup(pf->pvar->type);
|
|
|
|
if (pf->tvar->type == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (pf->pvar->name) {
|
|
|
|
pf->tvar->name = strdup(pf->pvar->name);
|
|
|
|
if (pf->tvar->name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
} else
|
|
|
|
pf->tvar->name = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-12 21:16:53 +04:00
|
|
|
if (pf->pvar->name)
|
2010-04-12 21:17:56 +04:00
|
|
|
pf->tvar->name = strdup(pf->pvar->name);
|
2010-04-12 21:16:53 +04:00
|
|
|
else {
|
2010-04-12 21:17:56 +04:00
|
|
|
ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-04-12 21:17:22 +04:00
|
|
|
ptr = strchr(buf, ':'); /* Change type separator to _ */
|
|
|
|
if (ptr)
|
|
|
|
*ptr = '_';
|
2010-04-12 21:17:56 +04:00
|
|
|
pf->tvar->name = strdup(buf);
|
2010-04-12 21:16:53 +04:00
|
|
|
}
|
2010-04-12 21:17:56 +04:00
|
|
|
if (pf->tvar->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 21:16:53 +04:00
|
|
|
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
|
2010-04-12 21:17:35 +04:00
|
|
|
/* Search child die for local variables and parameters. */
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
|
|
|
|
/* Search again in global variables */
|
|
|
|
if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
|
|
|
|
ret = -ENOENT;
|
2010-05-19 23:57:49 +04:00
|
|
|
}
|
2011-08-20 09:39:23 +04:00
|
|
|
if (ret >= 0)
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
ret = convert_variable(&vr_die, pf);
|
|
|
|
|
2010-05-19 23:57:49 +04:00
|
|
|
if (ret < 0)
|
2010-04-12 21:17:35 +04:00
|
|
|
pr_warning("Failed to find '%s' in this function.\n",
|
|
|
|
pf->pvar->var);
|
2010-05-19 23:57:49 +04:00
|
|
|
return ret;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
/* Convert subprogram DIE to trace point */
|
2013-09-25 17:16:16 +04:00
|
|
|
static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
|
|
|
|
Dwarf_Addr paddr, bool retprobe,
|
|
|
|
struct probe_trace_point *tp)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2012-02-24 11:41:39 +04:00
|
|
|
Dwarf_Addr eaddr, highaddr;
|
2013-09-25 17:16:16 +04:00
|
|
|
GElf_Sym sym;
|
|
|
|
const char *symbol;
|
|
|
|
|
|
|
|
/* Verify the address is correct */
|
|
|
|
if (dwarf_entrypc(sp_die, &eaddr) != 0) {
|
|
|
|
pr_warning("Failed to get entry address of %s\n",
|
|
|
|
dwarf_diename(sp_die));
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
if (dwarf_highpc(sp_die, &highaddr) != 0) {
|
|
|
|
pr_warning("Failed to get end address of %s\n",
|
|
|
|
dwarf_diename(sp_die));
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
if (paddr > highaddr) {
|
|
|
|
pr_warning("Offset specified is greater than size of %s\n",
|
|
|
|
dwarf_diename(sp_die));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get an appropriate symbol from symtab */
|
|
|
|
symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
|
|
|
|
if (!symbol) {
|
|
|
|
pr_warning("Failed to find symbol at 0x%lx\n",
|
|
|
|
(unsigned long)paddr);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
tp->offset = (unsigned long)(paddr - sym.st_value);
|
perf probe: Support basic dwarf-based operations on uprobe events
Support basic dwarf(debuginfo) based operations for uprobe events. With
this change, perf probe can analyze debuginfo of user application binary
to set up new uprobe event.
This allows perf-probe --add(with local variables, line numbers) and
--line works with -x option. (Actually, --vars has already accepted -x
option)
For example, the following command shows the probe-able lines of a given
user space function. Something that so far was only available in the
'perf probe' tool for kernel space functions:
# ./perf probe -x perf --line map__load
<map__load@/home/fedora/ksrc/linux-2.6/tools/perf/util/map.c:0>
0 int map__load(struct map *map, symbol_filter_t filter)
1 {
2 const char *name = map->dso->long_name;
int nr;
5 if (dso__loaded(map->dso, map->type))
6 return 0;
8 nr = dso__load(map->dso, map, filter);
9 if (nr < 0) {
10 if (map->dso->has_build_id) {
And this shows the available variables at the given line of the
function.
# ./perf probe -x perf --vars map__load:8
Available variables at map__load:8
@<map__load+96>
char* name
struct map* map
symbol_filter_t filter
@<map__find_symbol+112>
char* name
symbol_filter_t filter
@<map__find_symbol_by_name+136>
char* name
symbol_filter_t filter
@<map_groups__find_symbol_by_name+176>
char* name
struct map* map
symbol_filter_t filter
And lastly, we can now define probe(s) with all available
variables on the given line:
# ./perf probe -x perf --add 'map__load:8 $vars'
Added new events:
probe_perf:map__load (on map__load:8 with $vars)
probe_perf:map__load_1 (on map__load:8 with $vars)
probe_perf:map__load_2 (on map__load:8 with $vars)
probe_perf:map__load_3 (on map__load:8 with $vars)
You can now use it in all perf tools, such as:
perf record -e probe_perf:map__load_3 -aR sleep 1
Changes from previous version:
- Add examples in the patch description.
- Use .text section start address and dwarf symbol address
for calculating the offset of given symbol, instead of
searching the symbol in symtab again.
With this change, we can safely handle multiple local
function instances (e.g. scnprintf in perf).
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: David A. Long <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: systemtap@sourceware.org
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20131226054152.22364.47021.stgit@kbuild-fedora.novalocal
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-12-26 09:41:53 +04:00
|
|
|
tp->address = (unsigned long)paddr;
|
2013-09-25 17:16:16 +04:00
|
|
|
tp->symbol = strdup(symbol);
|
|
|
|
if (!tp->symbol)
|
|
|
|
return -ENOMEM;
|
2010-03-17 01:06:12 +03:00
|
|
|
|
2010-08-27 15:38:53 +04:00
|
|
|
/* Return probe must be on the head of a subprogram */
|
2010-10-21 14:13:23 +04:00
|
|
|
if (retprobe) {
|
|
|
|
if (eaddr != paddr) {
|
2010-08-27 15:38:53 +04:00
|
|
|
pr_warning("Return probe must be on the head of"
|
2010-12-17 16:12:11 +03:00
|
|
|
" a real function.\n");
|
2010-08-27 15:38:53 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-10-21 14:13:23 +04:00
|
|
|
tp->retprobe = true;
|
2010-08-27 15:38:53 +04:00
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Call probe_finder callback with scope DIE */
|
|
|
|
static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
|
2010-10-21 14:13:23 +04:00
|
|
|
{
|
|
|
|
Dwarf_Attribute fb_attr;
|
|
|
|
size_t nops;
|
|
|
|
int ret;
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
if (!sc_die) {
|
|
|
|
pr_err("Caller must pass a scope DIE. Program error.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If not a real subprogram, find a real one */
|
2012-04-23 07:24:36 +04:00
|
|
|
if (!die_is_func_def(sc_die)) {
|
2011-08-11 15:02:59 +04:00
|
|
|
if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
|
2010-10-21 14:13:23 +04:00
|
|
|
pr_warning("Failed to find probe point in any "
|
|
|
|
"functions.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2011-08-11 15:02:59 +04:00
|
|
|
} else
|
|
|
|
memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Get the frame base attribute/ops from subprogram */
|
|
|
|
dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
|
2010-03-15 20:02:35 +03:00
|
|
|
ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
|
2010-04-12 21:17:29 +04:00
|
|
|
if (ret <= 0 || nops == 0) {
|
2010-02-25 16:35:42 +03:00
|
|
|
pf->fb_ops = NULL;
|
2010-05-10 21:12:07 +04:00
|
|
|
#if _ELFUTILS_PREREQ(0, 142)
|
2010-04-12 21:17:29 +04:00
|
|
|
} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
|
|
|
|
pf->cfi != NULL) {
|
|
|
|
Dwarf_Frame *frame;
|
2010-04-12 21:17:35 +04:00
|
|
|
if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
|
|
|
|
dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_warning("Failed to get call frame on 0x%jx\n",
|
2010-04-12 21:17:35 +04:00
|
|
|
(uintmax_t)pf->addr);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2010-05-10 21:12:07 +04:00
|
|
|
#endif
|
2010-04-12 21:17:29 +04:00
|
|
|
}
|
2010-02-25 16:35:42 +03:00
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
/* Call finder's callback handler */
|
2011-08-11 15:02:59 +04:00
|
|
|
ret = pf->callback(sc_die, pf);
|
2010-02-25 16:35:42 +03:00
|
|
|
|
|
|
|
/* *pf->fb_ops will be cached in libdw. Don't free it. */
|
|
|
|
pf->fb_ops = NULL;
|
2010-10-21 14:13:23 +04:00
|
|
|
|
|
|
|
return ret;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
struct find_scope_param {
|
|
|
|
const char *function;
|
|
|
|
const char *file;
|
|
|
|
int line;
|
|
|
|
int diff;
|
|
|
|
Dwarf_Die *die_mem;
|
|
|
|
bool found;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
|
|
|
|
{
|
|
|
|
struct find_scope_param *fsp = data;
|
|
|
|
const char *file;
|
|
|
|
int lno;
|
|
|
|
|
|
|
|
/* Skip if declared file name does not match */
|
|
|
|
if (fsp->file) {
|
|
|
|
file = dwarf_decl_file(fn_die);
|
|
|
|
if (!file || strcmp(fsp->file, file) != 0)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* If the function name is given, that's what user expects */
|
|
|
|
if (fsp->function) {
|
|
|
|
if (die_compare_name(fn_die, fsp->function)) {
|
|
|
|
memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
|
|
|
|
fsp->found = true;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* With the line number, find the nearest declared DIE */
|
|
|
|
dwarf_decl_line(fn_die, &lno);
|
|
|
|
if (lno < fsp->line && fsp->diff > fsp->line - lno) {
|
|
|
|
/* Keep a candidate and continue */
|
|
|
|
fsp->diff = fsp->line - lno;
|
|
|
|
memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
|
|
|
|
fsp->found = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find an appropriate scope fits to given conditions */
|
|
|
|
static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
|
|
|
|
{
|
|
|
|
struct find_scope_param fsp = {
|
|
|
|
.function = pf->pev->point.function,
|
|
|
|
.file = pf->fname,
|
|
|
|
.line = pf->lno,
|
|
|
|
.diff = INT_MAX,
|
|
|
|
.die_mem = die_mem,
|
|
|
|
.found = false,
|
|
|
|
};
|
|
|
|
|
|
|
|
cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);
|
|
|
|
|
|
|
|
return fsp.found ? die_mem : NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
static int probe_point_line_walker(const char *fname, int lineno,
|
|
|
|
Dwarf_Addr addr, void *data)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2011-01-13 15:45:58 +03:00
|
|
|
struct probe_finder *pf = data;
|
2011-08-11 15:02:59 +04:00
|
|
|
Dwarf_Die *sc_die, die_mem;
|
2011-01-13 15:45:58 +03:00
|
|
|
int ret;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
|
|
|
|
return 0;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
pf->addr = addr;
|
2011-08-11 15:02:59 +04:00
|
|
|
sc_die = find_best_scope(pf, &die_mem);
|
|
|
|
if (!sc_die) {
|
|
|
|
pr_warning("Failed to find scope of probe point.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = call_probe_finder(sc_die, pf);
|
2009-10-27 23:43:19 +03:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
/* Continue if no error, because the line will be in inline function */
|
2011-02-21 19:23:57 +03:00
|
|
|
return ret < 0 ? ret : 0;
|
2011-01-13 15:45:58 +03:00
|
|
|
}
|
2010-02-25 16:35:42 +03:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
/* Find probe point from its line number */
|
|
|
|
static int find_probe_point_by_line(struct probe_finder *pf)
|
|
|
|
{
|
|
|
|
return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2010-02-25 16:36:12 +03:00
|
|
|
/* Find lines which match lazy pattern */
|
2014-02-06 09:32:09 +04:00
|
|
|
static int find_lazy_match_lines(struct intlist *list,
|
2010-02-25 16:36:12 +03:00
|
|
|
const char *fname, const char *pat)
|
|
|
|
{
|
2011-01-13 13:18:30 +03:00
|
|
|
FILE *fp;
|
|
|
|
char *line = NULL;
|
|
|
|
size_t line_len;
|
|
|
|
ssize_t len;
|
|
|
|
int count = 0, linenum = 1;
|
|
|
|
|
|
|
|
fp = fopen(fname, "r");
|
|
|
|
if (!fp) {
|
|
|
|
pr_warning("Failed to open %s: %s\n", fname, strerror(errno));
|
2010-05-19 06:04:28 +04:00
|
|
|
return -errno;
|
2010-04-12 21:17:35 +04:00
|
|
|
}
|
|
|
|
|
2011-01-13 13:18:30 +03:00
|
|
|
while ((len = getline(&line, &line_len, fp)) > 0) {
|
2010-05-19 06:04:28 +04:00
|
|
|
|
2011-01-13 13:18:30 +03:00
|
|
|
if (line[len - 1] == '\n')
|
|
|
|
line[len - 1] = '\0';
|
|
|
|
|
|
|
|
if (strlazymatch(line, pat)) {
|
2014-02-06 09:32:09 +04:00
|
|
|
intlist__add(list, linenum);
|
2011-01-13 13:18:30 +03:00
|
|
|
count++;
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
2011-01-13 13:18:30 +03:00
|
|
|
linenum++;
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
2011-01-13 13:18:30 +03:00
|
|
|
|
|
|
|
if (ferror(fp))
|
|
|
|
count = -errno;
|
|
|
|
free(line);
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
pr_debug("No matched lines found in %s.\n", fname);
|
|
|
|
return count;
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
static int probe_point_lazy_walker(const char *fname, int lineno,
|
|
|
|
Dwarf_Addr addr, void *data)
|
|
|
|
{
|
|
|
|
struct probe_finder *pf = data;
|
2011-08-11 15:02:59 +04:00
|
|
|
Dwarf_Die *sc_die, die_mem;
|
2011-01-13 15:45:58 +03:00
|
|
|
int ret;
|
|
|
|
|
2014-02-06 09:32:09 +04:00
|
|
|
if (!intlist__has_entry(pf->lcache, lineno) ||
|
2011-01-13 15:45:58 +03:00
|
|
|
strtailcmp(fname, pf->fname) != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pr_debug("Probe line found: line:%d addr:0x%llx\n",
|
|
|
|
lineno, (unsigned long long)addr);
|
|
|
|
pf->addr = addr;
|
2011-08-11 15:02:59 +04:00
|
|
|
pf->lno = lineno;
|
|
|
|
sc_die = find_best_scope(pf, &die_mem);
|
|
|
|
if (!sc_die) {
|
|
|
|
pr_warning("Failed to find scope of probe point.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = call_probe_finder(sc_die, pf);
|
2011-01-13 15:45:58 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Continue if no error, because the lazy pattern will match
|
|
|
|
* to other lines
|
|
|
|
*/
|
2011-03-15 22:51:09 +03:00
|
|
|
return ret < 0 ? ret : 0;
|
2011-01-13 15:45:58 +03:00
|
|
|
}
|
|
|
|
|
2010-02-25 16:36:12 +03:00
|
|
|
/* Find probe points from lazy pattern */
|
2010-04-12 21:17:35 +04:00
|
|
|
static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
|
2010-02-25 16:36:12 +03:00
|
|
|
{
|
2010-04-12 21:17:35 +04:00
|
|
|
int ret = 0;
|
2010-02-25 16:36:12 +03:00
|
|
|
|
2014-02-06 09:32:09 +04:00
|
|
|
if (intlist__empty(pf->lcache)) {
|
2010-02-25 16:36:12 +03:00
|
|
|
/* Matching lazy line pattern */
|
2014-02-06 09:32:09 +04:00
|
|
|
ret = find_lazy_match_lines(pf->lcache, pf->fname,
|
2010-03-17 01:06:12 +03:00
|
|
|
pf->pev->point.lazy_line);
|
2011-01-13 13:18:30 +03:00
|
|
|
if (ret <= 0)
|
2010-04-12 21:17:35 +04:00
|
|
|
return ret;
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
|
|
|
|
2010-02-25 16:35:50 +03:00
|
|
|
static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
|
|
|
|
{
|
2011-08-11 15:03:11 +04:00
|
|
|
struct probe_finder *pf = data;
|
2010-03-17 01:06:12 +03:00
|
|
|
struct perf_probe_point *pp = &pf->pev->point;
|
2010-04-12 21:17:35 +04:00
|
|
|
Dwarf_Addr addr;
|
2011-08-11 15:03:11 +04:00
|
|
|
int ret;
|
2010-02-25 16:35:50 +03:00
|
|
|
|
2010-02-25 16:36:12 +03:00
|
|
|
if (pp->lazy_line)
|
2011-08-11 15:03:11 +04:00
|
|
|
ret = find_probe_point_lazy(in_die, pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
else {
|
|
|
|
/* Get probe address */
|
2010-04-12 21:17:35 +04:00
|
|
|
if (dwarf_entrypc(in_die, &addr) != 0) {
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_warning("Failed to get entry address of %s.\n",
|
2010-04-12 21:17:35 +04:00
|
|
|
dwarf_diename(in_die));
|
2011-08-11 15:03:11 +04:00
|
|
|
return -ENOENT;
|
2010-04-12 21:17:35 +04:00
|
|
|
}
|
|
|
|
pf->addr = addr;
|
2010-02-25 16:36:12 +03:00
|
|
|
pf->addr += pp->offset;
|
|
|
|
pr_debug("found inline addr: 0x%jx\n",
|
|
|
|
(uintmax_t)pf->addr);
|
|
|
|
|
2011-08-11 15:03:11 +04:00
|
|
|
ret = call_probe_finder(in_die, pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
2010-02-25 16:35:50 +03:00
|
|
|
|
2011-08-11 15:03:11 +04:00
|
|
|
return ret;
|
2010-02-25 16:35:50 +03:00
|
|
|
}
|
2010-02-25 16:35:42 +03:00
|
|
|
|
2011-08-11 15:03:11 +04:00
|
|
|
/* Callback parameter with return value for libdw */
|
|
|
|
struct dwarf_callback_param {
|
|
|
|
void *data;
|
|
|
|
int retval;
|
|
|
|
};
|
|
|
|
|
2009-10-09 01:17:38 +04:00
|
|
|
/* Search function from function name */
|
2010-02-25 16:35:50 +03:00
|
|
|
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2010-04-12 21:17:35 +04:00
|
|
|
struct dwarf_callback_param *param = data;
|
|
|
|
struct probe_finder *pf = param->data;
|
2010-03-17 01:06:12 +03:00
|
|
|
struct perf_probe_point *pp = &pf->pev->point;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-02-25 16:35:50 +03:00
|
|
|
/* Check tag and diename */
|
2012-04-23 07:24:36 +04:00
|
|
|
if (!die_is_func_def(sp_die) ||
|
|
|
|
!die_compare_name(sp_die, pp->function))
|
2010-04-12 21:17:35 +04:00
|
|
|
return DWARF_CB_OK;
|
2010-02-25 16:35:50 +03:00
|
|
|
|
2011-03-30 13:25:41 +04:00
|
|
|
/* Check declared file */
|
|
|
|
if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
|
2010-02-25 16:36:12 +03:00
|
|
|
pf->fname = dwarf_decl_file(sp_die);
|
2010-02-25 16:35:50 +03:00
|
|
|
if (pp->line) { /* Function relative line */
|
|
|
|
dwarf_decl_line(sp_die, &pf->lno);
|
|
|
|
pf->lno += pp->line;
|
2010-04-12 21:17:35 +04:00
|
|
|
param->retval = find_probe_point_by_line(pf);
|
2010-02-25 16:35:50 +03:00
|
|
|
} else if (!dwarf_func_inline(sp_die)) {
|
|
|
|
/* Real function */
|
2010-02-25 16:36:12 +03:00
|
|
|
if (pp->lazy_line)
|
2010-04-12 21:17:35 +04:00
|
|
|
param->retval = find_probe_point_lazy(sp_die, pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
else {
|
2010-04-12 21:17:35 +04:00
|
|
|
if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_warning("Failed to get entry address of "
|
|
|
|
"%s.\n", dwarf_diename(sp_die));
|
2010-04-12 21:17:35 +04:00
|
|
|
param->retval = -ENOENT;
|
|
|
|
return DWARF_CB_ABORT;
|
|
|
|
}
|
2010-02-25 16:36:12 +03:00
|
|
|
pf->addr += pp->offset;
|
|
|
|
/* TODO: Check the address in this function */
|
2010-10-21 14:13:23 +04:00
|
|
|
param->retval = call_probe_finder(sp_die, pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
}
|
2011-08-11 15:03:11 +04:00
|
|
|
} else
|
2010-02-25 16:35:50 +03:00
|
|
|
/* Inlined function: search instances */
|
2011-08-11 15:03:11 +04:00
|
|
|
param->retval = die_walk_instances(sp_die,
|
|
|
|
probe_point_inline_cb, (void *)pf);
|
2010-02-25 16:35:50 +03:00
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
static int find_probe_point_by_func(struct probe_finder *pf)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2010-04-12 21:17:35 +04:00
|
|
|
struct dwarf_callback_param _param = {.data = (void *)pf,
|
|
|
|
.retval = 0};
|
|
|
|
dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
|
|
|
|
return _param.retval;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
struct pubname_callback_param {
|
|
|
|
char *function;
|
|
|
|
char *file;
|
|
|
|
Dwarf_Die *cu_die;
|
|
|
|
Dwarf_Die *sp_die;
|
|
|
|
int found;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
|
|
|
|
{
|
|
|
|
struct pubname_callback_param *param = data;
|
|
|
|
|
|
|
|
if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
|
|
|
|
if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
|
|
|
|
if (die_compare_name(param->sp_die, param->function)) {
|
|
|
|
if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
|
|
|
|
if (param->file &&
|
|
|
|
strtailcmp(param->file, dwarf_decl_file(param->sp_die)))
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
|
|
|
|
param->found = 1;
|
|
|
|
return DWARF_CB_ABORT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
/* Find probe points from debuginfo */
|
2013-11-05 22:32:36 +04:00
|
|
|
static int debuginfo__find_probes(struct debuginfo *dbg,
|
2011-06-27 11:27:39 +04:00
|
|
|
struct probe_finder *pf)
|
2009-10-09 01:17:38 +04:00
|
|
|
{
|
2010-10-21 14:13:23 +04:00
|
|
|
struct perf_probe_point *pp = &pf->pev->point;
|
2010-02-25 16:35:42 +03:00
|
|
|
Dwarf_Off off, noff;
|
|
|
|
size_t cuhl;
|
|
|
|
Dwarf_Die *diep;
|
2010-04-12 21:17:35 +04:00
|
|
|
int ret = 0;
|
2010-02-25 16:35:42 +03:00
|
|
|
|
2010-05-10 21:12:07 +04:00
|
|
|
#if _ELFUTILS_PREREQ(0, 142)
|
2010-04-12 21:17:29 +04:00
|
|
|
/* Get the call frame information from this dwarf */
|
2014-04-07 11:05:48 +04:00
|
|
|
pf->cfi = dwarf_getcfi_elf(dwarf_getelf(dbg->dbg));
|
2010-05-10 21:12:07 +04:00
|
|
|
#endif
|
2010-04-12 21:17:29 +04:00
|
|
|
|
2010-02-25 16:35:42 +03:00
|
|
|
off = 0;
|
2014-02-06 09:32:09 +04:00
|
|
|
pf->lcache = intlist__new(NULL);
|
|
|
|
if (!pf->lcache)
|
|
|
|
return -ENOMEM;
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
|
|
|
|
/* Fastpath: lookup by function name from .debug_pubnames section */
|
|
|
|
if (pp->function) {
|
|
|
|
struct pubname_callback_param pubname_param = {
|
|
|
|
.function = pp->function,
|
|
|
|
.file = pp->file,
|
|
|
|
.cu_die = &pf->cu_die,
|
|
|
|
.sp_die = &pf->sp_die,
|
2011-04-29 12:41:57 +04:00
|
|
|
.found = 0,
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
};
|
|
|
|
struct dwarf_callback_param probe_param = {
|
|
|
|
.data = pf,
|
|
|
|
};
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
dwarf_getpubnames(dbg->dbg, pubname_search_cb,
|
2011-06-27 11:27:39 +04:00
|
|
|
&pubname_param, 0);
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
if (pubname_param.found) {
|
|
|
|
ret = probe_point_search_cb(&pf->sp_die, &probe_param);
|
|
|
|
if (ret)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-25 16:35:42 +03:00
|
|
|
/* Loop on CUs (Compilation Unit) */
|
2013-11-05 22:32:36 +04:00
|
|
|
while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
|
2009-10-09 01:17:38 +04:00
|
|
|
/* Get the DIE(Debugging Information Entry) of this CU */
|
2013-11-05 22:32:36 +04:00
|
|
|
diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
|
2010-02-25 16:35:42 +03:00
|
|
|
if (!diep)
|
|
|
|
continue;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
|
|
|
/* Check if target file is included. */
|
|
|
|
if (pp->file)
|
2010-10-21 14:13:23 +04:00
|
|
|
pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
|
2010-02-25 16:35:42 +03:00
|
|
|
else
|
2010-10-21 14:13:23 +04:00
|
|
|
pf->fname = NULL;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
if (!pp->file || pf->fname) {
|
2009-10-09 01:17:38 +04:00
|
|
|
if (pp->function)
|
2010-10-21 14:13:23 +04:00
|
|
|
ret = find_probe_point_by_func(pf);
|
2010-02-25 16:36:12 +03:00
|
|
|
else if (pp->lazy_line)
|
2010-10-21 14:13:23 +04:00
|
|
|
ret = find_probe_point_lazy(NULL, pf);
|
2009-10-27 23:43:19 +03:00
|
|
|
else {
|
2010-10-21 14:13:23 +04:00
|
|
|
pf->lno = pp->line;
|
|
|
|
ret = find_probe_point_by_line(pf);
|
2009-10-27 23:43:19 +03:00
|
|
|
}
|
2011-02-22 12:56:18 +03:00
|
|
|
if (ret < 0)
|
2011-02-21 19:23:57 +03:00
|
|
|
break;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
2010-02-25 16:35:42 +03:00
|
|
|
off = noff;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
|
|
|
|
found:
|
2014-02-06 09:32:09 +04:00
|
|
|
intlist__delete(pf->lcache);
|
|
|
|
pf->lcache = NULL;
|
2009-10-09 01:17:38 +04:00
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-10-11 11:10:23 +04:00
|
|
|
struct local_vars_finder {
|
|
|
|
struct probe_finder *pf;
|
|
|
|
struct perf_probe_arg *args;
|
|
|
|
int max_args;
|
|
|
|
int nargs;
|
|
|
|
int ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Collect available variables in this scope */
|
|
|
|
static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
|
|
|
|
{
|
|
|
|
struct local_vars_finder *vf = data;
|
2013-10-11 11:10:26 +04:00
|
|
|
struct probe_finder *pf = vf->pf;
|
2013-10-11 11:10:23 +04:00
|
|
|
int tag;
|
|
|
|
|
|
|
|
tag = dwarf_tag(die_mem);
|
|
|
|
if (tag == DW_TAG_formal_parameter ||
|
|
|
|
tag == DW_TAG_variable) {
|
|
|
|
if (convert_variable_location(die_mem, vf->pf->addr,
|
2013-10-11 11:10:26 +04:00
|
|
|
vf->pf->fb_ops, &pf->sp_die,
|
|
|
|
NULL) == 0) {
|
2013-10-11 11:10:23 +04:00
|
|
|
vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
|
|
|
|
if (vf->args[vf->nargs].var == NULL) {
|
|
|
|
vf->ret = -ENOMEM;
|
|
|
|
return DIE_FIND_CB_END;
|
|
|
|
}
|
|
|
|
pr_debug(" %s", vf->args[vf->nargs].var);
|
|
|
|
vf->nargs++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dwarf_haspc(die_mem, vf->pf->addr))
|
|
|
|
return DIE_FIND_CB_CONTINUE;
|
|
|
|
else
|
|
|
|
return DIE_FIND_CB_SIBLING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
|
|
|
|
struct perf_probe_arg *args)
|
|
|
|
{
|
|
|
|
Dwarf_Die die_mem;
|
|
|
|
int i;
|
|
|
|
int n = 0;
|
|
|
|
struct local_vars_finder vf = {.pf = pf, .args = args,
|
|
|
|
.max_args = MAX_PROBE_ARGS, .ret = 0};
|
|
|
|
|
|
|
|
for (i = 0; i < pf->pev->nargs; i++) {
|
|
|
|
/* var never be NULL */
|
|
|
|
if (strcmp(pf->pev->args[i].var, "$vars") == 0) {
|
|
|
|
pr_debug("Expanding $vars into:");
|
|
|
|
vf.nargs = n;
|
|
|
|
/* Special local variables */
|
|
|
|
die_find_child(sc_die, copy_variables_cb, (void *)&vf,
|
|
|
|
&die_mem);
|
|
|
|
pr_debug(" (%d)\n", vf.nargs - n);
|
|
|
|
if (vf.ret < 0)
|
|
|
|
return vf.ret;
|
|
|
|
n = vf.nargs;
|
|
|
|
} else {
|
|
|
|
/* Copy normal argument */
|
|
|
|
args[n] = pf->pev->args[i];
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:23 +04:00
|
|
|
/* Add a found probe point into trace event list */
|
2011-08-11 15:02:59 +04:00
|
|
|
static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
|
2010-10-21 14:13:23 +04:00
|
|
|
{
|
|
|
|
struct trace_event_finder *tf =
|
|
|
|
container_of(pf, struct trace_event_finder, pf);
|
|
|
|
struct probe_trace_event *tev;
|
2013-10-11 11:10:23 +04:00
|
|
|
struct perf_probe_arg *args;
|
2010-10-21 14:13:23 +04:00
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
/* Check number of tevs */
|
|
|
|
if (tf->ntevs == tf->max_tevs) {
|
|
|
|
pr_warning("Too many( > %d) probe point found.\n",
|
|
|
|
tf->max_tevs);
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
tev = &tf->tevs[tf->ntevs++];
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Trace point should be converted from subprogram DIE */
|
2013-09-25 17:16:16 +04:00
|
|
|
ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
|
2011-08-11 15:02:59 +04:00
|
|
|
pf->pev->point.retprobe, &tev->point);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
|
|
|
|
tev->point.offset);
|
|
|
|
|
2013-10-11 11:10:23 +04:00
|
|
|
/* Expand special probe argument if exist */
|
|
|
|
args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
|
|
|
|
if (args == NULL)
|
2010-10-21 14:13:23 +04:00
|
|
|
return -ENOMEM;
|
2013-10-11 11:10:23 +04:00
|
|
|
|
|
|
|
ret = expand_probe_args(sc_die, pf, args);
|
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
tev->nargs = ret;
|
|
|
|
tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
|
|
|
|
if (tev->args == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find each argument */
|
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
|
|
|
pf->pvar = &args[i];
|
2010-10-21 14:13:23 +04:00
|
|
|
pf->tvar = &tev->args[i];
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Variable should be found from scope DIE */
|
|
|
|
ret = find_variable(sc_die, pf);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret != 0)
|
2013-10-11 11:10:23 +04:00
|
|
|
break;
|
2010-10-21 14:13:23 +04:00
|
|
|
}
|
|
|
|
|
2013-10-11 11:10:23 +04:00
|
|
|
end:
|
|
|
|
free(args);
|
|
|
|
return ret;
|
2010-10-21 14:13:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Find probe_trace_events specified by perf_probe_event from debuginfo */
|
2013-11-05 22:32:36 +04:00
|
|
|
int debuginfo__find_trace_events(struct debuginfo *dbg,
|
2011-06-27 11:27:39 +04:00
|
|
|
struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs, int max_tevs)
|
2010-10-21 14:13:23 +04:00
|
|
|
{
|
|
|
|
struct trace_event_finder tf = {
|
|
|
|
.pf = {.pev = pev, .callback = add_probe_trace_event},
|
2013-11-05 22:32:36 +04:00
|
|
|
.mod = dbg->mod, .max_tevs = max_tevs};
|
2010-10-21 14:13:23 +04:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Allocate result tevs array */
|
|
|
|
*tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
|
|
|
|
if (*tevs == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
tf.tevs = *tevs;
|
|
|
|
tf.ntevs = 0;
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
ret = debuginfo__find_probes(dbg, &tf.pf);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret < 0) {
|
2013-12-27 00:41:15 +04:00
|
|
|
zfree(tevs);
|
2010-10-21 14:13:23 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (ret < 0) ? ret : tf.ntevs;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_VAR_LEN 64
|
|
|
|
|
|
|
|
/* Collect available variables in this scope */
|
|
|
|
static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
|
|
|
|
{
|
|
|
|
struct available_var_finder *af = data;
|
|
|
|
struct variable_list *vl;
|
|
|
|
char buf[MAX_VAR_LEN];
|
|
|
|
int tag, ret;
|
|
|
|
|
|
|
|
vl = &af->vls[af->nvls - 1];
|
|
|
|
|
|
|
|
tag = dwarf_tag(die_mem);
|
|
|
|
if (tag == DW_TAG_formal_parameter ||
|
|
|
|
tag == DW_TAG_variable) {
|
|
|
|
ret = convert_variable_location(die_mem, af->pf.addr,
|
2013-10-11 11:10:26 +04:00
|
|
|
af->pf.fb_ops, &af->pf.sp_die,
|
|
|
|
NULL);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret == 0) {
|
|
|
|
ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
|
2010-10-21 14:13:35 +04:00
|
|
|
pr_debug2("Add new var: %s\n", buf);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret > 0)
|
|
|
|
strlist__add(vl->vars, buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-21 14:13:35 +04:00
|
|
|
if (af->child && dwarf_haspc(die_mem, af->pf.addr))
|
2010-10-21 14:13:23 +04:00
|
|
|
return DIE_FIND_CB_CONTINUE;
|
|
|
|
else
|
|
|
|
return DIE_FIND_CB_SIBLING;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a found vars into available variables list */
|
2011-08-11 15:02:59 +04:00
|
|
|
static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
|
2010-10-21 14:13:23 +04:00
|
|
|
{
|
|
|
|
struct available_var_finder *af =
|
|
|
|
container_of(pf, struct available_var_finder, pf);
|
|
|
|
struct variable_list *vl;
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
Dwarf_Die die_mem;
|
|
|
|
int ret;
|
2010-10-21 14:13:23 +04:00
|
|
|
|
|
|
|
/* Check number of tevs */
|
|
|
|
if (af->nvls == af->max_vls) {
|
|
|
|
pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
vl = &af->vls[af->nvls++];
|
|
|
|
|
2011-08-11 15:02:59 +04:00
|
|
|
/* Trace point should be converted from subprogram DIE */
|
2013-09-25 17:16:16 +04:00
|
|
|
ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
|
2011-08-11 15:02:59 +04:00
|
|
|
pf->pev->point.retprobe, &vl->point);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
|
|
|
|
vl->point.offset);
|
|
|
|
|
|
|
|
/* Find local variables */
|
|
|
|
vl->vars = strlist__new(true, NULL);
|
|
|
|
if (vl->vars == NULL)
|
|
|
|
return -ENOMEM;
|
2010-10-21 14:13:35 +04:00
|
|
|
af->child = true;
|
2011-08-11 15:02:59 +04:00
|
|
|
die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
|
2010-10-21 14:13:23 +04:00
|
|
|
|
2010-10-21 14:13:35 +04:00
|
|
|
/* Find external variables */
|
|
|
|
if (!af->externs)
|
|
|
|
goto out;
|
|
|
|
/* Don't need to search child DIE for externs. */
|
|
|
|
af->child = false;
|
perf probe: Avoid searching variables in intermediate scopes
Fix variable searching logic to search one in inner than local scope or
global(CU) scope. In the other words, skip searching in intermediate
scopes.
e.g., in the following code,
int var1;
void inline infunc(int i)
{
i++; <--- [A]
}
void func(void)
{
int var1, var2;
infunc(var2);
}
At [A], "var1" should point the global variable "var1", however, if user
mis-typed as "var2", variable search should be failed. However, current
logic searches variable infunc() scope, global scope, and then func()
scope. Thus, it can find "var2" variable in func() scope. This may not
be what user expects.
So, it would better not search outer scopes except outermost (compile
unit) scope which contains only global variables, when it failed to find
given variable in local scope.
E.g.
Without this:
$ perf probe -V pre_schedule --externs > without.vars
With this:
$ perf probe -V pre_schedule --externs > with.vars
Check the diff:
$ diff without.vars with.vars
88d87
< int cpu
133d131
< long unsigned int* switch_count
These vars are actually in the scope of schedule(), the caller of
pre_schedule().
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20110811110305.19900.94374.stgit@fedora15
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-08-11 15:03:05 +04:00
|
|
|
die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
|
2010-10-21 14:13:35 +04:00
|
|
|
|
|
|
|
out:
|
2010-10-21 14:13:23 +04:00
|
|
|
if (strlist__empty(vl->vars)) {
|
|
|
|
strlist__delete(vl->vars);
|
|
|
|
vl->vars = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find available variables at given probe point */
|
2013-11-05 22:32:36 +04:00
|
|
|
int debuginfo__find_available_vars_at(struct debuginfo *dbg,
|
2011-06-27 11:27:39 +04:00
|
|
|
struct perf_probe_event *pev,
|
|
|
|
struct variable_list **vls,
|
|
|
|
int max_vls, bool externs)
|
2010-10-21 14:13:23 +04:00
|
|
|
{
|
|
|
|
struct available_var_finder af = {
|
|
|
|
.pf = {.pev = pev, .callback = add_available_vars},
|
2013-11-05 22:32:36 +04:00
|
|
|
.mod = dbg->mod,
|
2010-10-21 14:13:35 +04:00
|
|
|
.max_vls = max_vls, .externs = externs};
|
2010-10-21 14:13:23 +04:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Allocate result vls array */
|
|
|
|
*vls = zalloc(sizeof(struct variable_list) * max_vls);
|
|
|
|
if (*vls == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
af.vls = *vls;
|
|
|
|
af.nvls = 0;
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
ret = debuginfo__find_probes(dbg, &af.pf);
|
2010-10-21 14:13:23 +04:00
|
|
|
if (ret < 0) {
|
|
|
|
/* Free vlist for error */
|
|
|
|
while (af.nvls--) {
|
2013-12-27 23:55:14 +04:00
|
|
|
zfree(&af.vls[af.nvls].point.symbol);
|
2013-12-26 22:54:57 +04:00
|
|
|
strlist__delete(af.vls[af.nvls].vars);
|
2010-10-21 14:13:23 +04:00
|
|
|
}
|
2013-12-27 00:41:15 +04:00
|
|
|
zfree(vls);
|
2010-10-21 14:13:23 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (ret < 0) ? ret : af.nvls;
|
2009-10-09 01:17:38 +04:00
|
|
|
}
|
|
|
|
|
2010-03-17 01:06:19 +03:00
|
|
|
/* Reverse search */
|
2013-11-05 22:32:36 +04:00
|
|
|
int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
|
2011-06-27 11:27:39 +04:00
|
|
|
struct perf_probe_point *ppt)
|
2010-03-17 01:06:19 +03:00
|
|
|
{
|
|
|
|
Dwarf_Die cudie, spdie, indie;
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
Dwarf_Addr _addr = 0, baseaddr = 0;
|
|
|
|
const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
int baseline = 0, lineno = 0, ret = 0;
|
2010-03-17 01:06:19 +03:00
|
|
|
|
2010-10-21 14:13:41 +04:00
|
|
|
/* Adjust address with bias */
|
2013-11-05 22:32:36 +04:00
|
|
|
addr += dbg->bias;
|
2011-06-27 11:27:39 +04:00
|
|
|
|
2010-03-17 01:06:19 +03:00
|
|
|
/* Find cu die */
|
2013-11-05 22:32:36 +04:00
|
|
|
if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr - dbg->bias, &cudie)) {
|
2010-12-17 16:12:11 +03:00
|
|
|
pr_warning("Failed to find debug information for address %lx\n",
|
|
|
|
addr);
|
2010-04-02 20:50:59 +04:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto end;
|
|
|
|
}
|
2010-03-17 01:06:19 +03:00
|
|
|
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/* Find a corresponding line (filename and lineno) */
|
|
|
|
cu_find_lineinfo(&cudie, addr, &fname, &lineno);
|
|
|
|
/* Don't care whether it failed or not */
|
2010-03-17 01:06:19 +03:00
|
|
|
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/* Find a corresponding function (name, baseline and baseaddr) */
|
2011-06-27 11:27:27 +04:00
|
|
|
if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/* Get function entry information */
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
func = basefunc = dwarf_diename(&spdie);
|
|
|
|
if (!func ||
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
dwarf_entrypc(&spdie, &baseaddr) != 0 ||
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
dwarf_decl_line(&spdie, &baseline) != 0) {
|
|
|
|
lineno = 0;
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
goto post;
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
}
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
|
2013-10-11 16:23:17 +04:00
|
|
|
fname = dwarf_decl_file(&spdie);
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
if (addr == (unsigned long)baseaddr) {
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/* Function entry - Relative line number is 0 */
|
|
|
|
lineno = baseline;
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
goto post;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Track down the inline functions step by step */
|
|
|
|
while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
|
|
|
|
&indie)) {
|
|
|
|
/* There is an inline function */
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
if (dwarf_entrypc(&indie, &_addr) == 0 &&
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
_addr == addr) {
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/*
|
|
|
|
* addr is at an inline function entry.
|
|
|
|
* In this case, lineno should be the call-site
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
* line number. (overwrite lineinfo)
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
*/
|
|
|
|
lineno = die_get_call_lineno(&indie);
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
fname = die_get_call_file(&indie);
|
|
|
|
break;
|
|
|
|
} else {
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
/*
|
|
|
|
* addr is in an inline function body.
|
|
|
|
* Since lineno points one of the lines
|
|
|
|
* of the inline function, baseline should
|
|
|
|
* be the entry line of the inline function.
|
|
|
|
*/
|
2010-04-12 21:17:35 +04:00
|
|
|
tmp = dwarf_diename(&indie);
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
if (!tmp ||
|
|
|
|
dwarf_decl_line(&indie, &baseline) != 0)
|
|
|
|
break;
|
|
|
|
func = tmp;
|
|
|
|
spdie = indie;
|
2010-04-12 21:17:35 +04:00
|
|
|
}
|
2010-03-17 01:06:19 +03:00
|
|
|
}
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
/* Verify the lineno and baseline are in a same file */
|
|
|
|
tmp = dwarf_decl_file(&spdie);
|
|
|
|
if (!tmp || strcmp(tmp, fname) != 0)
|
|
|
|
lineno = 0;
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
post:
|
|
|
|
/* Make a relative line number or an offset */
|
|
|
|
if (lineno)
|
|
|
|
ppt->line = lineno - baseline;
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
else if (basefunc) {
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
ppt->offset = addr - (unsigned long)baseaddr;
|
perf probe: Fix to find line information for probe list
Fix to find the correct (as much as possible) line information for
listing probes. Without this fix, perf probe --list action will show
incorrect line information as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:-89@x86/include/asm/current.h)
probe:getname_flags_2 (on user_path_at_empty:-2054@x86/include/asm/current.h)
The minus line number is obviously wrong, and current.h is not related
to the probe point. Deeper investigation discovered that there were 2
issues related to this bug, and minor typos too.
The 1st issue is the rack of considering about nested inlined functions,
which causes the wrong (relative) line number.
The 2nd issue is that the dwarf line info is not correct at those
points. It points 14th line of current.h.
Since it seems that the line info includes somewhat unreliable
information, this fixes perf to try to find correct line information
from both of debuginfo and line info as below.
1) Probe address is the entry of a function instance
In this case, the line is set as the function declared line.
2) Probe address is the entry of an expanded inline function block
In this case, the line is set as the function call-site line.
This means that the line number is relative from the entry line
of caller function (which can be an inlined function if nested)
3) Probe address is inside a function instance or an expanded
inline function block
In this case, perf probe queries the line number from lineinfo
and verify the function declared file is same as the file name
queried from lineinfo.
If the file name is different, it is a failure case. The probe
address is shown as symbol+offset.
4) Probe address is not in the any function instance
This is a failure case, the probe address is shown as
symbol+offset.
With this fix, perf probe -l shows correct probe lines as below;
probe:getname_flags (on getname_flags@ksrc/linux-3/fs/namei.c)
probe:getname_flags_1 (on getname:2@ksrc/linux-3/fs/namei.c)
probe:getname_flags_2 (on user_path_at_empty:4@ksrc/linux-3/fs/namei.c)
Changes at v2:
- Fix typos in the function comments. (Thanks to Namhyung Kim)
- Use die_find_top_inlinefunc instead of die_find_inlinefunc_next.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20130930092144.1693.11058.stgit@udc4-manage.rcp.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-09-30 13:21:44 +04:00
|
|
|
func = basefunc;
|
|
|
|
}
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
|
|
|
|
/* Duplicate strings */
|
|
|
|
if (func) {
|
|
|
|
ppt->function = strdup(func);
|
2010-04-12 21:17:56 +04:00
|
|
|
if (ppt->function == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto end;
|
|
|
|
}
|
2010-03-17 01:06:19 +03:00
|
|
|
}
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
if (fname) {
|
|
|
|
ppt->file = strdup(fname);
|
|
|
|
if (ppt->file == NULL) {
|
2013-12-27 00:41:15 +04:00
|
|
|
zfree(&ppt->function);
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
2010-03-17 01:06:19 +03:00
|
|
|
end:
|
perf probe: Fix listing incorrect line number with inline function
Fix a bug showing incorrect line number when a probe is put on the head of an
inline function. This patch updates find_perf_probe_point() and introduces new
rules to get correct line number.
- If debuginfo doesn't have a correct file name, we shouldn't return line
number too, because, without file name, line number is meaningless.
- If the address is in a function, it stores the function name and the offset
from the function entry.
- If the address is on a line, it tries to get the relative line number from
the function entry line, except for the address is same as the entry
address of the function (in this case, the relative line number should
be 0).
- If the address is in an inline function entry (call-site), it uses the
inline function call line number as the line on which the address is.
- If the address is in an inline function body, it stores the inline
function name and offset from the inline function call site instead of the
(non-inlined) function.
Cc: 2nddept-manager@sdl.hitachi.co.jp
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <20110330092605.2132.11629.stgit@ltc236.sdl.hitachi.co.jp>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-30 13:26:05 +04:00
|
|
|
if (ret == 0 && (fname || func))
|
|
|
|
ret = 1; /* Found a point */
|
2010-03-17 01:06:19 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-04-15 02:40:07 +04:00
|
|
|
/* Add a line and store the src path */
|
|
|
|
static int line_range_add_line(const char *src, unsigned int lineno,
|
|
|
|
struct line_range *lr)
|
|
|
|
{
|
2010-07-09 13:28:59 +04:00
|
|
|
/* Copy source path */
|
2010-04-15 02:40:07 +04:00
|
|
|
if (!lr->path) {
|
2010-07-09 13:28:59 +04:00
|
|
|
lr->path = strdup(src);
|
|
|
|
if (lr->path == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-15 02:40:07 +04:00
|
|
|
}
|
2014-02-06 09:32:09 +04:00
|
|
|
return intlist__add(lr->line_list, lineno);
|
2010-04-15 02:40:07 +04:00
|
|
|
}
|
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
static int line_range_walk_cb(const char *fname, int lineno,
|
2012-09-11 02:15:03 +04:00
|
|
|
Dwarf_Addr addr __maybe_unused,
|
2011-01-13 15:45:58 +03:00
|
|
|
void *data)
|
2010-04-15 02:40:07 +04:00
|
|
|
{
|
2011-01-13 15:45:58 +03:00
|
|
|
struct line_finder *lf = data;
|
2014-04-01 08:47:57 +04:00
|
|
|
int err;
|
2010-04-15 02:40:07 +04:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
if ((strtailcmp(fname, lf->fname) != 0) ||
|
2010-04-15 02:40:07 +04:00
|
|
|
(lf->lno_s > lineno || lf->lno_e < lineno))
|
2011-01-13 15:45:58 +03:00
|
|
|
return 0;
|
2010-04-15 02:40:07 +04:00
|
|
|
|
2014-04-01 08:47:57 +04:00
|
|
|
err = line_range_add_line(fname, lineno, lf->lr);
|
|
|
|
if (err < 0 && err != -EEXIST)
|
|
|
|
return err;
|
2010-04-15 02:40:07 +04:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
return 0;
|
2010-04-15 02:40:07 +04:00
|
|
|
}
|
2010-03-17 01:06:19 +03:00
|
|
|
|
2010-01-06 17:45:34 +03:00
|
|
|
/* Find line range from its line number */
|
2010-04-12 21:17:35 +04:00
|
|
|
static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
|
2010-01-06 17:45:34 +03:00
|
|
|
{
|
2011-01-13 15:45:58 +03:00
|
|
|
int ret;
|
2010-04-15 02:40:07 +04:00
|
|
|
|
2011-01-13 15:45:58 +03:00
|
|
|
ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
|
2010-04-15 02:40:07 +04:00
|
|
|
|
2010-02-25 16:35:42 +03:00
|
|
|
/* Update status */
|
2010-04-15 02:40:07 +04:00
|
|
|
if (ret >= 0)
|
2014-02-06 09:32:09 +04:00
|
|
|
if (!intlist__empty(lf->lr->line_list))
|
2010-04-15 02:40:07 +04:00
|
|
|
ret = lf->found = 1;
|
|
|
|
else
|
|
|
|
ret = 0; /* Lines are not found */
|
2010-02-25 16:35:42 +03:00
|
|
|
else {
|
2013-12-27 00:41:15 +04:00
|
|
|
zfree(&lf->lr->path);
|
2010-02-25 16:35:42 +03:00
|
|
|
}
|
2010-04-15 02:40:07 +04:00
|
|
|
return ret;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
|
|
|
|
2010-02-25 16:35:57 +03:00
|
|
|
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
|
|
|
|
{
|
2014-04-02 09:48:31 +04:00
|
|
|
int ret = find_line_range_by_line(in_die, data);
|
2011-08-11 15:02:47 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to check all instances of inlined function, because
|
|
|
|
* some execution paths can be optimized out depends on the
|
2014-04-02 09:48:31 +04:00
|
|
|
* function argument of instances. However, if an error occurs,
|
|
|
|
* it should be handled by the caller.
|
2011-08-11 15:02:47 +04:00
|
|
|
*/
|
2014-04-02 09:48:31 +04:00
|
|
|
return ret < 0 ? ret : 0;
|
2010-02-25 16:35:57 +03:00
|
|
|
}
|
|
|
|
|
2012-04-23 07:24:36 +04:00
|
|
|
/* Search function definition from function name */
|
2010-02-25 16:35:50 +03:00
|
|
|
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
|
2010-01-06 17:45:34 +03:00
|
|
|
{
|
2010-04-12 21:17:35 +04:00
|
|
|
struct dwarf_callback_param *param = data;
|
|
|
|
struct line_finder *lf = param->data;
|
2010-01-06 17:45:34 +03:00
|
|
|
struct line_range *lr = lf->lr;
|
|
|
|
|
2011-03-30 13:25:41 +04:00
|
|
|
/* Check declared file */
|
|
|
|
if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
|
|
|
|
return DWARF_CB_OK;
|
|
|
|
|
2012-04-23 07:24:36 +04:00
|
|
|
if (die_is_func_def(sp_die) &&
|
2010-07-09 13:29:17 +04:00
|
|
|
die_compare_name(sp_die, lr->function)) {
|
2010-02-25 16:35:50 +03:00
|
|
|
lf->fname = dwarf_decl_file(sp_die);
|
|
|
|
dwarf_decl_line(sp_die, &lr->offset);
|
2010-02-25 16:35:42 +03:00
|
|
|
pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
|
2010-01-06 17:45:34 +03:00
|
|
|
lf->lno_s = lr->offset + lr->start;
|
2010-04-15 02:39:42 +04:00
|
|
|
if (lf->lno_s < 0) /* Overflow */
|
|
|
|
lf->lno_s = INT_MAX;
|
|
|
|
lf->lno_e = lr->offset + lr->end;
|
|
|
|
if (lf->lno_e < 0) /* Overflow */
|
2010-02-25 16:35:42 +03:00
|
|
|
lf->lno_e = INT_MAX;
|
2010-04-15 02:39:42 +04:00
|
|
|
pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
|
2010-01-06 17:45:34 +03:00
|
|
|
lr->start = lf->lno_s;
|
|
|
|
lr->end = lf->lno_e;
|
2011-08-11 15:03:11 +04:00
|
|
|
if (dwarf_func_inline(sp_die))
|
|
|
|
param->retval = die_walk_instances(sp_die,
|
|
|
|
line_range_inline_cb, lf);
|
|
|
|
else
|
2010-04-12 21:17:35 +04:00
|
|
|
param->retval = find_line_range_by_line(sp_die, lf);
|
|
|
|
return DWARF_CB_ABORT;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
2010-04-12 21:17:35 +04:00
|
|
|
return DWARF_CB_OK;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
|
|
|
|
2010-04-12 21:17:35 +04:00
|
|
|
static int find_line_range_by_func(struct line_finder *lf)
|
2010-01-06 17:45:34 +03:00
|
|
|
{
|
2010-04-12 21:17:35 +04:00
|
|
|
struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
|
|
|
|
dwarf_getfuncs(&lf->cu_die, line_range_search_cb, ¶m, 0);
|
|
|
|
return param.retval;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
|
2010-01-06 17:45:34 +03:00
|
|
|
{
|
2010-02-25 16:35:42 +03:00
|
|
|
struct line_finder lf = {.lr = lr, .found = 0};
|
2010-04-12 21:17:35 +04:00
|
|
|
int ret = 0;
|
2010-02-25 16:35:42 +03:00
|
|
|
Dwarf_Off off = 0, noff;
|
|
|
|
size_t cuhl;
|
|
|
|
Dwarf_Die *diep;
|
2010-07-09 13:29:11 +04:00
|
|
|
const char *comp_dir;
|
2010-02-25 16:35:42 +03:00
|
|
|
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
/* Fastpath: lookup by function name from .debug_pubnames section */
|
|
|
|
if (lr->function) {
|
|
|
|
struct pubname_callback_param pubname_param = {
|
|
|
|
.function = lr->function, .file = lr->file,
|
|
|
|
.cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
|
|
|
|
struct dwarf_callback_param line_range_param = {
|
|
|
|
.data = (void *)&lf, .retval = 0};
|
|
|
|
|
2013-11-05 22:32:36 +04:00
|
|
|
dwarf_getpubnames(dbg->dbg, pubname_search_cb,
|
2011-06-27 11:27:39 +04:00
|
|
|
&pubname_param, 0);
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
if (pubname_param.found) {
|
|
|
|
line_range_search_cb(&lf.sp_die, &line_range_param);
|
|
|
|
if (lf.found)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-25 16:35:42 +03:00
|
|
|
/* Loop on CUs (Compilation Unit) */
|
2010-04-12 21:17:35 +04:00
|
|
|
while (!lf.found && ret >= 0) {
|
2013-11-05 22:32:36 +04:00
|
|
|
if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
|
2011-06-27 11:27:39 +04:00
|
|
|
NULL, NULL, NULL) != 0)
|
2010-01-06 17:45:34 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Get the DIE(Debugging Information Entry) of this CU */
|
2013-11-05 22:32:36 +04:00
|
|
|
diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
|
2010-02-25 16:35:42 +03:00
|
|
|
if (!diep)
|
|
|
|
continue;
|
2010-01-06 17:45:34 +03:00
|
|
|
|
|
|
|
/* Check if target file is included. */
|
|
|
|
if (lr->file)
|
2010-02-25 16:36:12 +03:00
|
|
|
lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
|
2010-02-25 16:35:42 +03:00
|
|
|
else
|
2010-02-25 16:36:12 +03:00
|
|
|
lf.fname = 0;
|
2010-01-06 17:45:34 +03:00
|
|
|
|
2010-02-25 16:36:12 +03:00
|
|
|
if (!lr->file || lf.fname) {
|
2010-01-06 17:45:34 +03:00
|
|
|
if (lr->function)
|
2010-04-12 21:17:35 +04:00
|
|
|
ret = find_line_range_by_func(&lf);
|
2010-01-06 17:45:34 +03:00
|
|
|
else {
|
|
|
|
lf.lno_s = lr->start;
|
2010-04-15 02:39:42 +04:00
|
|
|
lf.lno_e = lr->end;
|
2010-04-12 21:17:35 +04:00
|
|
|
ret = find_line_range_by_line(NULL, &lf);
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
|
|
|
}
|
2010-02-25 16:35:42 +03:00
|
|
|
off = noff;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
2010-07-09 13:29:11 +04:00
|
|
|
|
perf probe: Add fastpath to do lookup by function name
v3 -> v2:
- Make pubname_search_cb more generic
- Add fastpath to find_probes also
v2 -> v1:
- Don't compare file names with cu_find_realpath(...), instead, compare
them with the name returned by dwarf_decl_file(sp_die)
The vmlinux file may have thousands of CUs.
We can lookup function name from .debug_pubnames section
to avoid the slow loop on CUs.
1. Improvement data for find_line_range
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--line csum_partial_copy_to_user > tmp.log
before patch applied
=====================
847,988,276 cycles
0.355075856 seconds time elapsed
after patch applied
=====================
206,102,622 cycles
0.086883555 seconds time elapsed
2. Improvement data for find_probes
./perf stat -e cycles -r 10 -- ./perf probe -k /home/mlin/vmlinux \
-s /home/mlin/linux-2.6 \
--vars csum_partial_copy_to_user > tmp.log
before patch applied
=====================
848,490,844 cycles
0.355307901 seconds time elapsed
after patch applied
=====================
205,684,469 cycles
0.086694010 seconds time elapsed
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: linux-kernel <linux-kernel@vger.kernel.org>
LKML-Reference: <1301041668.14111.52.camel@minggr.sh.intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-03-25 11:27:48 +03:00
|
|
|
found:
|
2010-07-09 13:29:11 +04:00
|
|
|
/* Store comp_dir */
|
|
|
|
if (lf.found) {
|
|
|
|
comp_dir = cu_get_comp_dir(&lf.cu_die);
|
|
|
|
if (comp_dir) {
|
|
|
|
lr->comp_dir = strdup(comp_dir);
|
|
|
|
if (!lr->comp_dir)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-09 13:28:59 +04:00
|
|
|
pr_debug("path: %s\n", lr->path);
|
2010-04-12 21:17:35 +04:00
|
|
|
return (ret < 0) ? ret : lf.found;
|
2010-01-06 17:45:34 +03:00
|
|
|
}
|
|
|
|
|