by Masami Hiramatsu

[permalink] [raw]

Subject: [tip:perf/core] perf probe: Remove xstrdup()/xstrndup() from util/probe-{event, finder}.c

Commit-ID: 02b95dadc8a1d2c302513e5fa24c492380d26e93
Gitweb: http://git.kernel.org/tip/02b95dadc8a1d2c302513e5fa24c492380d26e93
Author: Masami Hiramatsu <[email protected]>
AuthorDate: Mon, 12 Apr 2010 13:17:56 -0400
Committer: Arnaldo Carvalho de Melo <[email protected]>
CommitDate: Wed, 14 Apr 2010 17:28:52 -0300

perf probe: Remove xstrdup()/xstrndup() from util/probe-{event, finder}.c

Remove all xstr*dup() calls from util/probe-{event,finder}.c since
it may cause 'sudden death' in utility functions and it makes
reusing it from other code difficult.

Cc: Ingo Molnar <[email protected]>
Cc: Paul Mackerras <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Mike Galbraith <[email protected]>
Cc: Frederic Weisbecker <[email protected]>
LKML-Reference: <[email protected]>
Signed-off-by: Masami Hiramatsu <[email protected]>
Signed-off-by: Arnaldo Carvalho de Melo <[email protected]>
---
tools/perf/util/probe-event.c | 159 ++++++++++++++++++++++++++++------------
tools/perf/util/probe-finder.c | 58 +++++++++++----
2 files changed, 156 insertions(+), 61 deletions(-)

diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index aacbf73..ca108b2 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -133,7 +133,9 @@ static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
if (ret <= 0) {
pr_debug("Failed to find corresponding probes from "
"debuginfo. Use kprobe event information.\n");
- pp->function = xstrdup(tp->symbol);
+ pp->function = strdup(tp->symbol);
+ if (pp->function == NULL)
+ return -ENOMEM;
pp->offset = tp->offset;
}
pp->retprobe = tp->retprobe;
@@ -300,7 +302,9 @@ end:
static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
struct perf_probe_point *pp)
{
- pp->function = xstrdup(tp->symbol);
+ pp->function = strdup(tp->symbol);
+ if (pp->function == NULL)
+ return -ENOMEM;
pp->offset = tp->offset;
pp->retprobe = tp->retprobe;

@@ -355,9 +359,12 @@ int parse_line_range_desc(const char *arg, struct line_range *lr)
*tmp);
return -EINVAL;
}
- tmp = xstrndup(arg, (ptr - arg));
+ tmp = strndup(arg, (ptr - arg));
} else
- tmp = xstrdup(arg);
+ tmp = strdup(arg);
+
+ if (tmp == NULL)
+ return -ENOMEM;

if (strchr(tmp, '.'))
lr->file = tmp;
@@ -406,7 +413,9 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
"follow C symbol-naming rule.\n", arg);
return -EINVAL;
}
- pev->event = xstrdup(arg);
+ pev->event = strdup(arg);
+ if (pev->event == NULL)
+ return -ENOMEM;
pev->group = NULL;
arg = tmp;
}
@@ -417,18 +426,24 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
*ptr++ = '\0';
}

+ tmp = strdup(arg);
+ if (tmp == NULL)
+ return -ENOMEM;
+
/* Check arg is function or file and copy it */
- if (strchr(arg, '.')) /* File */
- pp->file = xstrdup(arg);
+ if (strchr(tmp, '.')) /* File */
+ pp->file = tmp;
else /* Function */
- pp->function = xstrdup(arg);
+ pp->function = tmp;

/* Parse other options */
while (ptr) {
arg = ptr;
c = nc;
if (c == ';') { /* Lazy pattern must be the last part */
- pp->lazy_line = xstrdup(arg);
+ pp->lazy_line = strdup(arg);
+ if (pp->lazy_line == NULL)
+ return -ENOMEM;
break;
}
ptr = strpbrk(arg, ";:+@%");
@@ -458,7 +473,9 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
semantic_error("SRC@SRC is not allowed.\n");
return -EINVAL;
}
- pp->file = xstrdup(arg);
+ pp->file = strdup(arg);
+ if (pp->file == NULL)
+ return -ENOMEM;
break;
case '%': /* Probe places */
if (strcmp(arg, "return") == 0) {
@@ -530,7 +547,9 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)

tmp = strchr(str, '=');
if (tmp) {
- arg->name = xstrndup(str, tmp - str);
+ arg->name = strndup(str, tmp - str);
+ if (arg->name == NULL)
+ return -ENOMEM;
pr_debug("name:%s ", arg->name);
str = tmp + 1;
}
@@ -538,20 +557,26 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
tmp = strchr(str, ':');
if (tmp) { /* Type setting */
*tmp = '\0';
- arg->type = xstrdup(tmp + 1);
+ arg->type = strdup(tmp + 1);
+ if (arg->type == NULL)
+ return -ENOMEM;
pr_debug("type:%s ", arg->type);
}

