2009-10-09 04:17:38 +07:00
|
|
|
/*
|
|
|
|
* builtin-probe.c
|
|
|
|
*
|
|
|
|
* Builtin probe command: Set up probe events by C expression
|
|
|
|
*
|
|
|
|
* 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 <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "perf.h"
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "util/util.h"
|
2009-12-09 05:03:23 +07:00
|
|
|
#include "util/strlist.h"
|
2011-01-20 21:15:39 +07:00
|
|
|
#include "util/strfilter.h"
|
2010-03-17 05:05:37 +07:00
|
|
|
#include "util/symbol.h"
|
2009-10-17 07:08:10 +07:00
|
|
|
#include "util/debug.h"
|
2013-12-09 23:14:23 +07:00
|
|
|
#include <api/fs/debugfs.h>
|
2009-10-09 04:17:38 +07:00
|
|
|
#include "util/parse-options.h"
|
|
|
|
#include "util/probe-finder.h"
|
2009-12-01 07:19:58 +07:00
|
|
|
#include "util/probe-event.h"
|
2009-10-09 04:17:38 +07:00
|
|
|
|
2011-01-20 21:15:39 +07:00
|
|
|
#define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
|
2011-01-20 21:15:45 +07:00
|
|
|
#define DEFAULT_FUNC_FILTER "!_*"
|
2009-10-09 04:17:38 +07:00
|
|
|
|
|
|
|
/* Session management structure */
|
|
|
|
static struct {
|
2009-12-15 22:31:14 +07:00
|
|
|
bool list_events;
|
2009-12-15 22:32:25 +07:00
|
|
|
bool force_add;
|
2010-01-06 21:45:34 +07:00
|
|
|
bool show_lines;
|
2010-10-21 17:13:23 +07:00
|
|
|
bool show_vars;
|
2010-10-21 17:13:35 +07:00
|
|
|
bool show_ext_vars;
|
2011-01-13 19:46:11 +07:00
|
|
|
bool show_funcs;
|
2010-10-21 17:13:23 +07:00
|
|
|
bool mod_events;
|
2012-04-16 19:09:09 +07:00
|
|
|
bool uprobes;
|
2014-10-28 03:31:31 +07:00
|
|
|
bool quiet;
|
2010-03-17 05:06:12 +07:00
|
|
|
int nevents;
|
|
|
|
struct perf_probe_event events[MAX_PROBES];
|
2009-12-09 05:03:23 +07:00
|
|
|
struct strlist *dellist;
|
2010-01-06 21:45:34 +07:00
|
|
|
struct line_range line_range;
|
2014-01-16 16:39:47 +07:00
|
|
|
char *target;
|
2010-04-22 02:56:40 +07:00
|
|
|
int max_probe_points;
|
2011-01-20 21:15:39 +07:00
|
|
|
struct strfilter *filter;
|
2010-03-17 05:05:44 +07:00
|
|
|
} params;
|
2009-10-09 04:17:38 +07:00
|
|
|
|
2009-10-28 03:43:10 +07:00
|
|
|
/* Parse an event definition. Note that any error must die. */
|
2010-04-13 00:17:42 +07:00
|
|
|
static int parse_probe_event(const char *str)
|
2009-10-09 04:17:38 +07:00
|
|
|
{
|
2010-03-17 05:06:12 +07:00
|
|
|
struct perf_probe_event *pev = ¶ms.events[params.nevents];
|
2010-04-13 00:17:42 +07:00
|
|
|
int ret;
|
2009-10-09 04:17:38 +07:00
|
|
|
|
2010-03-17 05:06:12 +07:00
|
|
|
pr_debug("probe-definition(%d): %s\n", params.nevents, str);
|
2010-05-19 08:57:27 +07:00
|
|
|
if (++params.nevents == MAX_PROBES) {
|
|
|
|
pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-10-09 04:17:38 +07:00
|
|
|
|
2012-04-16 19:09:09 +07:00
|
|
|
pev->uprobes = params.uprobes;
|
|
|
|
|
2010-03-17 05:06:12 +07:00
|
|
|
/* Parse a perf-probe command into event */
|
2010-04-13 00:17:42 +07:00
|
|
|
ret = parse_perf_probe_command(str, pev);
|
2010-03-17 05:06:12 +07:00
|
|
|
pr_debug("%d arguments\n", pev->nargs);
|
2010-04-13 00:17:42 +07:00
|
|
|
|
|
|
|
return ret;
|
2009-10-28 03:43:02 +07:00
|
|
|
}
|
|
|
|
|
2012-04-16 19:09:25 +07:00
|
|
|
static int set_target(const char *ptr)
|
|
|
|
{
|
|
|
|
int found = 0;
|
|
|
|
const char *buf;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first argument after options can be an absolute path
|
|
|
|
* to an executable / library or kernel module.
|
|
|
|
*
|
|
|
|
* TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
|
|
|
|
* short module name.
|
|
|
|
*/
|
|
|
|
if (!params.target && ptr && *ptr == '/') {
|
2014-01-16 16:39:47 +07:00
|
|
|
params.target = strdup(ptr);
|
|
|
|
if (!params.target)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-04-16 19:09:25 +07:00
|
|
|
found = 1;
|
|
|
|
buf = ptr + (strlen(ptr) - 3);
|
|
|
|
|
|
|
|
if (strcmp(buf, ".ko"))
|
|
|
|
params.uprobes = true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2010-04-13 00:17:42 +07:00
|
|
|
static int parse_probe_event_argv(int argc, const char **argv)
|
2009-12-09 05:02:54 +07:00
|
|
|
{
|
2012-04-16 19:09:25 +07:00
|
|
|
int i, len, ret, found_target;
|
2009-12-09 05:02:54 +07:00
|
|
|
char *buf;
|
|
|
|
|
2012-04-16 19:09:25 +07:00
|
|
|
found_target = set_target(argv[0]);
|
2014-01-16 16:39:47 +07:00
|
|
|
if (found_target < 0)
|
|
|
|
return found_target;
|
|
|
|
|
2012-04-16 19:09:25 +07:00
|
|
|
if (found_target && argc == 1)
|
|
|
|
return 0;
|
|
|
|
|
2009-12-09 05:02:54 +07:00
|
|
|
/* Bind up rest arguments */
|
|
|
|
len = 0;
|
2012-04-16 19:09:25 +07:00
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (i == 0 && found_target)
|
|
|
|
continue;
|
|
|
|
|
2009-12-09 05:02:54 +07:00
|
|
|
len += strlen(argv[i]) + 1;
|
2012-04-16 19:09:25 +07:00
|
|
|
}
|
2010-05-19 08:57:27 +07:00
|
|
|
buf = zalloc(len + 1);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -ENOMEM;
|
2009-12-09 05:02:54 +07:00
|
|
|
len = 0;
|
2012-04-16 19:09:25 +07:00
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (i == 0 && found_target)
|
|
|
|
continue;
|
|
|
|
|
2009-12-09 05:02:54 +07:00
|
|
|
len += sprintf(&buf[len], "%s ", argv[i]);
|
2012-04-16 19:09:25 +07:00
|
|
|
}
|
2010-10-21 17:13:23 +07:00
|
|
|
params.mod_events = true;
|
2010-04-13 00:17:42 +07:00
|
|
|
ret = parse_probe_event(buf);
|
2009-12-09 05:02:54 +07:00
|
|
|
free(buf);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
2009-12-09 05:02:54 +07:00
|
|
|
}
|
|
|
|
|
2012-09-11 05:15:03 +07:00
|
|
|
static int opt_add_probe_event(const struct option *opt __maybe_unused,
|
|
|
|
const char *str, int unset __maybe_unused)
|
2009-10-28 03:43:02 +07:00
|
|
|
{
|
2010-10-21 17:13:23 +07:00
|
|
|
if (str) {
|
|
|
|
params.mod_events = true;
|
2010-04-13 00:17:42 +07:00
|
|
|
return parse_probe_event(str);
|
2010-10-21 17:13:23 +07:00
|
|
|
} else
|
2010-04-13 00:17:42 +07:00
|
|
|
return 0;
|
2009-10-09 04:17:38 +07:00
|
|
|
}
|
|
|
|
|
2012-09-11 05:15:03 +07:00
|
|
|
static int opt_del_probe_event(const struct option *opt __maybe_unused,
|
|
|
|
const char *str, int unset __maybe_unused)
|
2009-12-09 05:03:23 +07:00
|
|
|
{
|
|
|
|
if (str) {
|
2010-10-21 17:13:23 +07:00
|
|
|
params.mod_events = true;
|
2010-03-17 05:05:44 +07:00
|
|
|
if (!params.dellist)
|
|
|
|
params.dellist = strlist__new(true, NULL);
|
|
|
|
strlist__add(params.dellist, str);
|
2009-12-09 05:03:23 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-16 19:09:09 +07:00
|
|
|
static int opt_set_target(const struct option *opt, const char *str,
|
2012-09-11 05:15:03 +07:00
|
|
|
int unset __maybe_unused)
|
2012-04-16 19:09:09 +07:00
|
|
|
{
|
|
|
|
int ret = -ENOENT;
|
2013-12-26 12:41:50 +07:00
|
|
|
char *tmp;
|
2012-04-16 19:09:09 +07:00
|
|
|
|
|
|
|
if (str && !params.target) {
|
|
|
|
if (!strcmp(opt->long_name, "exec"))
|
|
|
|
params.uprobes = true;
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2012-04-16 19:09:09 +07:00
|
|
|
else if (!strcmp(opt->long_name, "module"))
|
|
|
|
params.uprobes = false;
|
|
|
|
#endif
|
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
|
2013-12-26 12:41:50 +07:00
|
|
|
/* Expand given path to absolute path, except for modulename */
|
|
|
|
if (params.uprobes || strchr(str, '/')) {
|
|
|
|
tmp = realpath(str, NULL);
|
|
|
|
if (!tmp) {
|
|
|
|
pr_warning("Failed to get the absolute path of %s: %m\n", str);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
tmp = strdup(str);
|
|
|
|
if (!tmp)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
params.target = tmp;
|
2012-04-16 19:09:09 +07:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2012-09-11 05:15:03 +07:00
|
|
|
static int opt_show_lines(const struct option *opt __maybe_unused,
|
|
|
|
const char *str, int unset __maybe_unused)
|
2010-01-16 19:31:16 +07:00
|
|
|
{
|
2010-04-13 00:17:42 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-08-11 18:02:53 +07:00
|
|
|
if (!str)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (params.show_lines) {
|
|
|
|
pr_warning("Warning: more than one --line options are"
|
|
|
|
" detected. Only the first one is valid.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-17 05:05:44 +07:00
|
|
|
params.show_lines = true;
|
2011-08-11 18:02:53 +07:00
|
|
|
ret = parse_line_range_desc(str, ¶ms.line_range);
|
2010-04-13 00:17:42 +07:00
|
|
|
|
|
|
|
return ret;
|
2010-01-16 19:31:16 +07:00
|
|
|
}
|
2010-10-21 17:13:23 +07:00
|
|
|
|
2012-09-11 05:15:03 +07:00
|
|
|
static int opt_show_vars(const struct option *opt __maybe_unused,
|
|
|
|
const char *str, int unset __maybe_unused)
|
2010-10-21 17:13:23 +07:00
|
|
|
{
|
|
|
|
struct perf_probe_event *pev = ¶ms.events[params.nevents];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!str)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = parse_probe_event(str);
|
|
|
|
if (!ret && pev->nargs != 0) {
|
|
|
|
pr_err(" Error: '--vars' doesn't accept arguments.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
params.show_vars = true;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2011-01-20 21:15:45 +07:00
|
|
|
#endif
|
2011-01-20 21:15:39 +07:00
|
|
|
|
2012-09-11 05:15:03 +07:00
|
|
|
static int opt_set_filter(const struct option *opt __maybe_unused,
|
|
|
|
const char *str, int unset __maybe_unused)
|
2011-01-20 21:15:39 +07:00
|
|
|
{
|
|
|
|
const char *err;
|
|
|
|
|
|
|
|
if (str) {
|
|
|
|
pr_debug2("Set filter: %s\n", str);
|
|
|
|
if (params.filter)
|
|
|
|
strfilter__delete(params.filter);
|
|
|
|
params.filter = strfilter__new(str, &err);
|
|
|
|
if (!params.filter) {
|
2011-02-01 04:45:38 +07:00
|
|
|
pr_err("Filter parse error at %td.\n", err - str + 1);
|
2011-01-20 21:15:39 +07:00
|
|
|
pr_err("Source: \"%s\"\n", str);
|
|
|
|
pr_err(" %*c\n", (int)(err - str + 1), '^');
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-09 04:17:38 +07:00
|
|
|
|
2014-02-06 12:32:09 +07:00
|
|
|
static int init_params(void)
|
2014-01-16 16:39:47 +07:00
|
|
|
{
|
2014-02-06 12:32:09 +07:00
|
|
|
return line_range__init(¶ms.line_range);
|
2014-01-16 16:39:47 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void cleanup_params(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < params.nevents; i++)
|
|
|
|
clear_perf_probe_event(params.events + i);
|
|
|
|
if (params.dellist)
|
|
|
|
strlist__delete(params.dellist);
|
|
|
|
line_range__clear(¶ms.line_range);
|
|
|
|
free(params.target);
|
|
|
|
if (params.filter)
|
|
|
|
strfilter__delete(params.filter);
|
|
|
|
memset(¶ms, 0, sizeof(params));
|
|
|
|
}
|
|
|
|
|
2014-06-06 14:13:52 +07:00
|
|
|
static void pr_err_with_code(const char *msg, int err)
|
|
|
|
{
|
2014-08-14 09:22:34 +07:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
|
|
|
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err("%s", msg);
|
2014-08-14 09:22:34 +07:00
|
|
|
pr_debug(" Reason: %s (Code: %d)",
|
|
|
|
strerror_r(-err, sbuf, sizeof(sbuf)), err);
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err("\n");
|
|
|
|
}
|
|
|
|
|
2014-01-16 16:39:47 +07:00
|
|
|
static int
|
|
|
|
__cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
|
2012-10-02 01:20:58 +07:00
|
|
|
{
|
|
|
|
const char * const probe_usage[] = {
|
|
|
|
"perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
|
|
|
|
"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
|
|
|
|
"perf probe [<options>] --del '[GROUP:]EVENT' ...",
|
|
|
|
"perf probe --list",
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2012-10-02 01:20:58 +07:00
|
|
|
"perf probe [<options>] --line 'LINEDESC'",
|
|
|
|
"perf probe [<options>] --vars 'PROBEPOINT'",
|
2010-02-25 20:35:12 +07:00
|
|
|
#endif
|
2012-10-02 01:20:58 +07:00
|
|
|
NULL
|
2009-10-09 04:17:38 +07:00
|
|
|
};
|
2014-10-22 22:15:49 +07:00
|
|
|
struct option options[] = {
|
2010-04-13 15:37:33 +07:00
|
|
|
OPT_INCR('v', "verbose", &verbose,
|
2009-10-17 07:08:10 +07:00
|
|
|
"be more verbose (show parsed arguments, etc)"),
|
2014-10-28 03:31:31 +07:00
|
|
|
OPT_BOOLEAN('q', "quiet", ¶ms.quiet,
|
|
|
|
"be quiet (do not show any mesages)"),
|
2010-03-17 05:05:44 +07:00
|
|
|
OPT_BOOLEAN('l', "list", ¶ms.list_events,
|
2009-12-15 22:31:14 +07:00
|
|
|
"list up current probe events"),
|
2009-12-09 05:03:23 +07:00
|
|
|
OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
|
|
|
|
opt_del_probe_event),
|
2009-10-28 03:43:02 +07:00
|
|
|
OPT_CALLBACK('a', "add", NULL,
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2010-03-04 10:38:43 +07:00
|
|
|
"[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
|
2010-04-13 00:16:53 +07:00
|
|
|
" [[NAME=]ARG ...]",
|
2010-03-22 23:10:26 +07:00
|
|
|
#else
|
2010-04-13 00:16:53 +07:00
|
|
|
"[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
|
2009-10-08 05:28:30 +07:00
|
|
|
#endif
|
2009-10-09 04:17:38 +07:00
|
|
|
"probe point definition, where\n"
|
2009-12-15 22:32:18 +07:00
|
|
|
"\t\tGROUP:\tGroup name (optional)\n"
|
|
|
|
"\t\tEVENT:\tEvent name\n"
|
2009-10-09 04:17:38 +07:00
|
|
|
"\t\tFUNC:\tFunction name\n"
|
2010-02-25 20:36:12 +07:00
|
|
|
"\t\tOFF:\tOffset from function entry (in byte)\n"
|
2009-10-28 03:43:10 +07:00
|
|
|
"\t\t%return:\tPut the probe at function return\n"
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2009-10-09 04:17:38 +07:00
|
|
|
"\t\tSRC:\tSource code path\n"
|
2010-02-25 20:36:12 +07:00
|
|
|
"\t\tRL:\tRelative line number from function entry.\n"
|
|
|
|
"\t\tAL:\tAbsolute line number in file.\n"
|
|
|
|
"\t\tPT:\tLazy expression of line code.\n"
|
2009-10-09 04:17:38 +07:00
|
|
|
"\t\tARG:\tProbe argument (local variable name or\n"
|
2009-12-01 07:19:58 +07:00
|
|
|
"\t\t\tkprobe-tracer argument format.)\n",
|
2010-03-22 23:10:26 +07:00
|
|
|
#else
|
|
|
|
"\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
|
|
|
|
#endif
|
2009-10-28 03:43:10 +07:00
|
|
|
opt_add_probe_event),
|
2010-03-17 05:05:44 +07:00
|
|
|
OPT_BOOLEAN('f', "force", ¶ms.force_add, "forcibly add events"
|
2009-12-15 22:32:25 +07:00
|
|
|
" with existing name"),
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2010-01-06 21:45:34 +07:00
|
|
|
OPT_CALLBACK('L', "line", NULL,
|
2010-04-02 23:50:39 +07:00
|
|
|
"FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
|
2010-01-06 21:45:34 +07:00
|
|
|
"Show source code lines.", opt_show_lines),
|
2010-10-21 17:13:23 +07:00
|
|
|
OPT_CALLBACK('V', "vars", NULL,
|
|
|
|
"FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
|
|
|
|
"Show accessible variables on PROBEDEF", opt_show_vars),
|
2010-10-21 17:13:35 +07:00
|
|
|
OPT_BOOLEAN('\0', "externs", ¶ms.show_ext_vars,
|
|
|
|
"Show external variables too (with --vars only)"),
|
2010-03-22 23:10:26 +07:00
|
|
|
OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
|
|
|
|
"file", "vmlinux pathname"),
|
2010-06-15 02:26:30 +07:00
|
|
|
OPT_STRING('s', "source", &symbol_conf.source_prefix,
|
|
|
|
"directory", "path to kernel source"),
|
2012-04-16 19:09:09 +07:00
|
|
|
OPT_CALLBACK('m', "module", NULL, "modname|path",
|
|
|
|
"target module name (for online) or path (for offline)",
|
|
|
|
opt_set_target),
|
2010-01-06 21:45:34 +07:00
|
|
|
#endif
|
2010-03-17 05:06:05 +07:00
|
|
|
OPT__DRY_RUN(&probe_event_dry_run),
|
2010-04-22 02:56:40 +07:00
|
|
|
OPT_INTEGER('\0', "max-probes", ¶ms.max_probe_points,
|
|
|
|
"Set how many probe points can be found for a probe."),
|
2011-01-13 19:46:11 +07:00
|
|
|
OPT_BOOLEAN('F', "funcs", ¶ms.show_funcs,
|
|
|
|
"Show potential probe-able functions."),
|
2011-01-20 21:15:45 +07:00
|
|
|
OPT_CALLBACK('\0', "filter", NULL,
|
|
|
|
"[!]FILTER", "Set a filter (with --vars/funcs only)\n"
|
|
|
|
"\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
|
|
|
|
"\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
|
|
|
|
opt_set_filter),
|
2012-04-16 19:09:09 +07:00
|
|
|
OPT_CALLBACK('x', "exec", NULL, "executable|path",
|
|
|
|
"target executable name or path", opt_set_target),
|
2013-10-28 15:04:24 +07:00
|
|
|
OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
|
2014-10-28 03:31:24 +07:00
|
|
|
"Enable symbol demangling"),
|
2014-09-13 11:15:05 +07:00
|
|
|
OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
|
|
|
|
"Enable kernel symbol demangling"),
|
2009-10-09 04:17:38 +07:00
|
|
|
OPT_END()
|
2012-10-02 01:20:58 +07:00
|
|
|
};
|
2010-04-13 00:17:42 +07:00
|
|
|
int ret;
|
|
|
|
|
2014-10-22 22:15:49 +07:00
|
|
|
set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE);
|
|
|
|
set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE);
|
|
|
|
set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE);
|
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
|
|
|
set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE);
|
|
|
|
set_option_flag(options, 'V', "vars", PARSE_OPT_EXCLUSIVE);
|
|
|
|
#endif
|
|
|
|
|
2009-10-09 04:17:38 +07:00
|
|
|
argc = parse_options(argc, argv, options, probe_usage,
|
2009-10-28 03:43:02 +07:00
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
2009-12-15 22:31:28 +07:00
|
|
|
if (argc > 0) {
|
|
|
|
if (strcmp(argv[0], "-") == 0) {
|
|
|
|
pr_warning(" Error: '-' is not supported.\n");
|
|
|
|
usage_with_options(probe_usage, options);
|
|
|
|
}
|
2010-04-13 00:17:42 +07:00
|
|
|
ret = parse_probe_event_argv(argc, argv);
|
|
|
|
if (ret < 0) {
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Command Parse Error.", ret);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2009-12-15 22:31:28 +07:00
|
|
|
}
|
2009-10-28 03:43:02 +07:00
|
|
|
|
2014-10-28 03:31:31 +07:00
|
|
|
if (params.quiet) {
|
|
|
|
if (verbose != 0) {
|
|
|
|
pr_err(" Error: -v and -q are exclusive.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
verbose = -1;
|
|
|
|
}
|
|
|
|
|
2010-04-22 02:56:40 +07:00
|
|
|
if (params.max_probe_points == 0)
|
|
|
|
params.max_probe_points = MAX_PROBES;
|
|
|
|
|
2010-03-17 05:06:12 +07:00
|
|
|
if ((!params.nevents && !params.dellist && !params.list_events &&
|
2011-01-13 19:46:11 +07:00
|
|
|
!params.show_lines && !params.show_funcs))
|
2009-10-09 04:17:38 +07:00
|
|
|
usage_with_options(probe_usage, options);
|
|
|
|
|
2010-12-10 20:06:03 +07:00
|
|
|
/*
|
|
|
|
* Only consider the user's kernel image path if given.
|
|
|
|
*/
|
|
|
|
symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
|
|
|
|
|
2010-03-17 05:05:44 +07:00
|
|
|
if (params.list_events) {
|
2012-04-16 19:09:09 +07:00
|
|
|
if (params.uprobes) {
|
|
|
|
pr_warning(" Error: Don't use --list with --exec.\n");
|
|
|
|
usage_with_options(probe_usage, options);
|
|
|
|
}
|
2010-04-13 00:17:42 +07:00
|
|
|
ret = show_perf_probe_events();
|
|
|
|
if (ret < 0)
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to show event list.", ret);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
2009-12-01 07:20:17 +07:00
|
|
|
}
|
2011-01-13 19:46:11 +07:00
|
|
|
if (params.show_funcs) {
|
2011-01-20 21:15:45 +07:00
|
|
|
if (!params.filter)
|
|
|
|
params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
|
|
|
|
NULL);
|
2012-04-16 19:09:09 +07:00
|
|
|
ret = show_available_funcs(params.target, params.filter,
|
|
|
|
params.uprobes);
|
2011-01-20 21:15:45 +07:00
|
|
|
strfilter__delete(params.filter);
|
2014-01-16 16:39:47 +07:00
|
|
|
params.filter = NULL;
|
2011-01-13 19:46:11 +07:00
|
|
|
if (ret < 0)
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to show functions.", ret);
|
2011-01-13 19:46:11 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2009-12-01 07:20:17 +07:00
|
|
|
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
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 12:41:53 +07:00
|
|
|
if (params.show_lines) {
|
2014-09-17 15:40:54 +07:00
|
|
|
ret = show_line_range(¶ms.line_range, params.target,
|
|
|
|
params.uprobes);
|
2010-04-13 00:17:42 +07:00
|
|
|
if (ret < 0)
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to show lines.", ret);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
2010-01-06 21:45:34 +07:00
|
|
|
}
|
2010-10-21 17:13:23 +07:00
|
|
|
if (params.show_vars) {
|
2011-01-20 21:15:39 +07:00
|
|
|
if (!params.filter)
|
|
|
|
params.filter = strfilter__new(DEFAULT_VAR_FILTER,
|
|
|
|
NULL);
|
|
|
|
|
2010-10-21 17:13:23 +07:00
|
|
|
ret = show_available_vars(params.events, params.nevents,
|
2010-10-21 17:13:35 +07:00
|
|
|
params.max_probe_points,
|
2012-02-02 21:20:40 +07:00
|
|
|
params.target,
|
2011-01-20 21:15:39 +07:00
|
|
|
params.filter,
|
2010-10-21 17:13:35 +07:00
|
|
|
params.show_ext_vars);
|
2011-01-20 21:15:39 +07:00
|
|
|
strfilter__delete(params.filter);
|
2014-01-16 16:39:47 +07:00
|
|
|
params.filter = NULL;
|
2010-10-21 17:13:23 +07:00
|
|
|
if (ret < 0)
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to show vars.", ret);
|
2010-10-21 17:13:23 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2010-01-06 21:45:34 +07:00
|
|
|
#endif
|
|
|
|
|
2010-03-17 05:05:44 +07:00
|
|
|
if (params.dellist) {
|
2010-04-13 00:17:42 +07:00
|
|
|
ret = del_perf_probe_events(params.dellist);
|
|
|
|
if (ret < 0) {
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to delete events.", ret);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2009-12-09 05:03:23 +07:00
|
|
|
}
|
|
|
|
|
2010-04-13 00:17:42 +07:00
|
|
|
if (params.nevents) {
|
|
|
|
ret = add_perf_probe_events(params.events, params.nevents,
|
2010-10-21 17:13:29 +07:00
|
|
|
params.max_probe_points,
|
2012-02-02 21:20:40 +07:00
|
|
|
params.target,
|
2010-10-21 17:13:29 +07:00
|
|
|
params.force_add);
|
2010-04-13 00:17:42 +07:00
|
|
|
if (ret < 0) {
|
2014-06-06 14:13:52 +07:00
|
|
|
pr_err_with_code(" Error: Failed to add events.", ret);
|
2010-04-13 00:17:42 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2009-10-09 04:17:38 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2014-01-16 16:39:47 +07:00
|
|
|
|
|
|
|
int cmd_probe(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-02-06 12:32:09 +07:00
|
|
|
ret = init_params();
|
|
|
|
if (!ret) {
|
|
|
|
ret = __cmd_probe(argc, argv, prefix);
|
|
|
|
cleanup_params();
|
|
|
|
}
|
2014-01-16 16:39:47 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|