2009-11-30 17:19:58 -07:00
|
|
|
/*
|
2010-07-29 08:13:51 -06:00
|
|
|
* probe-event.c : perf-probe definition to probe_events format converter
|
2009-11-30 17:19:58 -07:00
|
|
|
*
|
|
|
|
* 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>
|
2009-11-30 17:20:17 -07:00
|
|
|
#include <stdarg.h>
|
|
|
|
#include <limits.h>
|
2011-01-13 05:46:11 -07:00
|
|
|
#include <elf.h>
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-03-16 16:05:30 -06:00
|
|
|
#include "util.h"
|
2009-11-30 17:19:58 -07:00
|
|
|
#include "event.h"
|
2009-11-30 17:20:17 -07:00
|
|
|
#include "strlist.h"
|
2009-11-30 17:19:58 -07:00
|
|
|
#include "debug.h"
|
2010-01-05 15:47:10 -07:00
|
|
|
#include "cache.h"
|
2010-01-06 07:45:34 -07:00
|
|
|
#include "color.h"
|
2010-03-16 16:05:37 -06:00
|
|
|
#include "symbol.h"
|
|
|
|
#include "thread.h"
|
2013-12-09 09:14:23 -07:00
|
|
|
#include <api/fs/debugfs.h>
|
2012-09-10 16:15:03 -06:00
|
|
|
#include "trace-event.h" /* For __maybe_unused */
|
2009-11-30 17:19:58 -07:00
|
|
|
#include "probe-event.h"
|
2010-03-16 16:06:12 -06:00
|
|
|
#include "probe-finder.h"
|
2012-04-16 06:09:09 -06:00
|
|
|
#include "session.h"
|
2009-11-30 17:19:58 -07:00
|
|
|
|
|
|
|
#define MAX_CMDLEN 256
|
|
|
|
#define PERFPROBE_GROUP "probe"
|
|
|
|
|
2010-03-16 16:06:05 -06:00
|
|
|
bool probe_event_dry_run; /* Dry run flag */
|
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
#define semantic_error(msg ...) pr_err("Semantic error :" msg)
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2009-11-30 17:20:17 -07:00
|
|
|
/* If there is no space to write, returns -E2BIG. */
|
2009-12-07 10:00:53 -07:00
|
|
|
static int e_snprintf(char *str, size_t size, const char *format, ...)
|
|
|
|
__attribute__((format(printf, 3, 4)));
|
|
|
|
|
2009-11-30 17:20:17 -07:00
|
|
|
static int e_snprintf(char *str, size_t size, const char *format, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
ret = vsnprintf(str, size, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (ret >= (int)size)
|
|
|
|
ret = -E2BIG;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
|
2014-01-16 02:39:44 -07:00
|
|
|
static void clear_probe_trace_event(struct probe_trace_event *tev);
|
2014-02-05 22:32:04 -07:00
|
|
|
static struct machine *host_machine;
|
2010-03-16 16:05:37 -06:00
|
|
|
|
2010-10-21 04:13:41 -06:00
|
|
|
/* Initialize symbol maps and path of vmlinux/modules */
|
2014-02-05 22:32:04 -07:00
|
|
|
static int init_symbol_maps(bool user_only)
|
2010-03-16 16:05:37 -06:00
|
|
|
{
|
2010-04-12 11:17:42 -06:00
|
|
|
int ret;
|
|
|
|
|
2010-03-16 16:05:37 -06:00
|
|
|
symbol_conf.sort_by_name = true;
|
2014-08-12 00:40:45 -06:00
|
|
|
ret = symbol__init(NULL);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
pr_debug("Failed to init symbol map.\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-03-16 16:05:37 -06:00
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
if (host_machine || user_only) /* already initialized */
|
|
|
|
return 0;
|
2010-04-27 18:20:43 -06:00
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
if (symbol_conf.vmlinux_name)
|
|
|
|
pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
|
|
|
|
|
|
|
|
host_machine = machine__new_host();
|
|
|
|
if (!host_machine) {
|
|
|
|
pr_debug("machine__new_host() failed.\n");
|
|
|
|
symbol__exit();
|
|
|
|
ret = -1;
|
2010-10-21 04:13:41 -06:00
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
out:
|
|
|
|
if (ret < 0)
|
|
|
|
pr_warning("Failed to init vmlinux path.\n");
|
|
|
|
return ret;
|
2010-03-16 16:05:37 -06:00
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
static void exit_symbol_maps(void)
|
|
|
|
{
|
|
|
|
if (host_machine) {
|
|
|
|
machine__delete(host_machine);
|
|
|
|
host_machine = NULL;
|
|
|
|
}
|
|
|
|
symbol__exit();
|
|
|
|
}
|
|
|
|
|
2010-10-21 04:13:41 -06:00
|
|
|
static struct symbol *__find_kernel_function_by_name(const char *name,
|
|
|
|
struct map **mapp)
|
|
|
|
{
|
2014-02-05 22:32:04 -07:00
|
|
|
return machine__find_kernel_function_by_name(host_machine, name, mapp,
|
2010-10-21 04:13:41 -06:00
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:20 -07:00
|
|
|
static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
|
|
|
|
{
|
|
|
|
return machine__find_kernel_function(host_machine, addr, mapp, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
|
|
|
|
{
|
|
|
|
/* kmap->ref_reloc_sym should be set if host_machine is initialized */
|
|
|
|
struct kmap *kmap;
|
|
|
|
|
|
|
|
if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
|
|
|
|
return kmap->ref_reloc_sym;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
|
|
|
|
{
|
|
|
|
struct ref_reloc_sym *reloc_sym;
|
|
|
|
struct symbol *sym;
|
|
|
|
struct map *map;
|
|
|
|
|
|
|
|
/* ref_reloc_sym is just a label. Need a special fix*/
|
|
|
|
reloc_sym = kernel_get_ref_reloc_sym();
|
|
|
|
if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
|
|
|
|
return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
|
|
|
|
else {
|
|
|
|
sym = __find_kernel_function_by_name(name, &map);
|
|
|
|
if (sym)
|
|
|
|
return map->unmap_ip(map, sym->start) -
|
|
|
|
(reloc) ? 0 : map->reloc;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-13 05:46:11 -07:00
|
|
|
static struct map *kernel_get_module_map(const char *module)
|
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
2014-02-05 22:32:04 -07:00
|
|
|
struct map_groups *grp = &host_machine->kmaps;
|
2011-01-13 05:46:11 -07:00
|
|
|
|
2011-06-27 01:27:51 -06:00
|
|
|
/* A file path -- this is an offline module */
|
|
|
|
if (module && strchr(module, '/'))
|
2014-02-05 22:32:04 -07:00
|
|
|
return machine__new_module(host_machine, 0, module);
|
2011-06-27 01:27:51 -06:00
|
|
|
|
2011-01-13 05:46:11 -07:00
|
|
|
if (!module)
|
|
|
|
module = "kernel";
|
|
|
|
|
|
|
|
for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
|
|
|
|
struct map *pos = rb_entry(nd, struct map, rb_node);
|
|
|
|
if (strncmp(pos->dso->short_name + 1, module,
|
|
|
|
pos->dso->short_name_len - 2) == 0) {
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dso *kernel_get_module_dso(const char *module)
|
2010-10-21 04:13:41 -06:00
|
|
|
{
|
|
|
|
struct dso *dso;
|
2010-12-10 06:06:03 -07:00
|
|
|
struct map *map;
|
|
|
|
const char *vmlinux_name;
|
2010-10-21 04:13:41 -06:00
|
|
|
|
|
|
|
if (module) {
|
2014-09-29 14:07:28 -06:00
|
|
|
list_for_each_entry(dso, &host_machine->kernel_dsos.head,
|
|
|
|
node) {
|
2010-10-21 04:13:41 -06:00
|
|
|
if (strncmp(dso->short_name + 1, module,
|
|
|
|
dso->short_name_len - 2) == 0)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
pr_debug("Failed to find module %s.\n", module);
|
|
|
|
return NULL;
|
2010-12-10 06:06:03 -07:00
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
map = host_machine->vmlinux_maps[MAP__FUNCTION];
|
2010-12-10 06:06:03 -07:00
|
|
|
dso = map->dso;
|
|
|
|
|
|
|
|
vmlinux_name = symbol_conf.vmlinux_name;
|
|
|
|
if (vmlinux_name) {
|
2013-12-10 07:58:52 -07:00
|
|
|
if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
|
2010-12-10 06:06:03 -07:00
|
|
|
return NULL;
|
2010-10-21 04:13:41 -06:00
|
|
|
} else {
|
2010-12-10 06:07:14 -07:00
|
|
|
if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
|
2010-10-21 04:13:41 -06:00
|
|
|
pr_debug("Failed to load kernel map.\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
found:
|
2011-01-13 05:46:11 -07:00
|
|
|
return dso;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *kernel_get_module_path(const char *module)
|
|
|
|
{
|
|
|
|
struct dso *dso = kernel_get_module_dso(module);
|
|
|
|
return (dso) ? dso->long_name : NULL;
|
2010-10-21 04:13:41 -06:00
|
|
|
}
|
|
|
|
|
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-25 22:41:53 -07:00
|
|
|
static int convert_exec_to_group(const char *exec, char **result)
|
|
|
|
{
|
|
|
|
char *ptr1, *ptr2, *exec_copy;
|
|
|
|
char buf[64];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
exec_copy = strdup(exec);
|
|
|
|
if (!exec_copy)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ptr1 = basename(exec_copy);
|
|
|
|
if (!ptr1) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr2 = strpbrk(ptr1, "-._");
|
|
|
|
if (ptr2)
|
|
|
|
*ptr2 = '\0';
|
|
|
|
ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
*result = strdup(buf);
|
|
|
|
ret = *result ? 0 : -ENOMEM;
|
|
|
|
|
|
|
|
out:
|
|
|
|
free(exec_copy);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs; i++)
|
|
|
|
clear_probe_trace_event(tevs + i);
|
|
|
|
}
|
|
|
|
|
2013-09-30 04:07:11 -06:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2014-02-05 22:32:27 -07:00
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
/* Open new debuginfo of given module */
|
2014-08-14 19:44:32 -06:00
|
|
|
static struct debuginfo *open_debuginfo(const char *module, bool silent)
|
2010-03-16 16:05:37 -06:00
|
|
|
{
|
2014-02-05 22:32:27 -07:00
|
|
|
const char *path = module;
|
2014-08-14 19:44:32 -06:00
|
|
|
struct debuginfo *ret;
|
2011-06-27 01:27:39 -06:00
|
|
|
|
2014-02-05 22:32:27 -07:00
|
|
|
if (!module || !strchr(module, '/')) {
|
2011-06-27 01:27:51 -06:00
|
|
|
path = kernel_get_module_path(module);
|
|
|
|
if (!path) {
|
2014-08-14 19:44:32 -06:00
|
|
|
if (!silent)
|
|
|
|
pr_err("Failed to find path of %s module.\n",
|
|
|
|
module ?: "kernel");
|
2011-06-27 01:27:51 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-03-16 16:05:37 -06:00
|
|
|
}
|
2014-08-14 19:44:32 -06:00
|
|
|
ret = debuginfo__new(path);
|
|
|
|
if (!ret && !silent) {
|
|
|
|
pr_warning("The %s file has no debug information.\n", path);
|
|
|
|
if (!module || !strtailcmp(path, ".ko"))
|
|
|
|
pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
|
|
|
|
else
|
|
|
|
pr_warning("Rebuild with -g, ");
|
|
|
|
pr_warning("or install an appropriate debuginfo package.\n");
|
|
|
|
}
|
|
|
|
return ret;
|
2010-03-16 16:05:37 -06:00
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2014-08-14 19:44:32 -06:00
|
|
|
|
2014-01-16 02:39:49 -07:00
|
|
|
static int get_text_start_address(const char *exec, unsigned long *address)
|
|
|
|
{
|
|
|
|
Elf *elf;
|
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
int fd, ret = -ENOENT;
|
|
|
|
|
|
|
|
fd = open(exec, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
|
|
|
if (elf == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (gelf_getehdr(elf, &ehdr) == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
*address = shdr.sh_addr - shdr.sh_offset;
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
elf_end(elf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:23 -07:00
|
|
|
/*
|
|
|
|
* Convert trace point to probe point with debuginfo
|
|
|
|
*/
|
|
|
|
static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
|
|
|
|
struct perf_probe_point *pp,
|
|
|
|
bool is_kprobe)
|
|
|
|
{
|
|
|
|
struct debuginfo *dinfo = NULL;
|
|
|
|
unsigned long stext = 0;
|
|
|
|
u64 addr = tp->address;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
/* convert the address to dwarf address */
|
|
|
|
if (!is_kprobe) {
|
|
|
|
if (!addr) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ret = get_text_start_address(tp->module, &stext);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
addr += stext;
|
|
|
|
} else {
|
|
|
|
addr = kernel_get_symbol_address_by_name(tp->symbol, false);
|
|
|
|
if (addr == 0)
|
|
|
|
goto error;
|
|
|
|
addr += tp->offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
|
|
|
|
tp->module ? : "kernel");
|
|
|
|
|
2014-08-14 19:44:32 -06:00
|
|
|
dinfo = open_debuginfo(tp->module, verbose == 0);
|
2014-02-05 22:32:23 -07:00
|
|
|
if (dinfo) {
|
|
|
|
ret = debuginfo__find_probe_point(dinfo,
|
|
|
|
(unsigned long)addr, pp);
|
|
|
|
debuginfo__delete(dinfo);
|
2014-08-14 19:44:32 -06:00
|
|
|
} else
|
2014-02-05 22:32:23 -07:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
pp->retprobe = tp->retprobe;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
error:
|
|
|
|
pr_debug("Failed to find corresponding probes from debuginfo.\n");
|
|
|
|
return ret ? : -ENOENT;
|
|
|
|
}
|
|
|
|
|
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-25 22:41:53 -07:00
|
|
|
static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs, const char *exec)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
unsigned long stext = 0;
|
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-25 22:41:53 -07:00
|
|
|
|
|
|
|
if (!exec)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = get_text_start_address(exec, &stext);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs && ret >= 0; i++) {
|
2014-02-04 22:18:58 -07:00
|
|
|
/* point.address is the addres of point.symbol + point.offset */
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
tevs[i].point.address -= stext;
|
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-25 22:41:53 -07:00
|
|
|
tevs[i].point.module = strdup(exec);
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if (!tevs[i].point.module) {
|
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-25 22:41:53 -07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tevs[i].uprobes = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-27 01:27:45 -06:00
|
|
|
static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs, const char *module)
|
|
|
|
{
|
2011-06-27 01:27:51 -06:00
|
|
|
int i, ret = 0;
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
if (!module)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tmp = strrchr(module, '/');
|
|
|
|
if (tmp) {
|
|
|
|
/* This is a module path -- get the module name */
|
|
|
|
module = strdup(tmp + 1);
|
|
|
|
if (!module)
|
|
|
|
return -ENOMEM;
|
|
|
|
tmp = strchr(module, '.');
|
|
|
|
if (tmp)
|
|
|
|
*tmp = '\0';
|
|
|
|
tmp = (char *)module; /* For free() */
|
|
|
|
}
|
|
|
|
|
2011-06-27 01:27:45 -06:00
|
|
|
for (i = 0; i < ntevs; i++) {
|
|
|
|
tevs[i].point.module = strdup(module);
|
2011-06-27 01:27:51 -06:00
|
|
|
if (!tevs[i].point.module) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-27 01:27:45 -06:00
|
|
|
}
|
2011-06-27 01:27:51 -06:00
|
|
|
|
2013-12-26 11:54:57 -07:00
|
|
|
free(tmp);
|
2011-06-27 01:27:51 -06:00
|
|
|
return ret;
|
2011-06-27 01:27:45 -06:00
|
|
|
}
|
|
|
|
|
perf probe: Use ref_reloc_sym based address instead of the symbol name
Since several local symbols can have same name (e.g. t_show), we need to
use the relative address from the symbol referred by kmap->ref_reloc_sym
instead of the target symbol name itself.
Because the kernel address space layout randomize (kASLR) changes the
absolute address of kernel symbols, we can't rely on the absolute
address.
Note that this works only with debuginfo.
E.g. without this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
----
OK, we have 4 different t_show()s. All functions have
different arguments as below;
----
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show t_show m=%di:u64 v=%si:u64
p:probe/t_show_1 t_show m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 t_show m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 t_show m=%di:u64 v=%si:u64 file=%si:u64
----
However, all of them have been put on the *same* address.
----
# cat /sys/kernel/debug/kprobes/list
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
----
With this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show _stext+889880 m=%di:u64 v=%si:u64
p:probe/t_show_1 _stext+928568 m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 _stext+969512 m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 _stext+1001416 m=%di:u64 v=%si:u64 file=%si:u64
# cat /sys/kernel/debug/kprobes/list
ffffffffb50d95e0 k t_show+0x0 [DISABLED]
ffffffffb50e2d00 k t_show+0x0 [DISABLED]
ffffffffb50f4990 k t_show+0x0 [DISABLED]
ffffffffb50eccf0 k t_show+0x0 [DISABLED]
----
This time, each event is put in different address
correctly.
Note that currently this doesn't support address-based
probe on modules (thus the probes on modules are symbol
based), since it requires relative address probe syntax
for kprobe-tracer, and it isn't implemented yet.
One more note, this allows us to put events on correct
address, but --list option should be updated to show
correct corresponding source code.
Changes from v2:
- Refer kmap->ref_reloc_sym instead of "_stext".
- Refer map->reloc to catch up the kASLR perf fix.
Changes from v1:
- Use _stext relative address instead of actual
absolute address recorded in debuginfo.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053216.29635.22584.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:16 -07:00
|
|
|
/* Post processing the probe events */
|
|
|
|
static int post_process_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs, const char *module,
|
|
|
|
bool uprobe)
|
|
|
|
{
|
|
|
|
struct ref_reloc_sym *reloc_sym;
|
|
|
|
char *tmp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (uprobe)
|
|
|
|
return add_exec_to_probe_trace_events(tevs, ntevs, module);
|
|
|
|
|
|
|
|
/* Note that currently ref_reloc_sym based probe is not for drivers */
|
|
|
|
if (module)
|
|
|
|
return add_module_to_probe_trace_events(tevs, ntevs, module);
|
|
|
|
|
2014-02-05 22:32:20 -07:00
|
|
|
reloc_sym = kernel_get_ref_reloc_sym();
|
perf probe: Use ref_reloc_sym based address instead of the symbol name
Since several local symbols can have same name (e.g. t_show), we need to
use the relative address from the symbol referred by kmap->ref_reloc_sym
instead of the target symbol name itself.
Because the kernel address space layout randomize (kASLR) changes the
absolute address of kernel symbols, we can't rely on the absolute
address.
Note that this works only with debuginfo.
E.g. without this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
----
OK, we have 4 different t_show()s. All functions have
different arguments as below;
----
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show t_show m=%di:u64 v=%si:u64
p:probe/t_show_1 t_show m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 t_show m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 t_show m=%di:u64 v=%si:u64 file=%si:u64
----
However, all of them have been put on the *same* address.
----
# cat /sys/kernel/debug/kprobes/list
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
----
With this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show _stext+889880 m=%di:u64 v=%si:u64
p:probe/t_show_1 _stext+928568 m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 _stext+969512 m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 _stext+1001416 m=%di:u64 v=%si:u64 file=%si:u64
# cat /sys/kernel/debug/kprobes/list
ffffffffb50d95e0 k t_show+0x0 [DISABLED]
ffffffffb50e2d00 k t_show+0x0 [DISABLED]
ffffffffb50f4990 k t_show+0x0 [DISABLED]
ffffffffb50eccf0 k t_show+0x0 [DISABLED]
----
This time, each event is put in different address
correctly.
Note that currently this doesn't support address-based
probe on modules (thus the probes on modules are symbol
based), since it requires relative address probe syntax
for kprobe-tracer, and it isn't implemented yet.
One more note, this allows us to put events on correct
address, but --list option should be updated to show
correct corresponding source code.
Changes from v2:
- Refer kmap->ref_reloc_sym instead of "_stext".
- Refer map->reloc to catch up the kASLR perf fix.
Changes from v1:
- Use _stext relative address instead of actual
absolute address recorded in debuginfo.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053216.29635.22584.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:16 -07:00
|
|
|
if (!reloc_sym) {
|
|
|
|
pr_warning("Relocated base symbol is not found!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs; i++) {
|
|
|
|
if (tevs[i].point.address) {
|
|
|
|
tmp = strdup(reloc_sym->name);
|
|
|
|
if (!tmp)
|
|
|
|
return -ENOMEM;
|
|
|
|
free(tevs[i].point.symbol);
|
|
|
|
tevs[i].point.symbol = tmp;
|
|
|
|
tevs[i].point.offset = tevs[i].point.address -
|
|
|
|
reloc_sym->unrelocated_addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
/* Try to find perf_probe_event with debuginfo */
|
2010-07-29 08:13:51 -06:00
|
|
|
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
|
2011-06-27 01:27:45 -06:00
|
|
|
struct probe_trace_event **tevs,
|
2012-02-02 07:20:40 -07:00
|
|
|
int max_tevs, const char *target)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
|
|
|
bool need_dwarf = perf_probe_event_need_dwarf(pev);
|
2012-04-16 06:09:09 -06:00
|
|
|
struct debuginfo *dinfo;
|
2011-06-27 01:27:45 -06:00
|
|
|
int ntevs, ret = 0;
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2014-08-14 19:44:32 -06:00
|
|
|
dinfo = open_debuginfo(target, !need_dwarf);
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
if (!dinfo) {
|
2014-08-14 19:44:32 -06:00
|
|
|
if (need_dwarf)
|
2011-06-27 01:27:39 -06:00
|
|
|
return -ENOENT;
|
|
|
|
pr_debug("Could not open debuginfo. Try to use symbols.\n");
|
2010-03-22 10:10:26 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
perf probe: Use ref_reloc_sym based address instead of the symbol name
Since several local symbols can have same name (e.g. t_show), we need to
use the relative address from the symbol referred by kmap->ref_reloc_sym
instead of the target symbol name itself.
Because the kernel address space layout randomize (kASLR) changes the
absolute address of kernel symbols, we can't rely on the absolute
address.
Note that this works only with debuginfo.
E.g. without this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
----
OK, we have 4 different t_show()s. All functions have
different arguments as below;
----
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show t_show m=%di:u64 v=%si:u64
p:probe/t_show_1 t_show m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 t_show m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 t_show m=%di:u64 v=%si:u64 file=%si:u64
----
However, all of them have been put on the *same* address.
----
# cat /sys/kernel/debug/kprobes/list
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
----
With this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show _stext+889880 m=%di:u64 v=%si:u64
p:probe/t_show_1 _stext+928568 m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 _stext+969512 m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 _stext+1001416 m=%di:u64 v=%si:u64 file=%si:u64
# cat /sys/kernel/debug/kprobes/list
ffffffffb50d95e0 k t_show+0x0 [DISABLED]
ffffffffb50e2d00 k t_show+0x0 [DISABLED]
ffffffffb50f4990 k t_show+0x0 [DISABLED]
ffffffffb50eccf0 k t_show+0x0 [DISABLED]
----
This time, each event is put in different address
correctly.
Note that currently this doesn't support address-based
probe on modules (thus the probes on modules are symbol
based), since it requires relative address probe syntax
for kprobe-tracer, and it isn't implemented yet.
One more note, this allows us to put events on correct
address, but --list option should be updated to show
correct corresponding source code.
Changes from v2:
- Refer kmap->ref_reloc_sym instead of "_stext".
- Refer map->reloc to catch up the kASLR perf fix.
Changes from v1:
- Use _stext relative address instead of actual
absolute address recorded in debuginfo.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053216.29635.22584.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:16 -07:00
|
|
|
pr_debug("Try to find probe point from debuginfo.\n");
|
2011-06-27 01:27:39 -06:00
|
|
|
/* Searching trace events corresponding to a probe event */
|
|
|
|
ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
|
|
|
|
|
|
|
|
debuginfo__delete(dinfo);
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ntevs > 0) { /* Succeeded to find trace events */
|
perf probe: Use ref_reloc_sym based address instead of the symbol name
Since several local symbols can have same name (e.g. t_show), we need to
use the relative address from the symbol referred by kmap->ref_reloc_sym
instead of the target symbol name itself.
Because the kernel address space layout randomize (kASLR) changes the
absolute address of kernel symbols, we can't rely on the absolute
address.
Note that this works only with debuginfo.
E.g. without this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
----
OK, we have 4 different t_show()s. All functions have
different arguments as below;
----
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show t_show m=%di:u64 v=%si:u64
p:probe/t_show_1 t_show m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 t_show m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 t_show m=%di:u64 v=%si:u64 file=%si:u64
----
However, all of them have been put on the *same* address.
----
# cat /sys/kernel/debug/kprobes/list
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
ffffffff810d9720 k t_show+0x0 [DISABLED]
----
With this change;
----
# ./perf probe -a "t_show \$vars"
Added new events:
probe:t_show (on t_show with $vars)
probe:t_show_1 (on t_show with $vars)
probe:t_show_2 (on t_show with $vars)
probe:t_show_3 (on t_show with $vars)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# cat /sys/kernel/debug/tracing/kprobe_events
p:probe/t_show _stext+889880 m=%di:u64 v=%si:u64
p:probe/t_show_1 _stext+928568 m=%di:u64 v=%si:u64 t=%si:u64
p:probe/t_show_2 _stext+969512 m=%di:u64 v=%si:u64 fmt=%si:u64
p:probe/t_show_3 _stext+1001416 m=%di:u64 v=%si:u64 file=%si:u64
# cat /sys/kernel/debug/kprobes/list
ffffffffb50d95e0 k t_show+0x0 [DISABLED]
ffffffffb50e2d00 k t_show+0x0 [DISABLED]
ffffffffb50f4990 k t_show+0x0 [DISABLED]
ffffffffb50eccf0 k t_show+0x0 [DISABLED]
----
This time, each event is put in different address
correctly.
Note that currently this doesn't support address-based
probe on modules (thus the probes on modules are symbol
based), since it requires relative address probe syntax
for kprobe-tracer, and it isn't implemented yet.
One more note, this allows us to put events on correct
address, but --list option should be updated to show
correct corresponding source code.
Changes from v2:
- Refer kmap->ref_reloc_sym instead of "_stext".
- Refer map->reloc to catch up the kASLR perf fix.
Changes from v1:
- Use _stext relative address instead of actual
absolute address recorded in debuginfo.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053216.29635.22584.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:16 -07:00
|
|
|
pr_debug("Found %d probe_trace_events.\n", ntevs);
|
|
|
|
ret = post_process_probe_trace_events(*tevs, ntevs,
|
|
|
|
target, pev->uprobes);
|
2014-01-16 02:39:44 -07:00
|
|
|
if (ret < 0) {
|
|
|
|
clear_probe_trace_events(*tevs, ntevs);
|
|
|
|
zfree(tevs);
|
|
|
|
}
|
2011-06-27 01:27:45 -06:00
|
|
|
return ret < 0 ? ret : ntevs;
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ntevs == 0) { /* No error but failed to find probe point. */
|
2014-12-30 23:27:47 -07:00
|
|
|
pr_warning("Probe point '%s' not found in debuginfo.\n",
|
2010-04-12 11:17:42 -06:00
|
|
|
synthesize_perf_probe_point(&pev->point));
|
2014-12-30 23:27:47 -07:00
|
|
|
if (need_dwarf)
|
|
|
|
return -ENOENT;
|
|
|
|
return 0;
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
|
|
|
/* Error path : ntevs < 0 */
|
2010-04-21 13:56:24 -06:00
|
|
|
pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
|
|
|
|
if (ntevs == -EBADF) {
|
|
|
|
pr_warning("Warning: No dwarf info found in the vmlinux - "
|
|
|
|
"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
|
|
|
|
if (!need_dwarf) {
|
2010-12-17 06:12:11 -07:00
|
|
|
pr_debug("Trying to use symbols.\n");
|
2010-04-21 13:56:24 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
2010-04-21 13:56:24 -06:00
|
|
|
return ntevs;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
2010-07-09 03:28:59 -06:00
|
|
|
/*
|
|
|
|
* Find a src file from a DWARF tag path. Prepend optional source path prefix
|
|
|
|
* and chop off leading directories that do not exist. Result is passed back as
|
|
|
|
* a newly allocated path on success.
|
|
|
|
* Return 0 if file was found and readable, -errno otherwise.
|
|
|
|
*/
|
2010-07-09 03:29:11 -06:00
|
|
|
static int get_real_path(const char *raw_path, const char *comp_dir,
|
|
|
|
char **new_path)
|
2010-07-09 03:28:59 -06:00
|
|
|
{
|
2010-07-09 03:29:11 -06:00
|
|
|
const char *prefix = symbol_conf.source_prefix;
|
|
|
|
|
|
|
|
if (!prefix) {
|
|
|
|
if (raw_path[0] != '/' && comp_dir)
|
|
|
|
/* If not an absolute path, try to use comp_dir */
|
|
|
|
prefix = comp_dir;
|
|
|
|
else {
|
|
|
|
if (access(raw_path, R_OK) == 0) {
|
|
|
|
*new_path = strdup(raw_path);
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -errno;
|
|
|
|
}
|
2010-07-09 03:28:59 -06:00
|
|
|
}
|
|
|
|
|
2010-07-09 03:29:11 -06:00
|
|
|
*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
|
2010-07-09 03:28:59 -06:00
|
|
|
if (!*new_path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (;;) {
|
2010-07-09 03:29:11 -06:00
|
|
|
sprintf(*new_path, "%s/%s", prefix, raw_path);
|
2010-07-09 03:28:59 -06:00
|
|
|
|
|
|
|
if (access(*new_path, R_OK) == 0)
|
|
|
|
return 0;
|
|
|
|
|
2010-07-09 03:29:11 -06:00
|
|
|
if (!symbol_conf.source_prefix)
|
|
|
|
/* In case of searching comp_dir, don't retry */
|
|
|
|
return -errno;
|
|
|
|
|
2010-07-09 03:28:59 -06:00
|
|
|
switch (errno) {
|
|
|
|
case ENAMETOOLONG:
|
|
|
|
case ENOENT:
|
|
|
|
case EROFS:
|
|
|
|
case EFAULT:
|
|
|
|
raw_path = strchr(++raw_path, '/');
|
|
|
|
if (!raw_path) {
|
2013-12-26 13:41:15 -07:00
|
|
|
zfree(new_path);
|
2010-07-09 03:28:59 -06:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
|
|
|
default:
|
2013-12-26 13:41:15 -07:00
|
|
|
zfree(new_path);
|
2010-07-09 03:28:59 -06:00
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
#define LINEBUF_SIZE 256
|
|
|
|
#define NR_ADDITIONAL_LINES 2
|
|
|
|
|
2010-12-20 07:18:04 -07:00
|
|
|
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
2014-08-13 20:22:34 -06:00
|
|
|
char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
|
2010-12-20 07:18:01 -07:00
|
|
|
const char *color = show_num ? "" : PERF_COLOR_BLUE;
|
|
|
|
const char *prefix = NULL;
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2010-12-20 07:18:01 -07:00
|
|
|
do {
|
2010-03-22 10:10:26 -06:00
|
|
|
if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
|
|
|
|
goto error;
|
2010-12-20 07:18:01 -07:00
|
|
|
if (skip)
|
|
|
|
continue;
|
|
|
|
if (!prefix) {
|
|
|
|
prefix = show_num ? "%7d " : " ";
|
|
|
|
color_fprintf(stdout, color, prefix, l);
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
2010-12-20 07:18:01 -07:00
|
|
|
color_fprintf(stdout, color, "%s", buf);
|
|
|
|
|
|
|
|
} while (strchr(buf, '\n') == NULL);
|
2010-04-12 11:17:42 -06:00
|
|
|
|
2010-12-20 07:18:04 -07:00
|
|
|
return 1;
|
2010-03-22 10:10:26 -06:00
|
|
|
error:
|
2010-12-20 07:18:04 -07:00
|
|
|
if (ferror(fp)) {
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_warning("File read error: %s\n",
|
|
|
|
strerror_r(errno, sbuf, sizeof(sbuf)));
|
2010-12-20 07:18:04 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
2010-12-20 07:18:04 -07:00
|
|
|
static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
|
|
|
|
{
|
|
|
|
int rv = __show_one_line(fp, l, skip, show_num);
|
|
|
|
if (rv == 0) {
|
|
|
|
pr_warning("Source file is shorter than expected.\n");
|
|
|
|
rv = -1;
|
|
|
|
}
|
|
|
|
return rv;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
2010-12-20 07:18:04 -07:00
|
|
|
#define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)
|
|
|
|
#define show_one_line(f,l) _show_one_line(f,l,false,false)
|
|
|
|
#define skip_one_line(f,l) _show_one_line(f,l,true,false)
|
|
|
|
#define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)
|
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
/*
|
|
|
|
* Show line-range always requires debuginfo to find source file and
|
|
|
|
* line number.
|
|
|
|
*/
|
2014-02-05 22:32:04 -07:00
|
|
|
static int __show_line_range(struct line_range *lr, const char *module)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
2010-04-14 16:39:42 -06:00
|
|
|
int l = 1;
|
2014-02-05 22:32:09 -07:00
|
|
|
struct int_node *ln;
|
2011-06-27 01:27:39 -06:00
|
|
|
struct debuginfo *dinfo;
|
2010-03-22 10:10:26 -06:00
|
|
|
FILE *fp;
|
2011-06-27 01:27:39 -06:00
|
|
|
int ret;
|
2010-07-09 03:28:59 -06:00
|
|
|
char *tmp;
|
2014-08-13 20:22:34 -06:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2010-03-22 10:10:26 -06:00
|
|
|
|
|
|
|
/* Search a line range */
|
2014-08-14 19:44:32 -06:00
|
|
|
dinfo = open_debuginfo(module, false);
|
|
|
|
if (!dinfo)
|
2011-06-27 01:27:39 -06:00
|
|
|
return -ENOENT;
|
2010-04-12 11:17:42 -06:00
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
ret = debuginfo__find_line_range(dinfo, lr);
|
|
|
|
debuginfo__delete(dinfo);
|
2014-06-06 01:14:06 -06:00
|
|
|
if (ret == 0 || ret == -ENOENT) {
|
2010-04-12 11:17:42 -06:00
|
|
|
pr_warning("Specified source line is not found.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
} else if (ret < 0) {
|
2014-06-06 01:14:06 -06:00
|
|
|
pr_warning("Debuginfo analysis failed.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2010-07-09 03:28:59 -06:00
|
|
|
/* Convert source file path */
|
|
|
|
tmp = lr->path;
|
2010-07-09 03:29:11 -06:00
|
|
|
ret = get_real_path(tmp, lr->comp_dir, &lr->path);
|
2010-07-09 03:28:59 -06:00
|
|
|
free(tmp); /* Free old path */
|
|
|
|
if (ret < 0) {
|
2014-06-06 01:14:06 -06:00
|
|
|
pr_warning("Failed to find source file path.\n");
|
2010-07-09 03:28:59 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
setup_pager();
|
|
|
|
|
|
|
|
if (lr->function)
|
2011-02-10 02:08:16 -07:00
|
|
|
fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
|
2010-03-22 10:10:26 -06:00
|
|
|
lr->start - lr->offset);
|
|
|
|
else
|
2010-12-20 07:18:00 -07:00
|
|
|
fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
|
2010-03-22 10:10:26 -06:00
|
|
|
|
|
|
|
fp = fopen(lr->path, "r");
|
2010-04-12 11:17:42 -06:00
|
|
|
if (fp == NULL) {
|
|
|
|
pr_warning("Failed to open %s: %s\n", lr->path,
|
2014-08-13 20:22:34 -06:00
|
|
|
strerror_r(errno, sbuf, sizeof(sbuf)));
|
2010-04-12 11:17:42 -06:00
|
|
|
return -errno;
|
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
/* Skip to starting line number */
|
2010-12-20 07:18:02 -07:00
|
|
|
while (l < lr->start) {
|
2010-12-20 07:18:04 -07:00
|
|
|
ret = skip_one_line(fp, l++);
|
2010-12-20 07:18:02 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
}
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2014-02-05 22:32:09 -07:00
|
|
|
intlist__for_each(ln, lr->line_list) {
|
|
|
|
for (; ln->i > l; l++) {
|
2010-12-20 07:18:04 -07:00
|
|
|
ret = show_one_line(fp, l - lr->offset);
|
2010-12-20 07:18:02 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
}
|
2010-12-20 07:18:04 -07:00
|
|
|
ret = show_one_line_with_num(fp, l++ - lr->offset);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lr->end == INT_MAX)
|
|
|
|
lr->end = l + NR_ADDITIONAL_LINES;
|
2010-12-20 07:18:04 -07:00
|
|
|
while (l <= lr->end) {
|
|
|
|
ret = show_one_line_or_eof(fp, l++ - lr->offset);
|
|
|
|
if (ret <= 0)
|
2010-12-20 07:18:02 -07:00
|
|
|
break;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
end:
|
2010-03-22 10:10:26 -06:00
|
|
|
fclose(fp);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
2014-09-17 02:40:54 -06:00
|
|
|
int show_line_range(struct line_range *lr, const char *module, bool user)
|
2014-02-05 22:32:04 -07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-09-17 02:40:54 -06:00
|
|
|
ret = init_symbol_maps(user);
|
2014-02-05 22:32:04 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
ret = __show_line_range(lr, module);
|
|
|
|
exit_symbol_maps();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
static int show_available_vars_at(struct debuginfo *dinfo,
|
|
|
|
struct perf_probe_event *pev,
|
2011-01-20 07:15:39 -07:00
|
|
|
int max_vls, struct strfilter *_filter,
|
|
|
|
bool externs)
|
2010-10-21 04:13:23 -06:00
|
|
|
{
|
|
|
|
char *buf;
|
2011-01-20 07:15:39 -07:00
|
|
|
int ret, i, nvars;
|
2010-10-21 04:13:23 -06:00
|
|
|
struct str_node *node;
|
|
|
|
struct variable_list *vls = NULL, *vl;
|
2011-01-20 07:15:39 -07:00
|
|
|
const char *var;
|
2010-10-21 04:13:23 -06:00
|
|
|
|
|
|
|
buf = synthesize_perf_probe_point(&pev->point);
|
|
|
|
if (!buf)
|
|
|
|
return -EINVAL;
|
|
|
|
pr_debug("Searching variables at %s\n", buf);
|
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
|
|
|
|
max_vls, externs);
|
2011-01-20 07:15:39 -07:00
|
|
|
if (ret <= 0) {
|
2014-06-06 01:13:59 -06:00
|
|
|
if (ret == 0 || ret == -ENOENT) {
|
|
|
|
pr_err("Failed to find the address of %s\n", buf);
|
|
|
|
ret = -ENOENT;
|
|
|
|
} else
|
|
|
|
pr_warning("Debuginfo analysis failed.\n");
|
2011-01-20 07:15:39 -07:00
|
|
|
goto end;
|
|
|
|
}
|
2014-06-06 01:13:59 -06:00
|
|
|
|
2011-01-20 07:15:39 -07:00
|
|
|
/* Some variables are found */
|
|
|
|
fprintf(stdout, "Available variables at %s\n", buf);
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
vl = &vls[i];
|
|
|
|
/*
|
|
|
|
* A probe point might be converted to
|
|
|
|
* several trace points.
|
|
|
|
*/
|
|
|
|
fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
|
|
|
|
vl->point.offset);
|
2013-12-27 12:55:14 -07:00
|
|
|
zfree(&vl->point.symbol);
|
2011-01-20 07:15:39 -07:00
|
|
|
nvars = 0;
|
|
|
|
if (vl->vars) {
|
|
|
|
strlist__for_each(node, vl->vars) {
|
|
|
|
var = strchr(node->s, '\t') + 1;
|
|
|
|
if (strfilter__compare(_filter, var)) {
|
2010-10-21 04:13:23 -06:00
|
|
|
fprintf(stdout, "\t\t%s\n", node->s);
|
2011-01-20 07:15:39 -07:00
|
|
|
nvars++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strlist__delete(vl->vars);
|
2010-10-21 04:13:23 -06:00
|
|
|
}
|
2011-01-20 07:15:39 -07:00
|
|
|
if (nvars == 0)
|
|
|
|
fprintf(stdout, "\t\t(No matched variables)\n");
|
|
|
|
}
|
|
|
|
free(vls);
|
|
|
|
end:
|
2010-10-21 04:13:23 -06:00
|
|
|
free(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Show available variables on given probe point */
|
|
|
|
int show_available_vars(struct perf_probe_event *pevs, int npevs,
|
2011-01-20 07:15:39 -07:00
|
|
|
int max_vls, const char *module,
|
|
|
|
struct strfilter *_filter, bool externs)
|
2010-10-21 04:13:23 -06:00
|
|
|
{
|
2011-06-27 01:27:39 -06:00
|
|
|
int i, ret = 0;
|
|
|
|
struct debuginfo *dinfo;
|
2010-10-21 04:13:23 -06:00
|
|
|
|
2014-09-17 02:40:54 -06:00
|
|
|
ret = init_symbol_maps(pevs->uprobes);
|
2010-10-21 04:13:23 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-08-14 19:44:32 -06:00
|
|
|
dinfo = open_debuginfo(module, false);
|
2011-06-27 01:27:39 -06:00
|
|
|
if (!dinfo) {
|
2014-02-05 22:32:04 -07:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
2011-06-27 01:27:39 -06:00
|
|
|
}
|
|
|
|
|
2010-10-21 04:13:23 -06:00
|
|
|
setup_pager();
|
|
|
|
|
2011-06-27 01:27:39 -06:00
|
|
|
for (i = 0; i < npevs && ret >= 0; i++)
|
|
|
|
ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
|
2011-01-20 07:15:39 -07:00
|
|
|
externs);
|
2011-06-27 01:27:39 -06:00
|
|
|
|
|
|
|
debuginfo__delete(dinfo);
|
2014-02-05 22:32:04 -07:00
|
|
|
out:
|
|
|
|
exit_symbol_maps();
|
2010-10-21 04:13:23 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-09-30 04:07:11 -06:00
|
|
|
#else /* !HAVE_DWARF_SUPPORT */
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2014-02-05 22:32:23 -07:00
|
|
|
static int
|
|
|
|
find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
|
|
|
|
struct perf_probe_point *pp __maybe_unused,
|
|
|
|
bool is_kprobe __maybe_unused)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
2014-02-05 22:32:23 -07:00
|
|
|
return -ENOSYS;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
|
2012-09-10 16:15:03 -06:00
|
|
|
struct probe_trace_event **tevs __maybe_unused,
|
2014-01-13 11:15:25 -07:00
|
|
|
int max_tevs __maybe_unused,
|
|
|
|
const char *target __maybe_unused)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
2010-04-12 11:17:42 -06:00
|
|
|
if (perf_probe_event_need_dwarf(pev)) {
|
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-10 16:15:03 -06:00
|
|
|
int show_line_range(struct line_range *lr __maybe_unused,
|
2014-09-17 02:40:54 -06:00
|
|
|
const char *module __maybe_unused,
|
|
|
|
bool user __maybe_unused)
|
2010-03-22 10:10:26 -06:00
|
|
|
{
|
2010-04-12 11:17:42 -06:00
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
2010-03-22 10:10:26 -06:00
|
|
|
}
|
|
|
|
|
2012-09-10 16:15:03 -06:00
|
|
|
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
|
|
|
|
int npevs __maybe_unused, int max_vls __maybe_unused,
|
|
|
|
const char *module __maybe_unused,
|
|
|
|
struct strfilter *filter __maybe_unused,
|
|
|
|
bool externs __maybe_unused)
|
2010-10-21 04:13:23 -06:00
|
|
|
{
|
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2010-03-16 16:05:37 -06:00
|
|
|
#endif
|
|
|
|
|
2014-01-16 02:39:47 -07:00
|
|
|
void line_range__clear(struct line_range *lr)
|
|
|
|
{
|
|
|
|
free(lr->function);
|
|
|
|
free(lr->file);
|
|
|
|
free(lr->path);
|
|
|
|
free(lr->comp_dir);
|
2014-02-05 22:32:09 -07:00
|
|
|
intlist__delete(lr->line_list);
|
2014-01-16 02:39:47 -07:00
|
|
|
memset(lr, 0, sizeof(*lr));
|
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:09 -07:00
|
|
|
int line_range__init(struct line_range *lr)
|
2014-01-16 02:39:47 -07:00
|
|
|
{
|
|
|
|
memset(lr, 0, sizeof(*lr));
|
2014-02-05 22:32:09 -07:00
|
|
|
lr->line_list = intlist__new(NULL);
|
|
|
|
if (!lr->line_list)
|
|
|
|
return -ENOMEM;
|
|
|
|
else
|
|
|
|
return 0;
|
2014-01-16 02:39:47 -07:00
|
|
|
}
|
|
|
|
|
2010-12-20 07:18:05 -07:00
|
|
|
static int parse_line_num(char **ptr, int *val, const char *what)
|
|
|
|
{
|
|
|
|
const char *start = *ptr;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
*val = strtol(*ptr, ptr, 0);
|
|
|
|
if (errno || *ptr == start) {
|
|
|
|
semantic_error("'%s' is not a valid number.\n", what);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-20 07:18:03 -07:00
|
|
|
/*
|
|
|
|
* Stuff 'lr' according to the line range described by 'arg'.
|
|
|
|
* The line range syntax is described by:
|
|
|
|
*
|
|
|
|
* SRC[:SLN[+NUM|-ELN]]
|
2011-02-10 02:08:10 -07:00
|
|
|
* FNC[@SRC][:SLN[+NUM|-ELN]]
|
2010-12-20 07:18:03 -07:00
|
|
|
*/
|
2010-04-12 11:17:42 -06:00
|
|
|
int parse_line_range_desc(const char *arg, struct line_range *lr)
|
2010-01-06 07:45:34 -07:00
|
|
|
{
|
2011-02-10 02:08:10 -07:00
|
|
|
char *range, *file, *name = strdup(arg);
|
2010-12-20 07:18:05 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
lr->start = 0;
|
|
|
|
lr->end = INT_MAX;
|
|
|
|
|
|
|
|
range = strchr(name, ':');
|
|
|
|
if (range) {
|
|
|
|
*range++ = '\0';
|
|
|
|
|
|
|
|
err = parse_line_num(&range, &lr->start, "start line");
|
|
|
|
if (err)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (*range == '+' || *range == '-') {
|
|
|
|
const char c = *range++;
|
|
|
|
|
|
|
|
err = parse_line_num(&range, &lr->end, "end line");
|
|
|
|
if (err)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (c == '+') {
|
|
|
|
lr->end += lr->start;
|
|
|
|
/*
|
|
|
|
* Adjust the number of lines here.
|
|
|
|
* If the number of lines == 1, the
|
|
|
|
* the end of line should be equal to
|
|
|
|
* the start of line.
|
|
|
|
*/
|
|
|
|
lr->end--;
|
|
|
|
}
|
|
|
|
}
|
2010-12-20 07:18:03 -07:00
|
|
|
|
2010-04-14 16:39:42 -06:00
|
|
|
pr_debug("Line range is %d to %d\n", lr->start, lr->end);
|
2010-12-20 07:18:05 -07:00
|
|
|
|
|
|
|
err = -EINVAL;
|
2010-04-14 16:39:42 -06:00
|
|
|
if (lr->start > lr->end) {
|
2010-01-06 07:45:34 -07:00
|
|
|
semantic_error("Start line must be smaller"
|
2010-04-12 11:17:42 -06:00
|
|
|
" than end line.\n");
|
2010-12-20 07:18:05 -07:00
|
|
|
goto err;
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
2010-12-20 07:18:05 -07:00
|
|
|
if (*range != '\0') {
|
|
|
|
semantic_error("Tailing with invalid str '%s'.\n", range);
|
|
|
|
goto err;
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
2010-04-14 16:39:42 -06:00
|
|
|
}
|
2010-04-12 11:17:56 -06:00
|
|
|
|
2011-02-10 02:08:10 -07:00
|
|
|
file = strchr(name, '@');
|
|
|
|
if (file) {
|
|
|
|
*file = '\0';
|
|
|
|
lr->file = strdup(++file);
|
|
|
|
if (lr->file == NULL) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
lr->function = name;
|
|
|
|
} else if (strchr(name, '.'))
|
2010-12-20 07:18:05 -07:00
|
|
|
lr->file = name;
|
2010-01-06 07:45:34 -07:00
|
|
|
else
|
2010-12-20 07:18:05 -07:00
|
|
|
lr->function = name;
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return 0;
|
2010-12-20 07:18:05 -07:00
|
|
|
err:
|
|
|
|
free(name);
|
|
|
|
return err;
|
2010-01-06 07:45:34 -07:00
|
|
|
}
|
|
|
|
|
2009-12-16 15:24:15 -07:00
|
|
|
/* Check the name is good for event/group */
|
|
|
|
static bool check_event_name(const char *name)
|
|
|
|
{
|
|
|
|
if (!isalpha(*name) && *name != '_')
|
|
|
|
return false;
|
|
|
|
while (*++name != '\0') {
|
|
|
|
if (!isalpha(*name) && !isdigit(*name) && *name != '_')
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-11-30 17:19:58 -07:00
|
|
|
/* Parse probepoint definition. */
|
2010-04-12 11:17:42 -06:00
|
|
|
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
|
2009-11-30 17:19:58 -07:00
|
|
|
{
|
2010-03-16 16:06:12 -06:00
|
|
|
struct perf_probe_point *pp = &pev->point;
|
2009-11-30 17:19:58 -07:00
|
|
|
char *ptr, *tmp;
|
|
|
|
char c, nc = 0;
|
|
|
|
/*
|
|
|
|
* <Syntax>
|
2010-02-25 06:36:12 -07:00
|
|
|
* perf probe [EVENT=]SRC[:LN|;PTN]
|
|
|
|
* perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
|
2009-12-15 08:32:18 -07:00
|
|
|
*
|
|
|
|
* TODO:Group name support
|
2009-11-30 17:19:58 -07:00
|
|
|
*/
|
|
|
|
|
2010-02-25 06:36:12 -07:00
|
|
|
ptr = strpbrk(arg, ";=@+%");
|
|
|
|
if (ptr && *ptr == '=') { /* Event name */
|
2009-12-15 08:32:18 -07:00
|
|
|
*ptr = '\0';
|
|
|
|
tmp = ptr + 1;
|
2010-04-12 11:17:42 -06:00
|
|
|
if (strchr(arg, ':')) {
|
|
|
|
semantic_error("Group name is not supported yet.\n");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
if (!check_event_name(arg)) {
|
2009-12-16 15:24:15 -07:00
|
|
|
semantic_error("%s is bad for event name -it must "
|
2010-04-12 11:17:42 -06:00
|
|
|
"follow C symbol-naming rule.\n", arg);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-04-12 11:17:56 -06:00
|
|
|
pev->event = strdup(arg);
|
|
|
|
if (pev->event == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-16 16:06:12 -06:00
|
|
|
pev->group = NULL;
|
2009-12-15 08:32:18 -07:00
|
|
|
arg = tmp;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:36:12 -07:00
|
|
|
ptr = strpbrk(arg, ";:+@%");
|
2009-11-30 17:19:58 -07:00
|
|
|
if (ptr) {
|
|
|
|
nc = *ptr;
|
|
|
|
*ptr++ = '\0';
|
|
|
|
}
|
|
|
|
|
2010-04-12 11:17:56 -06:00
|
|
|
tmp = strdup(arg);
|
|
|
|
if (tmp == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-11-30 17:19:58 -07:00
|
|
|
/* Check arg is function or file and copy it */
|
2010-04-12 11:17:56 -06:00
|
|
|
if (strchr(tmp, '.')) /* File */
|
|
|
|
pp->file = tmp;
|
2009-11-30 17:19:58 -07:00
|
|
|
else /* Function */
|
2010-04-12 11:17:56 -06:00
|
|
|
pp->function = tmp;
|
2009-11-30 17:19:58 -07:00
|
|
|
|
|
|
|
/* Parse other options */
|
|
|
|
while (ptr) {
|
|
|
|
arg = ptr;
|
|
|
|
c = nc;
|
2010-02-25 06:36:12 -07:00
|
|
|
if (c == ';') { /* Lazy pattern must be the last part */
|
2010-04-12 11:17:56 -06:00
|
|
|
pp->lazy_line = strdup(arg);
|
|
|
|
if (pp->lazy_line == NULL)
|
|
|
|
return -ENOMEM;
|
2010-02-25 06:36:12 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ptr = strpbrk(arg, ";:+@%");
|
2009-11-30 17:19:58 -07:00
|
|
|
if (ptr) {
|
|
|
|
nc = *ptr;
|
|
|
|
*ptr++ = '\0';
|
|
|
|
}
|
|
|
|
switch (c) {
|
|
|
|
case ':': /* Line number */
|
|
|
|
pp->line = strtoul(arg, &tmp, 0);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (*tmp != '\0') {
|
2010-02-25 06:36:12 -07:00
|
|
|
semantic_error("There is non-digit char"
|
2010-04-12 11:17:42 -06:00
|
|
|
" in line number.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
break;
|
|
|
|
case '+': /* Byte offset from a symbol */
|
|
|
|
pp->offset = strtoul(arg, &tmp, 0);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (*tmp != '\0') {
|
2010-02-25 06:36:12 -07:00
|
|
|
semantic_error("There is non-digit character"
|
2010-04-12 11:17:42 -06:00
|
|
|
" in offset.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
break;
|
|
|
|
case '@': /* File name */
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->file) {
|
|
|
|
semantic_error("SRC@SRC is not allowed.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-04-12 11:17:56 -06:00
|
|
|
pp->file = strdup(arg);
|
|
|
|
if (pp->file == NULL)
|
|
|
|
return -ENOMEM;
|
2009-11-30 17:19:58 -07:00
|
|
|
break;
|
|
|
|
case '%': /* Probe places */
|
|
|
|
if (strcmp(arg, "return") == 0) {
|
|
|
|
pp->retprobe = 1;
|
2010-04-12 11:17:42 -06:00
|
|
|
} else { /* Others not supported yet */
|
|
|
|
semantic_error("%%%s is not supported.\n", arg);
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
break;
|
2010-04-12 11:17:42 -06:00
|
|
|
default: /* Buggy case */
|
|
|
|
pr_err("This program has a bug at %s:%d.\n",
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
return -ENOTSUP;
|
2009-11-30 17:19:58 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exclusion check */
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->lazy_line && pp->line) {
|
2010-12-17 06:12:11 -07:00
|
|
|
semantic_error("Lazy pattern can't be used with"
|
|
|
|
" line number.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-02-25 06:36:12 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->lazy_line && pp->offset) {
|
2010-12-17 06:12:11 -07:00
|
|
|
semantic_error("Lazy pattern can't be used with offset.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-02-25 06:36:12 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->line && pp->offset) {
|
2010-12-17 06:12:11 -07:00
|
|
|
semantic_error("Offset can't be used with line number.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
|
2010-02-25 06:36:12 -07:00
|
|
|
semantic_error("File always requires line number or "
|
2010-12-17 06:12:11 -07:00
|
|
|
"lazy pattern.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->offset && !pp->function) {
|
2010-12-17 06:12:11 -07:00
|
|
|
semantic_error("Offset requires an entry function.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (pp->retprobe && !pp->function) {
|
2010-12-17 06:12:11 -07:00
|
|
|
semantic_error("Return probe requires an entry function.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
|
2010-02-25 06:36:12 -07:00
|
|
|
semantic_error("Offset/Line/Lazy pattern can't be used with "
|
2010-12-17 06:12:11 -07:00
|
|
|
"return probe.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
|
2010-02-25 06:36:12 -07:00
|
|
|
pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
|
|
|
|
pp->lazy_line);
|
2010-04-12 11:17:42 -06:00
|
|
|
return 0;
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:26 -06:00
|
|
|
/* Parse perf-probe event argument */
|
2010-04-12 11:17:42 -06:00
|
|
|
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
|
2010-03-16 16:06:26 -06:00
|
|
|
{
|
2010-05-19 13:57:42 -06:00
|
|
|
char *tmp, *goodname;
|
2010-03-16 16:06:26 -06:00
|
|
|
struct perf_probe_arg_field **fieldp;
|
|
|
|
|
|
|
|
pr_debug("parsing arg: %s into ", str);
|
|
|
|
|
2010-04-12 11:16:53 -06:00
|
|
|
tmp = strchr(str, '=');
|
|
|
|
if (tmp) {
|
2010-04-12 11:17:56 -06:00
|
|
|
arg->name = strndup(str, tmp - str);
|
|
|
|
if (arg->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 11:17:22 -06:00
|
|
|
pr_debug("name:%s ", arg->name);
|
2010-04-12 11:16:53 -06:00
|
|
|
str = tmp + 1;
|
|
|
|
}
|
|
|
|
|
2010-04-12 11:17:22 -06:00
|
|
|
tmp = strchr(str, ':');
|
|
|
|
if (tmp) { /* Type setting */
|
|
|
|
*tmp = '\0';
|
2010-04-12 11:17:56 -06:00
|
|
|
arg->type = strdup(tmp + 1);
|
|
|
|
if (arg->type == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 11:17:22 -06:00
|
|
|
pr_debug("type:%s ", arg->type);
|
|
|
|
}
|
|
|
|
|
2010-05-19 13:57:42 -06:00
|
|
|
tmp = strpbrk(str, "-.[");
|
2010-03-16 16:06:26 -06:00
|
|
|
if (!is_c_varname(str) || !tmp) {
|
|
|
|
/* A variable, register, symbol or special value */
|
2010-04-12 11:17:56 -06:00
|
|
|
arg->var = strdup(str);
|
|
|
|
if (arg->var == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 11:16:53 -06:00
|
|
|
pr_debug("%s\n", arg->var);
|
2010-04-12 11:17:42 -06:00
|
|
|
return 0;
|
2010-03-16 16:06:26 -06:00
|
|
|
}
|
|
|
|
|
2010-05-19 13:57:42 -06:00
|
|
|
/* Structure fields or array element */
|
2010-04-12 11:17:56 -06:00
|
|
|
arg->var = strndup(str, tmp - str);
|
|
|
|
if (arg->var == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-19 13:57:42 -06:00
|
|
|
goodname = arg->var;
|
2010-04-12 11:16:53 -06:00
|
|
|
pr_debug("%s, ", arg->var);
|
2010-03-16 16:06:26 -06:00
|
|
|
fieldp = &arg->field;
|
|
|
|
|
|
|
|
do {
|
2010-04-12 11:17:49 -06:00
|
|
|
*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
|
|
|
|
if (*fieldp == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-19 13:57:42 -06:00
|
|
|
if (*tmp == '[') { /* Array */
|
|
|
|
str = tmp;
|
|
|
|
(*fieldp)->index = strtol(str + 1, &tmp, 0);
|
2010-03-16 16:06:26 -06:00
|
|
|
(*fieldp)->ref = true;
|
2010-05-19 13:57:42 -06:00
|
|
|
if (*tmp != ']' || tmp == str + 1) {
|
|
|
|
semantic_error("Array index must be a"
|
|
|
|
" number.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
tmp++;
|
|
|
|
if (*tmp == '\0')
|
|
|
|
tmp = NULL;
|
|
|
|
} else { /* Structure */
|
|
|
|
if (*tmp == '.') {
|
|
|
|
str = tmp + 1;
|
|
|
|
(*fieldp)->ref = false;
|
|
|
|
} else if (tmp[1] == '>') {
|
|
|
|
str = tmp + 2;
|
|
|
|
(*fieldp)->ref = true;
|
|
|
|
} else {
|
|
|
|
semantic_error("Argument parse error: %s\n",
|
|
|
|
str);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
tmp = strpbrk(str, "-.[");
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
2010-03-16 16:06:26 -06:00
|
|
|
if (tmp) {
|
2010-04-12 11:17:56 -06:00
|
|
|
(*fieldp)->name = strndup(str, tmp - str);
|
|
|
|
if ((*fieldp)->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-19 13:57:42 -06:00
|
|
|
if (*str != '[')
|
|
|
|
goodname = (*fieldp)->name;
|
2010-03-16 16:06:26 -06:00
|
|
|
pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
|
|
|
|
fieldp = &(*fieldp)->next;
|
|
|
|
}
|
|
|
|
} while (tmp);
|
2010-04-12 11:17:56 -06:00
|
|
|
(*fieldp)->name = strdup(str);
|
|
|
|
if ((*fieldp)->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-19 13:57:42 -06:00
|
|
|
if (*str != '[')
|
|
|
|
goodname = (*fieldp)->name;
|
2010-03-16 16:06:26 -06:00
|
|
|
pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
|
2010-04-12 11:17:00 -06:00
|
|
|
|
2010-05-19 13:57:42 -06:00
|
|
|
/* If no name is specified, set the last field name (not array index)*/
|
2010-04-12 11:17:56 -06:00
|
|
|
if (!arg->name) {
|
2010-05-19 13:57:42 -06:00
|
|
|
arg->name = strdup(goodname);
|
2010-04-12 11:17:56 -06:00
|
|
|
if (arg->name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
return 0;
|
2010-03-16 16:06:26 -06:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Parse perf-probe event command */
|
2010-04-12 11:17:42 -06:00
|
|
|
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
|
2009-11-30 17:19:58 -07:00
|
|
|
{
|
2009-11-30 17:20:05 -07:00
|
|
|
char **argv;
|
2010-04-12 11:17:42 -06:00
|
|
|
int argc, i, ret = 0;
|
2009-12-15 08:31:14 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
argv = argv_split(cmd, &argc);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!argv) {
|
|
|
|
pr_debug("Failed to split arguments.\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (argc - 1 > MAX_PROBE_ARGS) {
|
|
|
|
semantic_error("Too many probe arguments (%d).\n", argc - 1);
|
|
|
|
ret = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
/* Parse probe point */
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = parse_perf_probe_point(argv[0], pev);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2009-11-30 17:20:05 -07:00
|
|
|
/* Copy arguments and ensure return probe has no C argument */
|
2010-03-16 16:06:12 -06:00
|
|
|
pev->nargs = argc - 1;
|
2010-04-12 11:17:49 -06:00
|
|
|
pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
|
|
|
|
if (pev->args == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
for (i = 0; i < pev->nargs && ret >= 0; i++) {
|
|
|
|
ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
|
|
|
|
if (ret >= 0 &&
|
|
|
|
is_c_varname(pev->args[i].var) && pev->point.retprobe) {
|
2010-03-16 16:06:12 -06:00
|
|
|
semantic_error("You can't specify local variable for"
|
2010-04-12 11:17:42 -06:00
|
|
|
" kretprobe.\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2009-11-30 17:20:05 -07:00
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
out:
|
2009-11-30 17:20:05 -07:00
|
|
|
argv_free(argv);
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return ret;
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Return true if this perf_probe_event requires debuginfo */
|
|
|
|
bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (pev->point.file || pev->point.line || pev->point.lazy_line)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
for (i = 0; i < pev->nargs; i++)
|
2010-04-12 11:16:53 -06:00
|
|
|
if (is_c_varname(pev->args[i].var))
|
2010-03-16 16:06:12 -06:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
/* Parse probe_events event into struct probe_point */
|
|
|
|
static int parse_probe_trace_command(const char *cmd,
|
2011-06-27 01:27:45 -06:00
|
|
|
struct probe_trace_event *tev)
|
2009-11-30 17:20:17 -07:00
|
|
|
{
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_point *tp = &tev->point;
|
2009-11-30 17:20:17 -07:00
|
|
|
char pr;
|
|
|
|
char *p;
|
2012-09-20 14:37:50 -06:00
|
|
|
char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
|
2009-11-30 17:20:17 -07:00
|
|
|
int ret, i, argc;
|
|
|
|
char **argv;
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
pr_debug("Parsing probe_events: %s\n", cmd);
|
2010-03-16 16:06:12 -06:00
|
|
|
argv = argv_split(cmd, &argc);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!argv) {
|
|
|
|
pr_debug("Failed to split arguments.\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (argc < 2) {
|
|
|
|
semantic_error("Too few probe arguments.\n");
|
|
|
|
ret = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
|
|
|
|
/* Scan event and group name. */
|
2012-09-20 14:37:50 -06:00
|
|
|
argv0_str = strdup(argv[0]);
|
|
|
|
if (argv0_str == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fmt1_str = strtok_r(argv0_str, ":", &fmt);
|
|
|
|
fmt2_str = strtok_r(NULL, "/", &fmt);
|
|
|
|
fmt3_str = strtok_r(NULL, " \t", &fmt);
|
|
|
|
if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
|
|
|
|
|| fmt3_str == NULL) {
|
2010-04-12 11:17:42 -06:00
|
|
|
semantic_error("Failed to parse event name: %s\n", argv[0]);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-09-20 14:37:50 -06:00
|
|
|
pr = fmt1_str[0];
|
|
|
|
tev->group = strdup(fmt2_str);
|
|
|
|
tev->event = strdup(fmt3_str);
|
|
|
|
if (tev->group == NULL || tev->event == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
tp->retprobe = (pr == 'r');
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2011-06-27 01:27:45 -06:00
|
|
|
/* Scan module name(if there), function name and offset */
|
|
|
|
p = strchr(argv[1], ':');
|
|
|
|
if (p) {
|
|
|
|
tp->module = strndup(argv[1], p - argv[1]);
|
|
|
|
p++;
|
|
|
|
} else
|
|
|
|
p = argv[1];
|
2012-09-20 14:37:50 -06:00
|
|
|
fmt1_str = strtok_r(p, "+", &fmt);
|
2014-02-05 22:32:23 -07:00
|
|
|
if (fmt1_str[0] == '0') /* only the address started with 0x */
|
|
|
|
tp->address = strtoul(fmt1_str, NULL, 0);
|
|
|
|
else {
|
|
|
|
/* Only the symbol-based probe has offset */
|
|
|
|
tp->symbol = strdup(fmt1_str);
|
|
|
|
if (tp->symbol == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fmt2_str = strtok_r(NULL, "", &fmt);
|
|
|
|
if (fmt2_str == NULL)
|
|
|
|
tp->offset = 0;
|
|
|
|
else
|
|
|
|
tp->offset = strtoul(fmt2_str, NULL, 10);
|
2012-09-20 14:37:50 -06:00
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
tev->nargs = argc - 2;
|
2010-07-29 08:13:51 -06:00
|
|
|
tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
|
2010-04-12 11:17:49 -06:00
|
|
|
if (tev->args == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
2009-11-30 17:20:17 -07:00
|
|
|
p = strchr(argv[i + 2], '=');
|
|
|
|
if (p) /* We don't need which register is assigned. */
|
2010-03-16 16:06:12 -06:00
|
|
|
*p++ = '\0';
|
|
|
|
else
|
|
|
|
p = argv[i + 2];
|
2010-04-12 11:17:56 -06:00
|
|
|
tev->args[i].name = strdup(argv[i + 2]);
|
2010-03-16 16:06:12 -06:00
|
|
|
/* TODO: parse regs and offset */
|
2010-04-12 11:17:56 -06:00
|
|
|
tev->args[i].value = strdup(p);
|
|
|
|
if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2012-09-20 14:37:50 -06:00
|
|
|
free(argv0_str);
|
2009-11-30 17:20:17 -07:00
|
|
|
argv_free(argv);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:26 -06:00
|
|
|
/* Compose only probe arg */
|
|
|
|
int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
|
|
|
|
{
|
|
|
|
struct perf_probe_arg_field *field = pa->field;
|
|
|
|
int ret;
|
|
|
|
char *tmp = buf;
|
|
|
|
|
2010-04-12 11:16:53 -06:00
|
|
|
if (pa->name && pa->var)
|
|
|
|
ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
|
|
|
|
else
|
|
|
|
ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
|
2010-03-16 16:06:26 -06:00
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
tmp += ret;
|
|
|
|
len -= ret;
|
|
|
|
|
|
|
|
while (field) {
|
2010-05-19 13:57:42 -06:00
|
|
|
if (field->name[0] == '[')
|
|
|
|
ret = e_snprintf(tmp, len, "%s", field->name);
|
|
|
|
else
|
|
|
|
ret = e_snprintf(tmp, len, "%s%s",
|
|
|
|
field->ref ? "->" : ".", field->name);
|
2010-03-16 16:06:26 -06:00
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
tmp += ret;
|
|
|
|
len -= ret;
|
|
|
|
field = field->next;
|
|
|
|
}
|
2010-04-12 11:17:22 -06:00
|
|
|
|
|
|
|
if (pa->type) {
|
|
|
|
ret = e_snprintf(tmp, len, ":%s", pa->type);
|
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
tmp += ret;
|
|
|
|
len -= ret;
|
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:26 -06:00
|
|
|
return tmp - buf;
|
|
|
|
error:
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2010-03-16 16:06:26 -06:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Compose only probe point (not argument) */
|
|
|
|
static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
|
2009-11-30 17:20:17 -07:00
|
|
|
{
|
2010-03-16 16:06:19 -06:00
|
|
|
char *buf, *tmp;
|
|
|
|
char offs[32] = "", line[32] = "", file[32] = "";
|
|
|
|
int ret, len;
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2010-04-12 11:17:49 -06:00
|
|
|
buf = zalloc(MAX_CMDLEN);
|
|
|
|
if (buf == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
if (pp->offset) {
|
2010-03-16 16:06:19 -06:00
|
|
|
ret = e_snprintf(offs, 32, "+%lu", pp->offset);
|
2009-11-30 17:20:17 -07:00
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (pp->line) {
|
2010-03-16 16:06:19 -06:00
|
|
|
ret = e_snprintf(line, 32, ":%d", pp->line);
|
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (pp->file) {
|
2010-12-23 08:04:23 -07:00
|
|
|
tmp = pp->file;
|
|
|
|
len = strlen(tmp);
|
|
|
|
if (len > 30) {
|
|
|
|
tmp = strchr(pp->file + len - 30, '/');
|
|
|
|
tmp = tmp ? tmp + 1 : pp->file + len - 30;
|
|
|
|
}
|
|
|
|
ret = e_snprintf(file, 32, "@%s", tmp);
|
2009-11-30 17:20:17 -07:00
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pp->function)
|
2010-03-16 16:06:19 -06:00
|
|
|
ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
|
|
|
|
offs, pp->retprobe ? "%return" : "", line,
|
|
|
|
file);
|
2009-11-30 17:20:17 -07:00
|
|
|
else
|
2010-03-16 16:06:19 -06:00
|
|
|
ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
|
2010-03-16 16:06:12 -06:00
|
|
|
if (ret <= 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
return buf;
|
2009-12-15 08:32:47 -07:00
|
|
|
error:
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_debug("Failed to synthesize perf probe point: %d\n", ret);
|
2013-12-26 11:54:57 -07:00
|
|
|
free(buf);
|
2010-04-12 11:17:42 -06:00
|
|
|
return NULL;
|
2009-12-15 08:32:47 -07:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
#if 0
|
|
|
|
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
|
2009-12-15 08:32:47 -07:00
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
int i, len, ret;
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
buf = synthesize_perf_probe_point(&pev->point);
|
|
|
|
if (!buf)
|
|
|
|
return NULL;
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
len = strlen(buf);
|
|
|
|
for (i = 0; i < pev->nargs; i++) {
|
2009-11-30 17:20:17 -07:00
|
|
|
ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
|
2010-03-16 16:06:12 -06:00
|
|
|
pev->args[i].name);
|
|
|
|
if (ret <= 0) {
|
|
|
|
free(buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
len += ret;
|
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
|
2010-03-16 16:06:12 -06:00
|
|
|
char **buf, size_t *buflen,
|
|
|
|
int depth)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
if (ref->next) {
|
2010-07-29 08:13:51 -06:00
|
|
|
depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
|
2010-03-16 16:06:12 -06:00
|
|
|
buflen, depth + 1);
|
|
|
|
if (depth < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
|
|
|
|
if (ret < 0)
|
|
|
|
depth = ret;
|
|
|
|
else {
|
|
|
|
*buf += ret;
|
|
|
|
*buflen -= ret;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return depth;
|
2009-11-30 17:20:17 -07:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
|
2010-03-16 16:06:12 -06:00
|
|
|
char *buf, size_t buflen)
|
2009-11-30 17:19:58 -07:00
|
|
|
{
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_arg_ref *ref = arg->ref;
|
2010-03-16 16:06:12 -06:00
|
|
|
int ret, depth = 0;
|
|
|
|
char *tmp = buf;
|
|
|
|
|
|
|
|
/* Argument name or separator */
|
|
|
|
if (arg->name)
|
|
|
|
ret = e_snprintf(buf, buflen, " %s=", arg->name);
|
|
|
|
else
|
|
|
|
ret = e_snprintf(buf, buflen, " ");
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
|
|
|
|
2010-05-19 13:57:49 -06:00
|
|
|
/* Special case: @XXX */
|
|
|
|
if (arg->value[0] == '@' && arg->ref)
|
|
|
|
ref = ref->next;
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Dereferencing arguments */
|
2010-05-19 13:57:49 -06:00
|
|
|
if (ref) {
|
2010-07-29 08:13:51 -06:00
|
|
|
depth = __synthesize_probe_trace_arg_ref(ref, &buf,
|
2010-03-16 16:06:12 -06:00
|
|
|
&buflen, 1);
|
|
|
|
if (depth < 0)
|
|
|
|
return depth;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print argument value */
|
2010-05-19 13:57:49 -06:00
|
|
|
if (arg->value[0] == '@' && arg->ref)
|
|
|
|
ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
|
|
|
|
arg->ref->offset);
|
|
|
|
else
|
|
|
|
ret = e_snprintf(buf, buflen, "%s", arg->value);
|
2010-03-16 16:06:12 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
|
|
|
|
|
|
|
/* Closing */
|
|
|
|
while (depth--) {
|
|
|
|
ret = e_snprintf(buf, buflen, ")");
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
|
|
|
}
|
2010-04-12 11:17:15 -06:00
|
|
|
/* Print argument type */
|
|
|
|
if (arg->type) {
|
|
|
|
ret = e_snprintf(buf, buflen, ":%s", arg->type);
|
|
|
|
if (ret <= 0)
|
|
|
|
return ret;
|
|
|
|
buf += ret;
|
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
|
|
|
|
return buf - tmp;
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
|
2010-03-16 16:06:12 -06:00
|
|
|
{
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_point *tp = &tev->point;
|
2009-11-30 17:19:58 -07:00
|
|
|
char *buf;
|
|
|
|
int i, len, ret;
|
|
|
|
|
2010-04-12 11:17:49 -06:00
|
|
|
buf = zalloc(MAX_CMDLEN);
|
|
|
|
if (buf == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
|
|
|
|
tev->group, tev->event);
|
|
|
|
if (len <= 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Uprobes must have tp->address and tp->module */
|
|
|
|
if (tev->uprobes && (!tp->address || !tp->module))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Use the tp->address for uprobes */
|
2012-04-16 06:09:09 -06:00
|
|
|
if (tev->uprobes)
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
|
|
|
|
tp->module, tp->address);
|
2012-04-16 06:09:09 -06:00
|
|
|
else
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
|
2012-04-16 06:09:09 -06:00
|
|
|
tp->module ?: "", tp->module ? ":" : "",
|
|
|
|
tp->symbol, tp->offset);
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if (ret <= 0)
|
2009-11-30 17:19:58 -07:00
|
|
|
goto error;
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
len += ret;
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
|
2010-03-16 16:06:12 -06:00
|
|
|
MAX_CMDLEN - len);
|
2009-11-30 17:20:17 -07:00
|
|
|
if (ret <= 0)
|
2009-11-30 17:19:58 -07:00
|
|
|
goto error;
|
|
|
|
len += ret;
|
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
return buf;
|
2009-11-30 17:19:58 -07:00
|
|
|
error:
|
2010-03-16 16:06:12 -06:00
|
|
|
free(buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2014-02-05 22:32:23 -07:00
|
|
|
static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
|
|
|
|
struct perf_probe_point *pp,
|
|
|
|
bool is_kprobe)
|
|
|
|
{
|
|
|
|
struct symbol *sym = NULL;
|
|
|
|
struct map *map;
|
|
|
|
u64 addr;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
if (!is_kprobe) {
|
|
|
|
map = dso__new_map(tp->module);
|
|
|
|
if (!map)
|
|
|
|
goto out;
|
|
|
|
addr = tp->address;
|
|
|
|
sym = map__find_symbol(map, addr, NULL);
|
|
|
|
} else {
|
|
|
|
addr = kernel_get_symbol_address_by_name(tp->symbol, true);
|
|
|
|
if (addr) {
|
|
|
|
addr += tp->offset;
|
|
|
|
sym = __find_kernel_function(addr, &map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!sym)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pp->retprobe = tp->retprobe;
|
|
|
|
pp->offset = addr - map->unmap_ip(map, sym->start);
|
|
|
|
pp->function = strdup(sym->name);
|
|
|
|
ret = pp->function ? 0 : -ENOMEM;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (map && !is_kprobe) {
|
|
|
|
dso__delete(map->dso);
|
|
|
|
map__delete(map);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_to_perf_probe_point(struct probe_trace_point *tp,
|
|
|
|
struct perf_probe_point *pp,
|
|
|
|
bool is_kprobe)
|
|
|
|
{
|
|
|
|
char buf[128];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pr_debug("Failed to find probe point from both of dwarf and map.\n");
|
|
|
|
|
|
|
|
if (tp->symbol) {
|
|
|
|
pp->function = strdup(tp->symbol);
|
|
|
|
pp->offset = tp->offset;
|
|
|
|
} else if (!tp->module && !is_kprobe) {
|
|
|
|
ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
pp->function = strdup(buf);
|
|
|
|
pp->offset = 0;
|
|
|
|
}
|
|
|
|
if (pp->function == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pp->retprobe = tp->retprobe;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
|
2012-04-16 06:09:09 -06:00
|
|
|
struct perf_probe_event *pev, bool is_kprobe)
|
2010-03-16 16:06:12 -06:00
|
|
|
{
|
2010-04-12 11:17:56 -06:00
|
|
|
char buf[64] = "";
|
2010-04-12 11:17:42 -06:00
|
|
|
int i, ret;
|
2010-03-16 16:06:12 -06:00
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
/* Convert event/group name */
|
2010-04-12 11:17:56 -06:00
|
|
|
pev->event = strdup(tev->event);
|
|
|
|
pev->group = strdup(tev->group);
|
|
|
|
if (pev->event == NULL || pev->group == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-16 16:06:19 -06:00
|
|
|
|
2010-03-22 10:10:26 -06:00
|
|
|
/* Convert trace_point to probe_point */
|
2014-02-05 22:32:23 -07:00
|
|
|
ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-03-22 10:10:26 -06:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Convert trace_arg to probe_arg */
|
|
|
|
pev->nargs = tev->nargs;
|
2010-04-12 11:17:49 -06:00
|
|
|
pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
|
|
|
|
if (pev->args == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-12 11:17:56 -06:00
|
|
|
for (i = 0; i < tev->nargs && ret >= 0; i++) {
|
2010-03-16 16:06:12 -06:00
|
|
|
if (tev->args[i].name)
|
2010-04-12 11:17:56 -06:00
|
|
|
pev->args[i].name = strdup(tev->args[i].name);
|
2010-03-16 16:06:12 -06:00
|
|
|
else {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = synthesize_probe_trace_arg(&tev->args[i],
|
2010-04-12 11:17:42 -06:00
|
|
|
buf, 64);
|
2010-04-12 11:17:56 -06:00
|
|
|
pev->args[i].name = strdup(buf);
|
2010-03-16 16:06:12 -06:00
|
|
|
}
|
2010-04-12 11:17:56 -06:00
|
|
|
if (pev->args[i].name == NULL && ret >= 0)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
clear_perf_probe_event(pev);
|
|
|
|
|
|
|
|
return ret;
|
2010-03-16 16:06:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void clear_perf_probe_event(struct perf_probe_event *pev)
|
|
|
|
{
|
|
|
|
struct perf_probe_point *pp = &pev->point;
|
2010-03-16 16:06:26 -06:00
|
|
|
struct perf_probe_arg_field *field, *next;
|
2010-03-16 16:06:12 -06:00
|
|
|
int i;
|
|
|
|
|
2013-12-26 11:54:57 -07:00
|
|
|
free(pev->event);
|
|
|
|
free(pev->group);
|
|
|
|
free(pp->file);
|
|
|
|
free(pp->function);
|
|
|
|
free(pp->lazy_line);
|
|
|
|
|
2010-03-16 16:06:26 -06:00
|
|
|
for (i = 0; i < pev->nargs; i++) {
|
2013-12-26 11:54:57 -07:00
|
|
|
free(pev->args[i].name);
|
|
|
|
free(pev->args[i].var);
|
|
|
|
free(pev->args[i].type);
|
2010-03-16 16:06:26 -06:00
|
|
|
field = pev->args[i].field;
|
|
|
|
while (field) {
|
|
|
|
next = field->next;
|
2013-12-27 12:55:14 -07:00
|
|
|
zfree(&field->name);
|
2010-03-16 16:06:26 -06:00
|
|
|
free(field);
|
|
|
|
field = next;
|
|
|
|
}
|
|
|
|
}
|
2013-12-26 11:54:57 -07:00
|
|
|
free(pev->args);
|
2010-03-16 16:06:12 -06:00
|
|
|
memset(pev, 0, sizeof(*pev));
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static void clear_probe_trace_event(struct probe_trace_event *tev)
|
2010-03-16 16:06:12 -06:00
|
|
|
{
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_arg_ref *ref, *next;
|
2010-03-16 16:06:12 -06:00
|
|
|
int i;
|
|
|
|
|
2013-12-26 11:54:57 -07:00
|
|
|
free(tev->event);
|
|
|
|
free(tev->group);
|
|
|
|
free(tev->point.symbol);
|
|
|
|
free(tev->point.module);
|
2010-03-16 16:06:12 -06:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
2013-12-26 11:54:57 -07:00
|
|
|
free(tev->args[i].name);
|
|
|
|
free(tev->args[i].value);
|
|
|
|
free(tev->args[i].type);
|
2010-03-16 16:06:12 -06:00
|
|
|
ref = tev->args[i].ref;
|
|
|
|
while (ref) {
|
|
|
|
next = ref->next;
|
|
|
|
free(ref);
|
|
|
|
ref = next;
|
|
|
|
}
|
|
|
|
}
|
2013-12-26 11:54:57 -07:00
|
|
|
free(tev->args);
|
2010-03-16 16:06:12 -06:00
|
|
|
memset(tev, 0, sizeof(*tev));
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
static void print_open_warning(int err, bool is_kprobe)
|
2012-04-16 06:09:09 -06:00
|
|
|
{
|
2014-08-13 20:22:34 -06:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
if (err == -ENOENT) {
|
2012-04-16 06:09:09 -06:00
|
|
|
const char *config;
|
|
|
|
|
|
|
|
if (!is_kprobe)
|
|
|
|
config = "CONFIG_UPROBE_EVENTS";
|
|
|
|
else
|
|
|
|
config = "CONFIG_KPROBE_EVENTS";
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
pr_warning("%cprobe_events file does not exist"
|
|
|
|
" - please rebuild kernel with %s.\n",
|
|
|
|
is_kprobe ? 'k' : 'u', config);
|
|
|
|
} else if (err == -ENOTSUP)
|
|
|
|
pr_warning("Debugfs is not mounted.\n");
|
|
|
|
else
|
|
|
|
pr_warning("Failed to open %cprobe_events: %s\n",
|
|
|
|
is_kprobe ? 'k' : 'u',
|
|
|
|
strerror_r(-err, sbuf, sizeof(sbuf)));
|
2012-04-16 06:09:09 -06:00
|
|
|
}
|
|
|
|
|
2014-08-13 10:12:50 -06:00
|
|
|
static void print_both_open_warning(int kerr, int uerr)
|
|
|
|
{
|
|
|
|
/* Both kprobes and uprobes are disabled, warn it. */
|
|
|
|
if (kerr == -ENOTSUP && uerr == -ENOTSUP)
|
|
|
|
pr_warning("Debugfs is not mounted.\n");
|
|
|
|
else if (kerr == -ENOENT && uerr == -ENOENT)
|
|
|
|
pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
|
|
|
|
"or/and CONFIG_UPROBE_EVENTS.\n");
|
|
|
|
else {
|
2014-08-13 20:22:34 -06:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2014-08-13 10:12:50 -06:00
|
|
|
pr_warning("Failed to open kprobe events: %s.\n",
|
|
|
|
strerror_r(-kerr, sbuf, sizeof(sbuf)));
|
|
|
|
pr_warning("Failed to open uprobe events: %s.\n",
|
|
|
|
strerror_r(-uerr, sbuf, sizeof(sbuf)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
static int open_probe_events(const char *trace_file, bool readwrite)
|
2009-11-30 17:20:17 -07:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
2010-04-14 16:39:28 -06:00
|
|
|
const char *__debugfs;
|
2009-11-30 17:20:17 -07:00
|
|
|
int ret;
|
|
|
|
|
2010-04-14 16:39:28 -06:00
|
|
|
__debugfs = debugfs_find_mountpoint();
|
2014-08-13 10:12:48 -06:00
|
|
|
if (__debugfs == NULL)
|
|
|
|
return -ENOTSUP;
|
2010-04-14 16:39:28 -06:00
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret >= 0) {
|
2010-04-14 16:39:28 -06:00
|
|
|
pr_debug("Opening %s write=%d\n", buf, readwrite);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (readwrite && !probe_event_dry_run)
|
|
|
|
ret = open(buf, O_RDWR, O_APPEND);
|
|
|
|
else
|
|
|
|
ret = open(buf, O_RDONLY, 0);
|
2010-03-16 16:06:05 -06:00
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
if (ret < 0)
|
2014-08-13 10:12:48 -06:00
|
|
|
ret = -errno;
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
static int open_kprobe_events(bool readwrite)
|
|
|
|
{
|
2014-08-13 10:12:48 -06:00
|
|
|
return open_probe_events("tracing/kprobe_events", readwrite);
|
2012-04-16 06:09:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int open_uprobe_events(bool readwrite)
|
|
|
|
{
|
2014-08-13 10:12:48 -06:00
|
|
|
return open_probe_events("tracing/uprobe_events", readwrite);
|
2012-04-16 06:09:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get raw string list of current kprobe_events or uprobe_events */
|
2010-07-29 08:13:51 -06:00
|
|
|
static struct strlist *get_probe_trace_command_rawlist(int fd)
|
2009-11-30 17:20:17 -07:00
|
|
|
{
|
|
|
|
int ret, idx;
|
|
|
|
FILE *fp;
|
|
|
|
char buf[MAX_CMDLEN];
|
|
|
|
char *p;
|
|
|
|
struct strlist *sl;
|
|
|
|
|
|
|
|
sl = strlist__new(true, NULL);
|
|
|
|
|
|
|
|
fp = fdopen(dup(fd), "r");
|
|
|
|
while (!feof(fp)) {
|
|
|
|
p = fgets(buf, MAX_CMDLEN, fp);
|
|
|
|
if (!p)
|
|
|
|
break;
|
|
|
|
|
|
|
|
idx = strlen(p) - 1;
|
|
|
|
if (p[idx] == '\n')
|
|
|
|
p[idx] = '\0';
|
|
|
|
ret = strlist__add(sl, buf);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0) {
|
2014-08-13 20:22:30 -06:00
|
|
|
pr_debug("strlist__add failed (%d)\n", ret);
|
2010-04-12 11:17:42 -06:00
|
|
|
strlist__delete(sl);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return sl;
|
|
|
|
}
|
|
|
|
|
2009-12-08 15:02:40 -07:00
|
|
|
/* Show an event */
|
2014-02-05 22:32:13 -07:00
|
|
|
static int show_perf_probe_event(struct perf_probe_event *pev,
|
|
|
|
const char *module)
|
2009-12-08 15:02:40 -07:00
|
|
|
{
|
2009-12-15 08:31:21 -07:00
|
|
|
int i, ret;
|
2009-12-08 15:02:40 -07:00
|
|
|
char buf[128];
|
2010-03-16 16:06:12 -06:00
|
|
|
char *place;
|
2009-12-08 15:02:40 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Synthesize only event probe point */
|
|
|
|
place = synthesize_perf_probe_point(&pev->point);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!place)
|
|
|
|
return -EINVAL;
|
2010-03-16 16:06:12 -06:00
|
|
|
|
|
|
|
ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
|
2009-12-15 08:31:21 -07:00
|
|
|
if (ret < 0)
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
|
|
|
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info(" %-20s (on %s", buf, place);
|
2014-02-05 22:32:13 -07:00
|
|
|
if (module)
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info(" in %s", module);
|
2009-12-08 15:02:40 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
if (pev->nargs > 0) {
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info(" with");
|
2010-03-16 16:06:26 -06:00
|
|
|
for (i = 0; i < pev->nargs; i++) {
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = synthesize_perf_probe_arg(&pev->args[i],
|
|
|
|
buf, 128);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info(" %s", buf);
|
2010-03-16 16:06:26 -06:00
|
|
|
}
|
2009-12-08 15:02:40 -07:00
|
|
|
}
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info(")\n");
|
2010-03-16 16:06:12 -06:00
|
|
|
free(place);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2009-12-08 15:02:40 -07:00
|
|
|
}
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
static int __show_perf_probe_events(int fd, bool is_kprobe)
|
2009-11-30 17:20:17 -07:00
|
|
|
{
|
2012-04-16 06:09:09 -06:00
|
|
|
int ret = 0;
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_event tev;
|
2010-03-16 16:06:12 -06:00
|
|
|
struct perf_probe_event pev;
|
2009-11-30 17:20:17 -07:00
|
|
|
struct strlist *rawlist;
|
|
|
|
struct str_node *ent;
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
memset(&tev, 0, sizeof(tev));
|
|
|
|
memset(&pev, 0, sizeof(pev));
|
2010-01-05 15:47:10 -07:00
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
rawlist = get_probe_trace_command_rawlist(fd);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!rawlist)
|
2014-08-13 20:22:30 -06:00
|
|
|
return -ENOMEM;
|
2009-11-30 17:20:17 -07:00
|
|
|
|
2009-12-15 08:32:03 -07:00
|
|
|
strlist__for_each(ent, rawlist) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = parse_probe_trace_command(ent->s, &tev);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret >= 0) {
|
2012-04-16 06:09:09 -06:00
|
|
|
ret = convert_to_perf_probe_event(&tev, &pev,
|
|
|
|
is_kprobe);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret >= 0)
|
2014-02-05 22:32:13 -07:00
|
|
|
ret = show_perf_probe_event(&pev,
|
|
|
|
tev.point.module);
|
2010-04-12 11:17:42 -06:00
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
clear_perf_probe_event(&pev);
|
2010-07-29 08:13:51 -06:00
|
|
|
clear_probe_trace_event(&tev);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
|
|
|
strlist__delete(rawlist);
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return ret;
|
2009-11-30 17:20:17 -07:00
|
|
|
}
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
/* List up current perf-probe events */
|
|
|
|
int show_perf_probe_events(void)
|
|
|
|
{
|
2014-08-13 10:12:48 -06:00
|
|
|
int kp_fd, up_fd, ret;
|
2012-04-16 06:09:09 -06:00
|
|
|
|
|
|
|
setup_pager();
|
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
ret = init_symbol_maps(false);
|
2012-04-16 06:09:09 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
kp_fd = open_kprobe_events(false);
|
|
|
|
if (kp_fd >= 0) {
|
|
|
|
ret = __show_perf_probe_events(kp_fd, true);
|
|
|
|
close(kp_fd);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
up_fd = open_uprobe_events(false);
|
|
|
|
if (kp_fd < 0 && up_fd < 0) {
|
2014-08-13 10:12:50 -06:00
|
|
|
print_both_open_warning(kp_fd, up_fd);
|
2014-08-13 10:12:48 -06:00
|
|
|
ret = kp_fd;
|
|
|
|
goto out;
|
2012-04-16 06:09:09 -06:00
|
|
|
}
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
if (up_fd >= 0) {
|
|
|
|
ret = __show_perf_probe_events(up_fd, false);
|
|
|
|
close(up_fd);
|
|
|
|
}
|
|
|
|
out:
|
2014-02-05 22:32:04 -07:00
|
|
|
exit_symbol_maps();
|
2012-04-16 06:09:09 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-30 17:20:25 -07:00
|
|
|
/* Get current perf-probe event names */
|
2010-07-29 08:13:51 -06:00
|
|
|
static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
|
2009-11-30 17:20:25 -07:00
|
|
|
{
|
2009-12-08 15:03:23 -07:00
|
|
|
char buf[128];
|
2009-11-30 17:20:25 -07:00
|
|
|
struct strlist *sl, *rawlist;
|
|
|
|
struct str_node *ent;
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_event tev;
|
2010-04-12 11:17:42 -06:00
|
|
|
int ret = 0;
|
2009-11-30 17:20:25 -07:00
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
memset(&tev, 0, sizeof(tev));
|
2010-07-29 08:13:51 -06:00
|
|
|
rawlist = get_probe_trace_command_rawlist(fd);
|
2014-08-13 20:22:30 -06:00
|
|
|
if (!rawlist)
|
|
|
|
return NULL;
|
2009-12-07 10:00:46 -07:00
|
|
|
sl = strlist__new(true, NULL);
|
2009-12-15 08:32:03 -07:00
|
|
|
strlist__for_each(ent, rawlist) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = parse_probe_trace_command(ent->s, &tev);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2009-12-08 15:03:23 -07:00
|
|
|
if (include_group) {
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = e_snprintf(buf, 128, "%s:%s", tev.group,
|
|
|
|
tev.event);
|
|
|
|
if (ret >= 0)
|
|
|
|
ret = strlist__add(sl, buf);
|
2009-12-08 15:03:23 -07:00
|
|
|
} else
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = strlist__add(sl, tev.event);
|
2010-07-29 08:13:51 -06:00
|
|
|
clear_probe_trace_event(&tev);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2009-11-30 17:20:25 -07:00
|
|
|
}
|
|
|
|
strlist__delete(rawlist);
|
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
strlist__delete(sl);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-11-30 17:20:25 -07:00
|
|
|
return sl;
|
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
|
2009-11-30 17:19:58 -07:00
|
|
|
{
|
2010-04-20 18:01:05 -06:00
|
|
|
int ret = 0;
|
2010-07-29 08:13:51 -06:00
|
|
|
char *buf = synthesize_probe_trace_command(tev);
|
2014-08-13 20:22:34 -06:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!buf) {
|
2010-07-29 08:13:51 -06:00
|
|
|
pr_debug("Failed to synthesize probe trace event.\n");
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-08 15:03:23 -07:00
|
|
|
pr_debug("Writing event: %s\n", buf);
|
2010-03-16 16:06:05 -06:00
|
|
|
if (!probe_event_dry_run) {
|
|
|
|
ret = write(fd, buf, strlen(buf));
|
2015-01-10 03:33:48 -07:00
|
|
|
if (ret <= 0) {
|
|
|
|
ret = -errno;
|
2010-04-12 11:17:42 -06:00
|
|
|
pr_warning("Failed to write event: %s\n",
|
2014-08-13 20:22:34 -06:00
|
|
|
strerror_r(errno, sbuf, sizeof(sbuf)));
|
2015-01-10 03:33:48 -07:00
|
|
|
}
|
2010-03-16 16:06:05 -06:00
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
free(buf);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
static int get_new_event_name(char *buf, size_t len, const char *base,
|
|
|
|
struct strlist *namelist, bool allow_suffix)
|
2009-11-30 17:20:25 -07:00
|
|
|
{
|
|
|
|
int i, ret;
|
2009-12-08 15:03:02 -07:00
|
|
|
|
|
|
|
/* Try no suffix */
|
|
|
|
ret = e_snprintf(buf, len, "%s", base);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0) {
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_debug("snprintf() failed: %d\n", ret);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2009-12-08 15:03:02 -07:00
|
|
|
if (!strlist__has_entry(namelist, buf))
|
2010-04-12 11:17:42 -06:00
|
|
|
return 0;
|
2009-12-08 15:03:02 -07:00
|
|
|
|
2009-12-15 08:32:25 -07:00
|
|
|
if (!allow_suffix) {
|
|
|
|
pr_warning("Error: event \"%s\" already exists. "
|
|
|
|
"(Use -f to force duplicates.)\n", base);
|
2010-04-12 11:17:42 -06:00
|
|
|
return -EEXIST;
|
2009-12-15 08:32:25 -07:00
|
|
|
}
|
|
|
|
|
2009-12-08 15:03:02 -07:00
|
|
|
/* Try to add suffix */
|
|
|
|
for (i = 1; i < MAX_EVENT_INDEX; i++) {
|
2009-11-30 17:20:25 -07:00
|
|
|
ret = e_snprintf(buf, len, "%s_%d", base, i);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0) {
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_debug("snprintf() failed: %d\n", ret);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2009-11-30 17:20:25 -07:00
|
|
|
if (!strlist__has_entry(namelist, buf))
|
|
|
|
break;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
if (i == MAX_EVENT_INDEX) {
|
|
|
|
pr_warning("Too many events are on the same function.\n");
|
|
|
|
ret = -ERANGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2009-11-30 17:20:25 -07:00
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int __add_probe_trace_events(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event *tevs,
|
2010-04-12 11:17:42 -06:00
|
|
|
int ntevs, bool allow_suffix)
|
2009-11-30 17:19:58 -07:00
|
|
|
{
|
2010-04-12 11:17:42 -06:00
|
|
|
int i, fd, ret;
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_event *tev = NULL;
|
2010-03-16 16:06:12 -06:00
|
|
|
char buf[64];
|
|
|
|
const char *event, *group;
|
2009-11-30 17:20:25 -07:00
|
|
|
struct strlist *namelist;
|
2009-11-30 17:19:58 -07:00
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
if (pev->uprobes)
|
|
|
|
fd = open_uprobe_events(true);
|
|
|
|
else
|
|
|
|
fd = open_kprobe_events(true);
|
|
|
|
|
2014-08-13 10:12:48 -06:00
|
|
|
if (fd < 0) {
|
|
|
|
print_open_warning(fd, !pev->uprobes);
|
2010-04-12 11:17:42 -06:00
|
|
|
return fd;
|
2014-08-13 10:12:48 -06:00
|
|
|
}
|
|
|
|
|
2009-11-30 17:20:25 -07:00
|
|
|
/* Get current event names */
|
2010-07-29 08:13:51 -06:00
|
|
|
namelist = get_probe_trace_event_names(fd, false);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!namelist) {
|
|
|
|
pr_debug("Failed to get current event list.\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = 0;
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
|
2010-04-12 11:17:56 -06:00
|
|
|
for (i = 0; i < ntevs; i++) {
|
2010-03-16 16:06:12 -06:00
|
|
|
tev = &tevs[i];
|
|
|
|
if (pev->event)
|
|
|
|
event = pev->event;
|
|
|
|
else
|
|
|
|
if (pev->point.function)
|
|
|
|
event = pev->point.function;
|
|
|
|
else
|
|
|
|
event = tev->point.symbol;
|
|
|
|
if (pev->group)
|
|
|
|
group = pev->group;
|
|
|
|
else
|
|
|
|
group = PERFPROBE_GROUP;
|
|
|
|
|
|
|
|
/* Get an unused new event name */
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = get_new_event_name(buf, 64, event,
|
|
|
|
namelist, allow_suffix);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2010-03-16 16:06:12 -06:00
|
|
|
event = buf;
|
|
|
|
|
2010-04-12 11:17:56 -06:00
|
|
|
tev->event = strdup(event);
|
|
|
|
tev->group = strdup(group);
|
|
|
|
if (tev->event == NULL || tev->group == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = write_probe_trace_event(fd, tev);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Add added event name to namelist */
|
|
|
|
strlist__add(namelist, event);
|
|
|
|
|
|
|
|
/* Trick here - save current event/group */
|
|
|
|
event = pev->event;
|
|
|
|
group = pev->group;
|
|
|
|
pev->event = tev->event;
|
|
|
|
pev->group = tev->group;
|
2014-02-05 22:32:13 -07:00
|
|
|
show_perf_probe_event(pev, tev->point.module);
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Trick here - restore current event/group */
|
|
|
|
pev->event = (char *)event;
|
|
|
|
pev->group = (char *)group;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probes after the first probe which comes from same
|
|
|
|
* user input are always allowed to add suffix, because
|
|
|
|
* there might be several addresses corresponding to
|
|
|
|
* one code line.
|
|
|
|
*/
|
|
|
|
allow_suffix = true;
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
if (ret >= 0) {
|
|
|
|
/* Show how to use the event. */
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info("\nYou can now use it in all perf tools, such as:\n\n");
|
|
|
|
pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
|
2010-04-12 11:17:42 -06:00
|
|
|
tev->event);
|
|
|
|
}
|
2009-12-08 15:02:47 -07:00
|
|
|
|
2009-12-07 10:00:46 -07:00
|
|
|
strlist__delete(namelist);
|
2009-11-30 17:19:58 -07:00
|
|
|
close(fd);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2009-11-30 17:19:58 -07:00
|
|
|
}
|
2009-12-08 15:03:23 -07:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
static char *looking_function_name;
|
|
|
|
static int num_matched_functions;
|
|
|
|
|
|
|
|
static int probe_function_filter(struct map *map __maybe_unused,
|
|
|
|
struct symbol *sym)
|
|
|
|
{
|
|
|
|
if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
|
|
|
|
strcmp(looking_function_name, sym->name) == 0) {
|
|
|
|
num_matched_functions++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define strdup_or_goto(str, label) \
|
|
|
|
({ char *__p = strdup(str); if (!__p) goto label; __p; })
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find probe function addresses from map.
|
|
|
|
* Return an error or the number of found probe_trace_event
|
|
|
|
*/
|
|
|
|
static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs,
|
|
|
|
int max_tevs, const char *target)
|
2010-03-16 16:05:37 -06:00
|
|
|
{
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
struct map *map = NULL;
|
|
|
|
struct kmap *kmap = NULL;
|
|
|
|
struct ref_reloc_sym *reloc_sym = NULL;
|
2010-03-16 16:05:37 -06:00
|
|
|
struct symbol *sym;
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
struct rb_node *nd;
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_event *tev;
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
struct perf_probe_point *pp = &pev->point;
|
|
|
|
struct probe_trace_point *tp;
|
|
|
|
int ret, i;
|
2010-03-16 16:06:12 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
/* Init maps of given executable or kernel */
|
|
|
|
if (pev->uprobes)
|
|
|
|
map = dso__new_map(target);
|
|
|
|
else
|
|
|
|
map = kernel_get_module_map(target);
|
|
|
|
if (!map) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
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-25 22:41:53 -07:00
|
|
|
}
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
/*
|
|
|
|
* Load matched symbols: Since the different local symbols may have
|
|
|
|
* same name but different addresses, this lists all the symbols.
|
|
|
|
*/
|
|
|
|
num_matched_functions = 0;
|
|
|
|
looking_function_name = pp->function;
|
|
|
|
ret = map__load(map, probe_function_filter);
|
|
|
|
if (ret || num_matched_functions == 0) {
|
|
|
|
pr_err("Failed to find symbol %s in %s\n", pp->function,
|
|
|
|
target ? : "kernel");
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
} else if (num_matched_functions > max_tevs) {
|
|
|
|
pr_err("Too many functions matched in %s\n",
|
|
|
|
target ? : "kernel");
|
|
|
|
ret = -E2BIG;
|
|
|
|
goto out;
|
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-25 22:41:53 -07:00
|
|
|
}
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if (!pev->uprobes) {
|
|
|
|
kmap = map__kmap(map);
|
|
|
|
reloc_sym = kmap->ref_reloc_sym;
|
|
|
|
if (!reloc_sym) {
|
|
|
|
pr_warning("Relocated base symbol is not found!\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
/* Setup result trace-probe-events */
|
|
|
|
*tevs = zalloc(sizeof(*tev) * num_matched_functions);
|
|
|
|
if (!*tevs) {
|
2010-04-12 11:17:56 -06:00
|
|
|
ret = -ENOMEM;
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
goto out;
|
2010-04-12 11:17:56 -06:00
|
|
|
}
|
2011-07-25 08:08:08 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
ret = 0;
|
|
|
|
map__for_each_symbol(map, sym, nd) {
|
|
|
|
tev = (*tevs) + ret;
|
|
|
|
tp = &tev->point;
|
|
|
|
if (ret == num_matched_functions) {
|
|
|
|
pr_warning("Too many symbols are listed. Skip it.\n");
|
|
|
|
break;
|
2011-07-25 08:08:08 -06:00
|
|
|
}
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
ret++;
|
2011-07-25 08:08:08 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if (pp->offset > sym->end - sym->start) {
|
|
|
|
pr_warning("Offset %ld is bigger than the size of %s\n",
|
|
|
|
pp->offset, sym->name);
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
/* Add one probe point */
|
|
|
|
tp->address = map->unmap_ip(map, sym->start) + pp->offset;
|
|
|
|
if (reloc_sym) {
|
|
|
|
tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
|
|
|
|
tp->offset = tp->address - reloc_sym->addr;
|
|
|
|
} else {
|
|
|
|
tp->symbol = strdup_or_goto(sym->name, nomem_out);
|
|
|
|
tp->offset = pp->offset;
|
|
|
|
}
|
|
|
|
tp->retprobe = pp->retprobe;
|
|
|
|
if (target)
|
|
|
|
tev->point.module = strdup_or_goto(target, nomem_out);
|
|
|
|
tev->uprobes = pev->uprobes;
|
|
|
|
tev->nargs = pev->nargs;
|
|
|
|
if (tev->nargs) {
|
|
|
|
tev->args = zalloc(sizeof(struct probe_trace_arg) *
|
|
|
|
tev->nargs);
|
|
|
|
if (tev->args == NULL)
|
|
|
|
goto nomem_out;
|
2010-04-12 11:17:49 -06:00
|
|
|
}
|
2010-04-12 11:16:53 -06:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if (pev->args[i].name)
|
|
|
|
tev->args[i].name =
|
|
|
|
strdup_or_goto(pev->args[i].name,
|
|
|
|
nomem_out);
|
|
|
|
|
|
|
|
tev->args[i].value = strdup_or_goto(pev->args[i].var,
|
|
|
|
nomem_out);
|
|
|
|
if (pev->args[i].type)
|
|
|
|
tev->args[i].type =
|
|
|
|
strdup_or_goto(pev->args[i].type,
|
|
|
|
nomem_out);
|
2010-04-12 11:16:53 -06:00
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
}
|
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
out:
|
|
|
|
if (map && pev->uprobes) {
|
|
|
|
/* Only when using uprobe(exec) map needs to be released */
|
|
|
|
dso__delete(map->dso);
|
|
|
|
map__delete(map);
|
|
|
|
}
|
|
|
|
return ret;
|
2012-04-16 06:09:09 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
nomem_out:
|
|
|
|
ret = -ENOMEM;
|
|
|
|
err_out:
|
|
|
|
clear_probe_trace_events(*tevs, num_matched_functions);
|
|
|
|
zfree(tevs);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-02-27 21:13:01 -07:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs,
|
|
|
|
int max_tevs, const char *target)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (pev->uprobes && !pev->group) {
|
|
|
|
/* Replace group name if not given */
|
|
|
|
ret = convert_exec_to_group(target, &pev->group);
|
|
|
|
if (ret != 0) {
|
|
|
|
pr_warning("Failed to make a group name.\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2010-04-12 11:17:56 -06:00
|
|
|
}
|
2010-04-12 11:17:49 -06:00
|
|
|
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
/* Convert perf_probe_event with debuginfo */
|
|
|
|
ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret; /* Found in debuginfo or got an error */
|
|
|
|
|
|
|
|
return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
|
2010-03-16 16:06:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
struct __event_package {
|
|
|
|
struct perf_probe_event *pev;
|
2010-07-29 08:13:51 -06:00
|
|
|
struct probe_trace_event *tevs;
|
2010-03-16 16:06:12 -06:00
|
|
|
int ntevs;
|
|
|
|
};
|
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
|
2012-02-02 07:20:40 -07:00
|
|
|
int max_tevs, const char *target, bool force_add)
|
2010-03-16 16:06:12 -06:00
|
|
|
{
|
2010-04-12 11:17:42 -06:00
|
|
|
int i, j, ret;
|
2010-03-16 16:06:12 -06:00
|
|
|
struct __event_package *pkgs;
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
ret = 0;
|
2010-04-12 11:17:49 -06:00
|
|
|
pkgs = zalloc(sizeof(struct __event_package) * npevs);
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2010-04-12 11:17:49 -06:00
|
|
|
if (pkgs == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-16 16:06:12 -06:00
|
|
|
|
2014-02-05 22:32:04 -07:00
|
|
|
ret = init_symbol_maps(pevs->uprobes);
|
2010-08-02 20:11:40 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
free(pkgs);
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2010-08-02 20:11:40 -06:00
|
|
|
}
|
2010-03-16 16:06:12 -06:00
|
|
|
|
|
|
|
/* Loop 1: convert all events */
|
|
|
|
for (i = 0; i < npevs; i++) {
|
|
|
|
pkgs[i].pev = &pevs[i];
|
|
|
|
/* Convert with or without debuginfo */
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = convert_to_probe_trace_events(pkgs[i].pev,
|
2010-10-21 04:13:41 -06:00
|
|
|
&pkgs[i].tevs,
|
|
|
|
max_tevs,
|
2012-02-02 07:20:40 -07:00
|
|
|
target);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
pkgs[i].ntevs = ret;
|
2010-03-16 16:05:37 -06:00
|
|
|
}
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
/* Loop 2: add all events */
|
2011-02-22 02:56:18 -07:00
|
|
|
for (i = 0; i < npevs; i++) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
|
2010-04-12 11:17:42 -06:00
|
|
|
pkgs[i].ntevs, force_add);
|
2011-02-21 09:23:57 -07:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
end:
|
2010-08-02 20:11:40 -06:00
|
|
|
/* Loop 3: cleanup and free trace events */
|
|
|
|
for (i = 0; i < npevs; i++) {
|
2010-04-12 11:17:42 -06:00
|
|
|
for (j = 0; j < pkgs[i].ntevs; j++)
|
2010-07-29 08:13:51 -06:00
|
|
|
clear_probe_trace_event(&pkgs[i].tevs[j]);
|
2013-12-27 12:55:14 -07:00
|
|
|
zfree(&pkgs[i].tevs);
|
2010-08-02 20:11:40 -06:00
|
|
|
}
|
|
|
|
free(pkgs);
|
2014-02-05 22:32:04 -07:00
|
|
|
exit_symbol_maps();
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return ret;
|
2010-03-16 16:05:37 -06:00
|
|
|
}
|
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
static int __del_trace_probe_event(int fd, struct str_node *ent)
|
2009-12-15 08:32:10 -07:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char buf[128];
|
2010-03-16 16:06:12 -06:00
|
|
|
int ret;
|
2009-12-15 08:32:10 -07:00
|
|
|
|
2010-07-29 08:13:51 -06:00
|
|
|
/* Convert from perf-probe event to trace-probe event */
|
2010-04-12 11:17:42 -06:00
|
|
|
ret = e_snprintf(buf, 128, "-:%s", ent->s);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2009-12-15 08:32:10 -07:00
|
|
|
p = strchr(buf + 2, ':');
|
2010-04-12 11:17:42 -06:00
|
|
|
if (!p) {
|
|
|
|
pr_debug("Internal error: %s should have ':' but not.\n",
|
|
|
|
ent->s);
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
2009-12-15 08:32:10 -07:00
|
|
|
*p = '/';
|
|
|
|
|
2010-03-16 16:06:12 -06:00
|
|
|
pr_debug("Writing event: %s\n", buf);
|
|
|
|
ret = write(fd, buf, strlen(buf));
|
2011-10-04 04:45:04 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
ret = -errno;
|
2010-04-12 11:17:42 -06:00
|
|
|
goto error;
|
2011-10-04 04:45:04 -06:00
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
2014-10-27 14:31:31 -06:00
|
|
|
pr_info("Removed event: %s\n", ent->s);
|
2010-04-12 11:17:42 -06:00
|
|
|
return 0;
|
|
|
|
error:
|
2014-08-13 20:22:34 -06:00
|
|
|
pr_warning("Failed to delete event: %s\n",
|
|
|
|
strerror_r(-ret, buf, sizeof(buf)));
|
2010-04-12 11:17:42 -06:00
|
|
|
return ret;
|
2009-12-15 08:32:10 -07:00
|
|
|
}
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
static int del_trace_probe_event(int fd, const char *buf,
|
|
|
|
struct strlist *namelist)
|
2009-12-08 15:03:23 -07:00
|
|
|
{
|
2009-12-15 08:32:10 -07:00
|
|
|
struct str_node *ent, *n;
|
2012-04-16 06:09:09 -06:00
|
|
|
int ret = -1;
|
2009-12-08 15:03:23 -07:00
|
|
|
|
2009-12-15 08:32:10 -07:00
|
|
|
if (strpbrk(buf, "*?")) { /* Glob-exp */
|
|
|
|
strlist__for_each_safe(ent, n, namelist)
|
|
|
|
if (strglobmatch(ent->s, buf)) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = __del_trace_probe_event(fd, ent);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2009-12-15 08:32:10 -07:00
|
|
|
strlist__remove(namelist, ent);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ent = strlist__find(namelist, buf);
|
|
|
|
if (ent) {
|
2010-07-29 08:13:51 -06:00
|
|
|
ret = __del_trace_probe_event(fd, ent);
|
2010-04-12 11:17:42 -06:00
|
|
|
if (ret >= 0)
|
|
|
|
strlist__remove(namelist, ent);
|
2009-12-15 08:32:10 -07:00
|
|
|
}
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return ret;
|
2009-12-08 15:03:23 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 11:17:42 -06:00
|
|
|
int del_perf_probe_events(struct strlist *dellist)
|
2009-12-08 15:03:23 -07:00
|
|
|
{
|
2012-04-16 06:09:09 -06:00
|
|
|
int ret = -1, ufd = -1, kfd = -1;
|
|
|
|
char buf[128];
|
2009-12-08 15:03:23 -07:00
|
|
|
const char *group, *event;
|
|
|
|
char *p, *str;
|
|
|
|
struct str_node *ent;
|
2012-04-16 06:09:09 -06:00
|
|
|
struct strlist *namelist = NULL, *unamelist = NULL;
|
2010-04-12 11:17:42 -06:00
|
|
|
|
2009-12-08 15:03:23 -07:00
|
|
|
/* Get current event names */
|
2012-04-16 06:09:09 -06:00
|
|
|
kfd = open_kprobe_events(true);
|
2014-08-13 10:12:50 -06:00
|
|
|
if (kfd >= 0)
|
|
|
|
namelist = get_probe_trace_event_names(kfd, true);
|
2012-04-16 06:09:09 -06:00
|
|
|
|
|
|
|
ufd = open_uprobe_events(true);
|
2014-08-13 10:12:50 -06:00
|
|
|
if (ufd >= 0)
|
2012-04-16 06:09:09 -06:00
|
|
|
unamelist = get_probe_trace_event_names(ufd, true);
|
|
|
|
|
2014-08-13 10:12:50 -06:00
|
|
|
if (kfd < 0 && ufd < 0) {
|
|
|
|
print_both_open_warning(kfd, ufd);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2012-04-16 06:09:09 -06:00
|
|
|
if (namelist == NULL && unamelist == NULL)
|
|
|
|
goto error;
|
2009-12-08 15:03:23 -07:00
|
|
|
|
2009-12-15 08:32:03 -07:00
|
|
|
strlist__for_each(ent, dellist) {
|
2010-04-12 11:17:56 -06:00
|
|
|
str = strdup(ent->s);
|
|
|
|
if (str == NULL) {
|
|
|
|
ret = -ENOMEM;
|
2012-04-16 06:09:09 -06:00
|
|
|
goto error;
|
2010-04-12 11:17:56 -06:00
|
|
|
}
|
2009-12-15 08:32:10 -07:00
|
|
|
pr_debug("Parsing: %s\n", str);
|
2009-12-08 15:03:23 -07:00
|
|
|
p = strchr(str, ':');
|
|
|
|
if (p) {
|
|
|
|
group = str;
|
|
|
|
*p = '\0';
|
|
|
|
event = p + 1;
|
|
|
|
} else {
|
2009-12-15 08:32:10 -07:00
|
|
|
group = "*";
|
2009-12-08 15:03:23 -07:00
|
|
|
event = str;
|
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
|
|
|
ret = e_snprintf(buf, 128, "%s:%s", group, event);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("Failed to copy event.");
|
|
|
|
free(str);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2009-12-15 08:32:10 -07:00
|
|
|
pr_debug("Group: %s, Event: %s\n", group, event);
|
2012-04-16 06:09:09 -06:00
|
|
|
|
|
|
|
if (namelist)
|
|
|
|
ret = del_trace_probe_event(kfd, buf, namelist);
|
|
|
|
|
|
|
|
if (unamelist && ret != 0)
|
|
|
|
ret = del_trace_probe_event(ufd, buf, unamelist);
|
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
pr_info("Info: Event \"%s\" does not exist.\n", buf);
|
|
|
|
|
2009-12-08 15:03:23 -07:00
|
|
|
free(str);
|
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (kfd >= 0) {
|
2012-05-31 05:46:43 -06:00
|
|
|
strlist__delete(namelist);
|
2012-04-16 06:09:09 -06:00
|
|
|
close(kfd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ufd >= 0) {
|
2012-05-31 05:46:43 -06:00
|
|
|
strlist__delete(unamelist);
|
2012-04-16 06:09:09 -06:00
|
|
|
close(ufd);
|
|
|
|
}
|
2010-04-12 11:17:42 -06:00
|
|
|
|
|
|
|
return ret;
|
2009-12-08 15:03:23 -07:00
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2011-01-20 07:15:45 -07:00
|
|
|
/* TODO: don't use a global variable for filter ... */
|
|
|
|
static struct strfilter *available_func_filter;
|
2009-12-08 15:03:23 -07:00
|
|
|
|
2011-01-13 05:46:11 -07:00
|
|
|
/*
|
2011-01-20 07:15:45 -07:00
|
|
|
* If a symbol corresponds to a function with global binding and
|
|
|
|
* matches filter return 0. For all others return 1.
|
2011-01-13 05:46:11 -07:00
|
|
|
*/
|
2012-09-10 16:15:03 -06:00
|
|
|
static int filter_available_functions(struct map *map __maybe_unused,
|
2011-01-20 07:15:45 -07:00
|
|
|
struct symbol *sym)
|
2011-01-13 05:46:11 -07:00
|
|
|
{
|
perf probe: Allow to add events on the local functions
Allow to add events on the local functions without debuginfo.
(With the debuginfo, we can add events even on inlined functions)
Currently, probing on local functions requires debuginfo to
locate actual address. It is also possible without debuginfo since
we have symbol maps.
Without this change;
----
# ./perf probe -a t_show
Added new event:
probe:t_show (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
no symbols found in /kbuild/ksrc/linux-3/tools/perf/perf, maybe install a debug package?
Failed to load map.
Error: Failed to add events. (-22)
----
As the above results, perf probe just put one event
on the first found symbol for kprobe event. Moreover,
for uprobe event, perf probe failed to find local
functions.
With this change;
----
# ./perf probe -a t_show
Added new events:
probe:t_show (on t_show)
probe:t_show_1 (on t_show)
probe:t_show_2 (on t_show)
probe:t_show_3 (on t_show)
You can now use it in all perf tools, such as:
perf record -e probe:t_show_3 -aR sleep 1
# ./perf probe -x perf -a identity__map_ip
Added new events:
probe_perf:identity__map_ip (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_1 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_2 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
probe_perf:identity__map_ip_3 (on identity__map_ip in /kbuild/ksrc/linux-3/tools/perf/perf)
You can now use it in all perf tools, such as:
perf record -e probe_perf:identity__map_ip_3 -aR sleep 1
----
Now we succeed to put events on every given local functions
for both kprobes and uprobes. :)
Note that this also introduces some symbol rbtree
iteration macros; symbols__for_each, dso__for_each_symbol,
and map__for_each_symbol. These are for walking through
the symbol list in a map.
Changes from v2:
- Fix add_exec_to_probe_trace_events() not to convert address
to tp->symbol any more.
- Fix to set kernel probes based on ref_reloc_sym.
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: "David A. Long" <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20140206053225.29635.15026.stgit@kbuild-fedora.yrl.intra.hitachi.co.jp
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2014-02-05 22:32:25 -07:00
|
|
|
if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
|
2011-01-20 07:15:45 -07:00
|
|
|
strfilter__compare(available_func_filter, sym->name))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
2011-01-13 05:46:11 -07:00
|
|
|
}
|
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
int show_available_funcs(const char *target, struct strfilter *_filter,
|
|
|
|
bool user)
|
2011-01-13 05:46:11 -07:00
|
|
|
{
|
|
|
|
struct map *map;
|
|
|
|
int ret;
|
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
ret = init_symbol_maps(user);
|
2011-01-13 05:46:11 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
/* Get a symbol map */
|
|
|
|
if (user)
|
|
|
|
map = dso__new_map(target);
|
|
|
|
else
|
|
|
|
map = kernel_get_module_map(target);
|
2011-01-13 05:46:11 -07:00
|
|
|
if (!map) {
|
2014-02-05 22:32:11 -07:00
|
|
|
pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
|
2011-01-13 05:46:11 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
/* Load symbols with given filter */
|
2011-01-20 07:15:45 -07:00
|
|
|
available_func_filter = _filter;
|
2014-02-05 22:32:11 -07:00
|
|
|
if (map__load(map, filter_available_functions)) {
|
|
|
|
pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
if (!dso__sorted_by_name(map->dso, map->type))
|
|
|
|
dso__sort_by_name(map->dso, map->type);
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
/* Show all (filtered) symbols */
|
|
|
|
setup_pager();
|
|
|
|
dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
|
|
|
|
end:
|
|
|
|
if (user) {
|
|
|
|
dso__delete(map->dso);
|
|
|
|
map__delete(map);
|
|
|
|
}
|
|
|
|
exit_symbol_maps();
|
2012-04-16 06:09:09 -06:00
|
|
|
|
2014-02-05 22:32:11 -07:00
|
|
|
return ret;
|
2012-04-16 06:09:09 -06:00
|
|
|
}
|
|
|
|
|