tmp = strpbrk(str, "-.");
if (!is_c_varname(str) || !tmp) {
/* A variable, register, symbol or special value */
- arg->var = xstrdup(str);
+ arg->var = strdup(str);
+ if (arg->var == NULL)
+ return -ENOMEM;
pr_debug("%s\n", arg->var);
return 0;
}

/* Structure fields */
- arg->var = xstrndup(str, tmp - str);
+ arg->var = strndup(str, tmp - str);
+ if (arg->var == NULL)
+ return -ENOMEM;
pr_debug("%s, ", arg->var);
fieldp = &arg->field;

@@ -572,18 +597,24 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)

tmp = strpbrk(str, "-.");
if (tmp) {
- (*fieldp)->name = xstrndup(str, tmp - str);
+ (*fieldp)->name = strndup(str, tmp - str);
+ if ((*fieldp)->name == NULL)
+ return -ENOMEM;
pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
fieldp = &(*fieldp)->next;
}
} while (tmp);
- (*fieldp)->name = xstrdup(str);
+ (*fieldp)->name = strdup(str);
+ if ((*fieldp)->name == NULL)
+ return -ENOMEM;
pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);

/* If no name is specified, set the last field name */
- if (!arg->name)
- arg->name = xstrdup((*fieldp)->name);
-
+ if (!arg->name) {
+ arg->name = strdup((*fieldp)->name);
+ if (arg->name == NULL)
+ return -ENOMEM;
+ }
return 0;
}

@@ -697,9 +728,13 @@ int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
*p++ = '\0';
else
p = argv[i + 2];
- tev->args[i].name = xstrdup(argv[i + 2]);
+ tev->args[i].name = strdup(argv[i + 2]);
/* TODO: parse regs and offset */
- tev->args[i].value = xstrdup(p);
+ tev->args[i].value = strdup(p);
+ if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
+ ret = -ENOMEM;
+ goto out;
+ }
}
ret = 0;
out:
@@ -933,12 +968,14 @@ error:
int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
struct perf_probe_event *pev)
{
- char buf[64];
+ char buf[64] = "";
int i, ret;

/* Convert event/group name */
- pev->event = xstrdup(tev->event);
- pev->group = xstrdup(tev->group);
+ pev->event = strdup(tev->event);
+ pev->group = strdup(tev->group);
+ if (pev->event == NULL || pev->group == NULL)
+ return -ENOMEM;

/* Convert trace_point to probe_point */
ret = convert_to_perf_probe_point(&tev->point, &pev->point);
@@ -950,14 +987,17 @@ int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
if (pev->args == NULL)
return -ENOMEM;
- for (i = 0; i < tev->nargs && ret >= 0; i++)
+ for (i = 0; i < tev->nargs && ret >= 0; i++) {
if (tev->args[i].name)
- pev->args[i].name = xstrdup(tev->args[i].name);
+ pev->args[i].name = strdup(tev->args[i].name);
else {
ret = synthesize_kprobe_trace_arg(&tev->args[i],
buf, 64);
- pev->args[i].name = xstrdup(buf);
+ pev->args[i].name = strdup(buf);
}
+ if (pev->args[i].name == NULL && ret >= 0)
+ ret = -ENOMEM;
+ }

if (ret < 0)
clear_perf_probe_event(pev);
@@ -1282,7 +1322,7 @@ static int __add_kprobe_trace_events(struct perf_probe_event *pev,

ret = 0;
printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
- for (i = 0; i < ntevs && ret >= 0; i++) {
+ for (i = 0; i < ntevs; i++) {
tev = &tevs[i];
if (pev->event)
event = pev->event;
@@ -1303,8 +1343,12 @@ static int __add_kprobe_trace_events(struct perf_probe_event *pev,
break;
event = buf;

- tev->event = xstrdup(event);
- tev->group = xstrdup(group);
+ tev->event = strdup(event);
+ tev->group = strdup(group);
+ if (tev->event == NULL || tev->group == NULL) {
+ ret = -ENOMEM;
+ break;
+ }
ret = write_kprobe_trace_event(fd, tev);
if (ret < 0)
break;
@@ -1360,23 +1404,40 @@ static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
return -ENOMEM;

/* Copy parameters */
- tev->point.symbol = xstrdup(pev->point.function);
+ tev->point.symbol = strdup(pev->point.function);
+ if (tev->point.symbol == NULL) {
+ ret = -ENOMEM;
+ goto error;
+ }
tev->point.offset = pev->point.offset;
tev->nargs = pev->nargs;
if (tev->nargs) {
tev->args = zalloc(sizeof(struct kprobe_trace_arg)
* tev->nargs);
if (tev->args == NULL) {
- free(tev);
- *tevs = NULL;
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto error;
}
for (i = 0; i < tev->nargs; i++) {
- if (pev->args[i].name)
- tev->args[i].name = xstrdup(pev->args[i].name);
- tev->args[i].value = xstrdup(pev->args[i].var);
- if (pev->args[i].type)
- tev->args[i].type = xstrdup(pev->args[i].type);
+ if (pev->args[i].name) {
+ tev->args[i].name = strdup(pev->args[i].name);
+ if (tev->args[i].name == NULL) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ }
+ tev->args[i].value = strdup(pev->args[i].var);
+ if (tev->args[i].value == NULL) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ if (pev->args[i].type) {
+ tev->args[i].type = strdup(pev->args[i].type);
+ if (tev->args[i].type == NULL) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ }
}
}

@@ -1386,13 +1447,15 @@ static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
if (!sym) {
pr_warning("Kernel symbol \'%s\' not found.\n",
tev->point.symbol);
- clear_kprobe_trace_event(tev);
- free(tev);
- *tevs = NULL;
- return -ENOENT;
- } else
- ret = 1;
+ ret = -ENOENT;
+ goto error;
+ }

+ return 1;
+error:
+ clear_kprobe_trace_event(tev);
+ free(tev);
+ *tevs = NULL;
return ret;
}

@@ -1528,7 +1591,11 @@ int del_perf_probe_events(struct strlist *dellist)
return -EINVAL;

strlist__for_each(ent, dellist) {
- str = xstrdup(ent->s);
+ str = strdup(ent->s);
+ if (str == NULL) {
+ ret = -ENOMEM;
+ break;
+ }
pr_debug("Parsing: %s\n", str);
p = strchr(str, ':');
if (p) {
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index ce1ac82..e443e69 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -424,7 +424,10 @@ static int convert_location(Dwarf_Op *op, struct probe_finder *pf)
return -ERANGE;
}

- tvar->value = xstrdup(regs);
+ tvar->value = strdup(regs);
+ if (tvar->value == NULL)
+ return -ENOMEM;
+
if (ref) {
tvar->ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
if (tvar->ref == NULL)
@@ -466,7 +469,9 @@ static int convert_variable_type(Dwarf_Die *vr_die,
strerror(-ret));
return ret;
}
- targ->type = xstrdup(buf);
+ targ->type = strdup(buf);
+ if (targ->type == NULL)
+ return -ENOMEM;
}
return 0;
}
@@ -576,9 +581,11 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
vr_die = &die_mem;
}
if (ret == 0) {
- if (pf->pvar->type)
- pf->tvar->type = xstrdup(pf->pvar->type);
- else
+ if (pf->pvar->type) {
+ pf->tvar->type = strdup(pf->pvar->type);
+ if (pf->tvar->type == NULL)
+ ret = -ENOMEM;
+ } else
ret = convert_variable_type(vr_die, pf->tvar);
}
/* *expr will be cached in libdw. Don't free it. */
@@ -595,22 +602,30 @@ static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
{
Dwarf_Die vr_die;
char buf[32], *ptr;
+ int ret;

/* TODO: Support arrays */
if (pf->pvar->name)
- pf->tvar->name = xstrdup(pf->pvar->name);
+ pf->tvar->name = strdup(pf->pvar->name);
else {
- synthesize_perf_probe_arg(pf->pvar, buf, 32);
+ ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
+ if (ret < 0)
+ return ret;
ptr = strchr(buf, ':'); /* Change type separator to _ */
if (ptr)
*ptr = '_';
- pf->tvar->name = xstrdup(buf);
+ pf->tvar->name = strdup(buf);
}
+ if (pf->tvar->name == NULL)
+ return -ENOMEM;

if (!is_c_varname(pf->pvar->var)) {
/* Copy raw parameters */
- pf->tvar->value = xstrdup(pf->pvar->var);
- return 0;
+ pf->tvar->value = strdup(pf->pvar->var);
+ if (pf->tvar->value == NULL)
+ return -ENOMEM;
+ else
+ return 0;
}

pr_debug("Searching '%s' variable in context.\n",
@@ -660,7 +675,9 @@ static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
dwarf_diename(sp_die));
return -ENOENT;
}
- tev->point.symbol = xstrdup(name);
+ tev->point.symbol = strdup(name);
+ if (tev->point.symbol == NULL)
+ return -ENOMEM;
tev->point.offset = (unsigned long)(pf->addr - eaddr);
} else
/* This function has no name. */
@@ -1028,7 +1045,11 @@ int find_perf_probe_point(int fd, unsigned long addr,
tmp = dwarf_linesrc(line, NULL, NULL);
if (tmp) {
ppt->line = lineno;
- ppt->file = xstrdup(tmp);
+ ppt->file = strdup(tmp);
+ if (ppt->file == NULL) {
+ ret = -ENOMEM;
+ goto end;
+ }
found = true;
}
}
@@ -1064,7 +1085,11 @@ int find_perf_probe_point(int fd, unsigned long addr,
/* We don't have a line number, let's use offset */
ppt->offset = addr - (unsigned long)eaddr;
found:
- ppt->function = xstrdup(tmp);
+ ppt->function = strdup(tmp);
+ if (ppt->function == NULL) {
+ ret = -ENOMEM;
+ goto end;
+ }
found = true;
}

@@ -1116,8 +1141,11 @@ static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
continue;

/* Copy real path */
- if (!lf->lr->path)
- lf->lr->path = xstrdup(src);
+ if (!lf->lr->path) {
+ lf->lr->path = strdup(src);
+ if (lf->lr->path == NULL)
+ return -ENOMEM;
+ }
line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
}
/* Update status */

2010-04-15 07:32:55

by Masami Hiramatsu

[permalink] [raw]

Subject: [tip:perf/core] perf probe: Support DW_OP_call_frame_cfa in debuginfo

Commit-ID: a34a985499895a46a4dacff727d0fbc63cdc75e8
Gitweb: http://git.kernel.org/tip/a34a985499895a46a4dacff727d0fbc63cdc75e8
Author: Masami Hiramatsu <[email protected]>
AuthorDate: Mon, 12 Apr 2010 13:17:29 -0400
Committer: Arnaldo Carvalho de Melo <[email protected]>
CommitDate: Wed, 14 Apr 2010 17:28:20 -0300

perf probe: Support DW_OP_call_frame_cfa in debuginfo

When building kernel without CONFIG_FRAME_POINTER, gcc uses
CFA (canonical frame address) for frame base. With this patch,
perf probe just gets CFI (call frame information) from debuginfo
and search corresponding CFA from the CFI. IOW, this allows
perf probe works correctly on the kernel without CONFIG_FRAME_POINTER.

<Before>
./perf probe -fn sched_slice:12 lw.weight
Fatal: DW_OP 156 is not supported.
(^^^ DW_OP_call_frame_cfa)

<After>
./perf probe -fn sched_slice:12 lw.weight
Add new event:
probe:sched_slice (on sched_slice:12 with weight=lw.weight)

Cc: Ingo Molnar <[email protected]>
Cc: Paul Mackerras <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Mike Galbraith <[email protected]>
Cc: Frederic Weisbecker <[email protected]>
LKML-Reference: <[email protected]>
Signed-off-by: Masami Hiramatsu <[email protected]>
Signed-off-by: Arnaldo Carvalho de Melo <[email protected]>
---
tools/perf/util/probe-finder.c | 14 +++++++++++---
tools/perf/util/probe-finder.h | 1 +
2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index ab47673..1f45285 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -398,7 +398,6 @@ static void convert_location(Dwarf_Op *op, struct probe_finder *pf)
const char *regs;
struct kprobe_trace_arg *tvar = pf->tvar;

- /* TODO: support CFA */
/* If this is based on frame buffer, set the offset */
if (op->atom == DW_OP_fbreg) {
if (pf->fb_ops == NULL)
@@ -629,11 +628,17 @@ static void convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
/* Get the frame base attribute/ops */
dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
- if (ret <= 0 || nops == 0)
+ if (ret <= 0 || nops == 0) {
pf->fb_ops = NULL;
+ } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
+ pf->cfi != NULL) {
+ Dwarf_Frame *frame;
+ ret = dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame);
+ DIE_IF(ret != 0);
+ dwarf_frame_cfa(frame, &pf->fb_ops, &nops);
+ }

/* Find each argument */
- /* TODO: use dwarf_cfi_addrframe */
tev->nargs = pf->pev->nargs;
tev->args = xzalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
for (i = 0; i < pf->pev->nargs; i++) {
@@ -842,6 +847,9 @@ int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
if (!dbg)
return -ENOENT;

+ /* Get the call frame information from this dwarf */
+ pf.cfi = dwarf_getcfi(dbg);
+
off = 0;
line_list__init(&pf.lcache);
/* Loop on CUs (Compilation Unit) */
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 2a27132..310ce89 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -42,6 +42,7 @@ struct probe_finder {
struct list_head lcache; /* Line cache for lazy match */

/* For variable searching */
+ Dwarf_CFI *cfi; /* Call Frame Information */
Dwarf_Op *fb_ops; /* Frame base attribute */
struct perf_probe_arg *pvar; /* Current target variable */
struct kprobe_trace_arg *tvar; /* Current result variable */