2009-12-01 08:19:58 +08:00
|
|
|
/*
|
2010-07-29 22:13:51 +08:00
|
|
|
* probe-event.c : perf-probe definition to probe_events format converter
|
2009-12-01 08:19:58 +08: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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2017-04-18 02:23:08 +08:00
|
|
|
#include <inttypes.h>
|
2009-12-01 08:19:58 +08:00
|
|
|
#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-12-01 08:20:17 +08:00
|
|
|
#include <stdarg.h>
|
|
|
|
#include <limits.h>
|
2011-01-13 20:46:11 +08:00
|
|
|
#include <elf.h>
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2010-03-17 06:05:30 +08:00
|
|
|
#include "util.h"
|
2009-12-01 08:19:58 +08:00
|
|
|
#include "event.h"
|
2019-01-22 21:24:34 +08:00
|
|
|
#include "namespaces.h"
|
2009-12-01 08:20:17 +08:00
|
|
|
#include "strlist.h"
|
2017-04-18 21:57:25 +08:00
|
|
|
#include "strfilter.h"
|
2009-12-01 08:19:58 +08:00
|
|
|
#include "debug.h"
|
2010-01-06 06:47:10 +08:00
|
|
|
#include "cache.h"
|
2010-01-06 22:45:34 +08:00
|
|
|
#include "color.h"
|
2019-01-27 20:42:37 +08:00
|
|
|
#include "map.h"
|
2019-01-27 20:44:29 +08:00
|
|
|
#include "map_groups.h"
|
2010-03-17 06:05:37 +08:00
|
|
|
#include "symbol.h"
|
|
|
|
#include "thread.h"
|
2015-09-02 15:56:43 +08:00
|
|
|
#include <api/fs/fs.h>
|
2012-09-11 06:15:03 +08:00
|
|
|
#include "trace-event.h" /* For __maybe_unused */
|
2009-12-01 08:19:58 +08:00
|
|
|
#include "probe-event.h"
|
2010-03-17 06:06:12 +08:00
|
|
|
#include "probe-finder.h"
|
2015-07-15 17:14:07 +08:00
|
|
|
#include "probe-file.h"
|
2012-04-16 20:09:09 +08:00
|
|
|
#include "session.h"
|
2017-04-18 03:51:59 +08:00
|
|
|
#include "string2.h"
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2017-04-18 03:10:49 +08:00
|
|
|
#include "sane_ctype.h"
|
|
|
|
|
2009-12-01 08:19:58 +08:00
|
|
|
#define PERFPROBE_GROUP "probe"
|
|
|
|
|
2010-03-17 06:06:05 +08:00
|
|
|
bool probe_event_dry_run; /* Dry run flag */
|
2015-05-08 09:03:31 +08:00
|
|
|
struct probe_conf probe_conf;
|
2010-03-17 06:06:05 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
#define semantic_error(msg ...) pr_err("Semantic error :" msg)
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
int e_snprintf(char *str, size_t size, const char *format, ...)
|
2009-12-01 08:20:17 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-02-06 13:32:04 +08:00
|
|
|
static struct machine *host_machine;
|
2010-03-17 06:05:37 +08:00
|
|
|
|
2010-10-21 18:13:41 +08:00
|
|
|
/* Initialize symbol maps and path of vmlinux/modules */
|
2015-09-10 10:27:05 +08:00
|
|
|
int init_probe_symbol_maps(bool user_only)
|
2010-03-17 06:05:37 +08:00
|
|
|
{
|
2010-04-13 01:17:42 +08:00
|
|
|
int ret;
|
|
|
|
|
2010-03-17 06:05:37 +08:00
|
|
|
symbol_conf.sort_by_name = true;
|
2015-03-06 15:31:27 +08:00
|
|
|
symbol_conf.allow_aliases = true;
|
2014-08-12 14:40:45 +08:00
|
|
|
ret = symbol__init(NULL);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
pr_debug("Failed to init symbol map.\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-03-17 06:05:37 +08:00
|
|
|
|
2014-02-06 13:32:04 +08:00
|
|
|
if (host_machine || user_only) /* already initialized */
|
|
|
|
return 0;
|
2010-04-28 08:20:43 +08:00
|
|
|
|
2014-02-06 13:32:04 +08: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 18:13:41 +08:00
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
out:
|
|
|
|
if (ret < 0)
|
|
|
|
pr_warning("Failed to init vmlinux path.\n");
|
|
|
|
return ret;
|
2010-03-17 06:05:37 +08:00
|
|
|
}
|
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
void exit_probe_symbol_maps(void)
|
2014-02-06 13:32:04 +08:00
|
|
|
{
|
2016-06-22 21:19:11 +08:00
|
|
|
machine__delete(host_machine);
|
|
|
|
host_machine = NULL;
|
2014-02-06 13:32:04 +08:00
|
|
|
symbol__exit();
|
|
|
|
}
|
|
|
|
|
2014-02-06 13:32:20 +08:00
|
|
|
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;
|
2015-09-30 22:54:04 +08:00
|
|
|
struct map *map = machine__kernel_map(host_machine);
|
2014-02-06 13:32:20 +08:00
|
|
|
|
2016-09-02 06:25:52 +08:00
|
|
|
if (map__load(map) < 0)
|
2014-02-06 13:32:20 +08:00
|
|
|
return NULL;
|
|
|
|
|
2015-09-30 22:08:58 +08:00
|
|
|
kmap = map__kmap(map);
|
2015-04-07 16:22:45 +08:00
|
|
|
if (!kmap)
|
|
|
|
return NULL;
|
2014-02-06 13:32:20 +08:00
|
|
|
return kmap->ref_reloc_sym;
|
|
|
|
}
|
|
|
|
|
2015-10-01 00:41:33 +08:00
|
|
|
static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
|
|
|
|
bool reloc, bool reladdr)
|
2014-02-06 13:32:20 +08:00
|
|
|
{
|
|
|
|
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)
|
2015-10-01 00:41:33 +08:00
|
|
|
*addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
|
2014-02-06 13:32:20 +08:00
|
|
|
else {
|
2018-04-30 23:20:54 +08:00
|
|
|
sym = machine__find_kernel_symbol_by_name(host_machine, name, &map);
|
2015-10-01 00:41:33 +08:00
|
|
|
if (!sym)
|
|
|
|
return -ENOENT;
|
|
|
|
*addr = map->unmap_ip(map, sym->start) -
|
|
|
|
((reloc) ? 0 : map->reloc) -
|
|
|
|
((reladdr) ? map->start : 0);
|
2014-02-06 13:32:20 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-13 20:46:11 +08:00
|
|
|
static struct map *kernel_get_module_map(const char *module)
|
|
|
|
{
|
2018-04-25 04:06:25 +08:00
|
|
|
struct maps *maps = machine__kernel_maps(host_machine);
|
2015-05-22 22:52:22 +08:00
|
|
|
struct map *pos;
|
2011-01-13 20:46:11 +08:00
|
|
|
|
2011-06-27 15:27:51 +08:00
|
|
|
/* A file path -- this is an offline module */
|
|
|
|
if (module && strchr(module, '/'))
|
2017-01-04 11:29:05 +08:00
|
|
|
return dso__new_map(module);
|
2011-06-27 15:27:51 +08:00
|
|
|
|
2019-03-04 21:13:21 +08:00
|
|
|
if (!module) {
|
|
|
|
pos = machine__kernel_map(host_machine);
|
|
|
|
return map__get(pos);
|
|
|
|
}
|
2011-01-13 20:46:11 +08:00
|
|
|
|
2015-05-22 22:52:22 +08:00
|
|
|
for (pos = maps__first(maps); pos; pos = map__next(pos)) {
|
2016-08-05 20:22:36 +08:00
|
|
|
/* short_name is "[module]" */
|
2011-01-13 20:46:11 +08:00
|
|
|
if (strncmp(pos->dso->short_name + 1, module,
|
2016-08-05 20:22:36 +08:00
|
|
|
pos->dso->short_name_len - 2) == 0 &&
|
|
|
|
module[pos->dso->short_name_len - 2] == '\0') {
|
2018-05-24 22:17:34 +08:00
|
|
|
return map__get(pos);
|
2011-01-13 20:46:11 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
struct map *get_target_map(const char *target, struct nsinfo *nsi, bool user)
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
{
|
|
|
|
/* Init maps of given executable or kernel */
|
2017-07-06 09:48:10 +08:00
|
|
|
if (user) {
|
|
|
|
struct map *map;
|
|
|
|
|
|
|
|
map = dso__new_map(target);
|
|
|
|
if (map && map->dso)
|
|
|
|
map->dso->nsinfo = nsinfo__get(nsi);
|
|
|
|
return map;
|
|
|
|
} else {
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
return kernel_get_module_map(target);
|
2017-07-06 09:48:10 +08:00
|
|
|
}
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08: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-26 13:41:53 +08: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;
|
|
|
|
}
|
|
|
|
|
2016-10-03 18:34:31 +08:00
|
|
|
for (ptr2 = ptr1; *ptr2 != '\0'; ptr2++) {
|
2016-09-23 23:35:16 +08:00
|
|
|
if (!isalnum(*ptr2) && *ptr2 != '_') {
|
|
|
|
*ptr2 = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
perf probe: Support basic dwarf-based operations on uprobe events
Support basic dwarf(debuginfo) based operations for uprobe events. With
this change, perf probe can analyze debuginfo of user application binary
to set up new uprobe event.
This allows perf-probe --add(with local variables, line numbers) and
--line works with -x option. (Actually, --vars has already accepted -x
option)
For example, the following command shows the probe-able lines of a given
user space function. Something that so far was only available in the
'perf probe' tool for kernel space functions:
# ./perf probe -x perf --line map__load
<map__load@/home/fedora/ksrc/linux-2.6/tools/perf/util/map.c:0>
0 int map__load(struct map *map, symbol_filter_t filter)
1 {
2 const char *name = map->dso->long_name;
int nr;
5 if (dso__loaded(map->dso, map->type))
6 return 0;
8 nr = dso__load(map->dso, map, filter);
9 if (nr < 0) {
10 if (map->dso->has_build_id) {
And this shows the available variables at the given line of the
function.
# ./perf probe -x perf --vars map__load:8
Available variables at map__load:8
@<map__load+96>
char* name
struct map* map
symbol_filter_t filter
@<map__find_symbol+112>
char* name
symbol_filter_t filter
@<map__find_symbol_by_name+136>
char* name
symbol_filter_t filter
@<map_groups__find_symbol_by_name+176>
char* name
struct map* map
symbol_filter_t filter
And lastly, we can now define probe(s) with all available
variables on the given line:
# ./perf probe -x perf --add 'map__load:8 $vars'
Added new events:
probe_perf:map__load (on map__load:8 with $vars)
probe_perf:map__load_1 (on map__load:8 with $vars)
probe_perf:map__load_2 (on map__load:8 with $vars)
probe_perf:map__load_3 (on map__load:8 with $vars)
You can now use it in all perf tools, such as:
perf record -e probe_perf:map__load_3 -aR sleep 1
Changes from previous version:
- Add examples in the patch description.
- Use .text section start address and dwarf symbol address
for calculating the offset of given symbol, instead of
searching the symbol in symtab again.
With this change, we can safely handle multiple local
function instances (e.g. scnprintf in perf).
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: David A. Long <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: systemtap@sourceware.org
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20131226054152.22364.47021.stgit@kbuild-fedora.novalocal
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-12-26 13:41:53 +08:00
|
|
|
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: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
static void clear_perf_probe_point(struct perf_probe_point *pp)
|
|
|
|
{
|
|
|
|
free(pp->file);
|
|
|
|
free(pp->function);
|
|
|
|
free(pp->lazy_line);
|
|
|
|
}
|
|
|
|
|
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-06 13:32:25 +08: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);
|
|
|
|
}
|
|
|
|
|
2015-06-16 19:50:55 +08:00
|
|
|
static bool kprobe_blacklist__listed(unsigned long address);
|
|
|
|
static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
|
|
|
|
{
|
2015-10-01 00:41:33 +08:00
|
|
|
u64 etext_addr = 0;
|
|
|
|
int ret;
|
2015-06-18 10:49:10 +08:00
|
|
|
|
2015-06-16 19:50:55 +08:00
|
|
|
/* Get the address of _etext for checking non-probable text symbol */
|
2015-10-01 00:41:33 +08:00
|
|
|
ret = kernel_get_symbol_address_by_name("_etext", &etext_addr,
|
|
|
|
false, false);
|
2015-06-18 10:49:10 +08:00
|
|
|
|
2015-10-01 00:41:33 +08:00
|
|
|
if (ret == 0 && etext_addr < address)
|
2015-06-16 19:50:55 +08:00
|
|
|
pr_warning("%s is out of .text, skip it.\n", symbol);
|
|
|
|
else if (kprobe_blacklist__listed(address))
|
|
|
|
pr_warning("%s is blacklisted function, skip it.\n", symbol);
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-04-26 22:25:40 +08:00
|
|
|
/*
|
|
|
|
* @module can be module name of module file path. In case of path,
|
|
|
|
* inspect elf and find out what is actual module name.
|
|
|
|
* Caller has to free mod_name after using it.
|
|
|
|
*/
|
|
|
|
static char *find_module_name(const char *module)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
Elf *elf;
|
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
Elf_Data *data;
|
|
|
|
Elf_Scn *sec;
|
|
|
|
char *mod_name = NULL;
|
2017-01-02 23:20:49 +08:00
|
|
|
int name_offset;
|
2016-04-26 22:25:40 +08:00
|
|
|
|
|
|
|
fd = open(module, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
|
|
|
if (elf == NULL)
|
|
|
|
goto elf_err;
|
|
|
|
|
|
|
|
if (gelf_getehdr(elf, &ehdr) == NULL)
|
|
|
|
goto ret_err;
|
|
|
|
|
|
|
|
sec = elf_section_by_name(elf, &ehdr, &shdr,
|
|
|
|
".gnu.linkonce.this_module", NULL);
|
|
|
|
if (!sec)
|
|
|
|
goto ret_err;
|
|
|
|
|
|
|
|
data = elf_getdata(sec, NULL);
|
|
|
|
if (!data || !data->d_buf)
|
|
|
|
goto ret_err;
|
|
|
|
|
2017-01-02 23:20:49 +08:00
|
|
|
/*
|
|
|
|
* NOTE:
|
|
|
|
* '.gnu.linkonce.this_module' section of kernel module elf directly
|
|
|
|
* maps to 'struct module' from linux/module.h. This section contains
|
|
|
|
* actual module name which will be used by kernel after loading it.
|
|
|
|
* But, we cannot use 'struct module' here since linux/module.h is not
|
|
|
|
* exposed to user-space. Offset of 'name' has remained same from long
|
|
|
|
* time, so hardcoding it here.
|
|
|
|
*/
|
|
|
|
if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
|
|
|
|
name_offset = 12;
|
|
|
|
else /* expect ELFCLASS64 by default */
|
|
|
|
name_offset = 24;
|
|
|
|
|
|
|
|
mod_name = strdup((char *)data->d_buf + name_offset);
|
2016-04-26 22:25:40 +08:00
|
|
|
|
|
|
|
ret_err:
|
|
|
|
elf_end(elf);
|
|
|
|
elf_err:
|
|
|
|
close(fd);
|
|
|
|
return mod_name;
|
|
|
|
}
|
|
|
|
|
2013-09-30 18:07:11 +08:00
|
|
|
#ifdef HAVE_DWARF_SUPPORT
|
2015-05-28 10:25:05 +08:00
|
|
|
|
|
|
|
static int kernel_get_module_dso(const char *module, struct dso **pdso)
|
|
|
|
{
|
|
|
|
struct dso *dso;
|
|
|
|
struct map *map;
|
|
|
|
const char *vmlinux_name;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (module) {
|
2015-09-24 22:24:18 +08:00
|
|
|
char module_name[128];
|
|
|
|
|
|
|
|
snprintf(module_name, sizeof(module_name), "[%s]", module);
|
2018-04-24 23:16:09 +08:00
|
|
|
map = map_groups__find_by_name(&host_machine->kmaps, module_name);
|
2015-09-24 22:24:18 +08:00
|
|
|
if (map) {
|
|
|
|
dso = map->dso;
|
|
|
|
goto found;
|
2015-05-28 10:25:05 +08:00
|
|
|
}
|
|
|
|
pr_debug("Failed to find module %s.\n", module);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2015-09-30 22:54:04 +08:00
|
|
|
map = machine__kernel_map(host_machine);
|
2015-05-28 10:25:05 +08:00
|
|
|
dso = map->dso;
|
|
|
|
|
|
|
|
vmlinux_name = symbol_conf.vmlinux_name;
|
|
|
|
dso->load_errno = 0;
|
|
|
|
if (vmlinux_name)
|
2016-09-02 06:25:52 +08:00
|
|
|
ret = dso__load_vmlinux(dso, map, vmlinux_name, false);
|
2015-05-28 10:25:05 +08:00
|
|
|
else
|
2016-09-02 06:25:52 +08:00
|
|
|
ret = dso__load_vmlinux_path(dso, map);
|
2015-05-28 10:25:05 +08:00
|
|
|
found:
|
|
|
|
*pdso = dso;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
/*
|
|
|
|
* Some binaries like glibc have special symbols which are on the symbol
|
|
|
|
* table, but not in the debuginfo. If we can find the address of the
|
|
|
|
* symbol from map, we can translate the address back to the probe point.
|
|
|
|
*/
|
|
|
|
static int find_alternative_probe_point(struct debuginfo *dinfo,
|
|
|
|
struct perf_probe_point *pp,
|
|
|
|
struct perf_probe_point *result,
|
2017-07-06 09:48:10 +08:00
|
|
|
const char *target, struct nsinfo *nsi,
|
|
|
|
bool uprobes)
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
{
|
|
|
|
struct map *map = NULL;
|
|
|
|
struct symbol *sym;
|
|
|
|
u64 address = 0;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
/* This can work only for function-name based one */
|
|
|
|
if (!pp->function || pp->file)
|
|
|
|
return -ENOTSUP;
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
map = get_target_map(target, nsi, uprobes);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (!map)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Find the address of given function */
|
|
|
|
map__for_each_symbol_by_name(map, pp->function, sym) {
|
2015-03-22 19:40:22 +08:00
|
|
|
if (uprobes)
|
|
|
|
address = sym->start;
|
|
|
|
else
|
2016-08-06 18:29:48 +08:00
|
|
|
address = map->unmap_ip(map, sym->start) - map->reloc;
|
2015-03-06 15:31:29 +08:00
|
|
|
break;
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
}
|
|
|
|
if (!address) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-04-08 10:14:34 +08:00
|
|
|
pr_debug("Symbol %s address found : %" PRIx64 "\n",
|
|
|
|
pp->function, address);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
|
|
|
|
ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
|
|
|
|
result);
|
|
|
|
if (ret <= 0)
|
|
|
|
ret = (!ret) ? -ENOENT : ret;
|
|
|
|
else {
|
|
|
|
result->offset += pp->offset;
|
|
|
|
result->line += pp->line;
|
2015-04-13 19:41:28 +08:00
|
|
|
result->retprobe = pp->retprobe;
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2017-01-04 11:29:05 +08:00
|
|
|
map__put(map);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_alternative_probe_event(struct debuginfo *dinfo,
|
|
|
|
struct perf_probe_event *pev,
|
2015-05-08 09:03:28 +08:00
|
|
|
struct perf_probe_point *tmp)
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memcpy(tmp, &pev->point, sizeof(*tmp));
|
|
|
|
memset(&pev->point, 0, sizeof(pev->point));
|
2017-07-06 09:48:10 +08:00
|
|
|
ret = find_alternative_probe_point(dinfo, tmp, &pev->point, pev->target,
|
|
|
|
pev->nsi, pev->uprobes);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (ret < 0)
|
|
|
|
memcpy(&pev->point, tmp, sizeof(*tmp));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2014-02-06 13:32:27 +08:00
|
|
|
|
2015-03-06 15:31:22 +08:00
|
|
|
static int get_alternative_line_range(struct debuginfo *dinfo,
|
|
|
|
struct line_range *lr,
|
|
|
|
const char *target, bool user)
|
|
|
|
{
|
2015-03-11 22:36:20 +08:00
|
|
|
struct perf_probe_point pp = { .function = lr->function,
|
|
|
|
.file = lr->file,
|
|
|
|
.line = lr->start };
|
|
|
|
struct perf_probe_point result;
|
2015-03-06 15:31:22 +08:00
|
|
|
int ret, len = 0;
|
|
|
|
|
2015-03-11 22:36:20 +08:00
|
|
|
memset(&result, 0, sizeof(result));
|
|
|
|
|
2015-03-06 15:31:22 +08:00
|
|
|
if (lr->end != INT_MAX)
|
|
|
|
len = lr->end - lr->start;
|
|
|
|
ret = find_alternative_probe_point(dinfo, &pp, &result,
|
2017-07-06 09:48:10 +08:00
|
|
|
target, NULL, user);
|
2015-03-06 15:31:22 +08:00
|
|
|
if (!ret) {
|
|
|
|
lr->function = result.function;
|
|
|
|
lr->file = result.file;
|
|
|
|
lr->start = result.line;
|
|
|
|
if (lr->end != INT_MAX)
|
|
|
|
lr->end = lr->start + len;
|
|
|
|
clear_perf_probe_point(&pp);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-27 15:27:39 +08:00
|
|
|
/* Open new debuginfo of given module */
|
2017-07-06 09:48:10 +08:00
|
|
|
static struct debuginfo *open_debuginfo(const char *module, struct nsinfo *nsi,
|
|
|
|
bool silent)
|
2010-03-17 06:05:37 +08:00
|
|
|
{
|
2014-02-06 13:32:27 +08:00
|
|
|
const char *path = module;
|
2015-05-27 16:37:18 +08:00
|
|
|
char reason[STRERR_BUFSIZE];
|
|
|
|
struct debuginfo *ret = NULL;
|
|
|
|
struct dso *dso = NULL;
|
2017-07-06 09:48:10 +08:00
|
|
|
struct nscookie nsc;
|
2015-05-27 16:37:18 +08:00
|
|
|
int err;
|
2011-06-27 15:27:39 +08:00
|
|
|
|
2014-02-06 13:32:27 +08:00
|
|
|
if (!module || !strchr(module, '/')) {
|
2015-05-27 16:37:18 +08:00
|
|
|
err = kernel_get_module_dso(module, &dso);
|
|
|
|
if (err < 0) {
|
|
|
|
if (!dso || dso->load_errno == 0) {
|
tools: Introduce str_error_r()
The tools so far have been using the strerror_r() GNU variant, that
returns a string, be it the buffer passed or something else.
But that, besides being tricky in cases where we expect that the
function using strerror_r() returns the error formatted in a provided
buffer (we have to check if it returned something else and copy that
instead), breaks the build on systems not using glibc, like Alpine
Linux, where musl libc is used.
So, introduce yet another wrapper, str_error_r(), that has the GNU
interface, but uses the portable XSI variant of strerror_r(), so that
users rest asured that the provided buffer is used and it is what is
returned.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-d4t42fnf48ytlk8rjxs822tf@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-07-06 22:56:20 +08:00
|
|
|
if (!str_error_r(-err, reason, STRERR_BUFSIZE))
|
2015-05-27 16:37:18 +08:00
|
|
|
strcpy(reason, "(unknown)");
|
|
|
|
} else
|
|
|
|
dso__strerror_load(dso, reason, STRERR_BUFSIZE);
|
perf probe: Clarify error message about not finding kernel modules debuginfo
'perf probe' supports using just the kernel module name, but that will
work only when the module is loaded, or using the full pathname to the
file with the DWARF debug info, but the warning was cryptic:
Before:
# perf probe -m cls_flower -L fl_change
Failed to find the path for cls_flower: No such file or directory
Error: Failed to show lines.
#
After:
# perf probe -m cls_flower -L fl_change
Module cls_flower is not loaded, please specify its full path name.
Error: Failed to show lines.
# perf probe -m /lib/modules/5.0.0-rc7+/kernel/net/sched/cls_flower.ko -L fl_change | head -7
<fl_change@/home/acme/git/linux/net/sched/cls_flower.c:0>
0 static int fl_change(struct net *net, struct sk_buff *in_skb,
struct tcf_proto *tp, unsigned long base,
u32 handle, struct nlattr **tca,
void **arg, bool ovr, struct netlink_ext_ack *extack)
4 {
5 struct cls_fl_head *head = rtnl_dereference(tp->root);
#
The behaviour doesn't change when the module is loaded:
# modprobe cls_flower
# perf probe -m cls_flower -L fl_change | head -7
<fl_change@/home/acme/git/linux/net/sched/cls_flower.c:0>
0 static int fl_change(struct net *net, struct sk_buff *in_skb,
struct tcf_proto *tp, unsigned long base,
u32 handle, struct nlattr **tca,
void **arg, bool ovr, struct netlink_ext_ack *extack)
4 {
5 struct cls_fl_head *head = rtnl_dereference(tp->root);
#
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Marcelo Ricardo Leitner <mleitner@redhat.com>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Link: https://lkml.kernel.org/n/tip-q4njvk9mshra00jacqjbzfn5@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-02-28 22:22:45 +08:00
|
|
|
if (!silent) {
|
|
|
|
if (module)
|
|
|
|
pr_err("Module %s is not loaded, please specify its full path name.\n", module);
|
|
|
|
else
|
|
|
|
pr_err("Failed to find the path for the kernel: %s\n", reason);
|
|
|
|
}
|
2011-06-27 15:27:51 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2015-05-27 16:37:18 +08:00
|
|
|
path = dso->long_name;
|
2010-03-17 06:05:37 +08:00
|
|
|
}
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_enter(nsi, &nsc);
|
2014-08-15 09:44:32 +08: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");
|
|
|
|
}
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_exit(&nsc);
|
2014-08-15 09:44:32 +08:00
|
|
|
return ret;
|
2010-03-17 06:05:37 +08:00
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2015-06-17 22:58:54 +08:00
|
|
|
/* For caching the last debuginfo */
|
|
|
|
static struct debuginfo *debuginfo_cache;
|
|
|
|
static char *debuginfo_cache_path;
|
|
|
|
|
|
|
|
static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
|
|
|
|
{
|
2015-10-01 00:41:35 +08:00
|
|
|
const char *path = module;
|
|
|
|
|
|
|
|
/* If the module is NULL, it should be the kernel. */
|
|
|
|
if (!module)
|
|
|
|
path = "kernel";
|
|
|
|
|
|
|
|
if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path))
|
2015-06-17 22:58:54 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Copy module path */
|
|
|
|
free(debuginfo_cache_path);
|
2015-10-01 00:41:35 +08:00
|
|
|
debuginfo_cache_path = strdup(path);
|
|
|
|
if (!debuginfo_cache_path) {
|
|
|
|
debuginfo__delete(debuginfo_cache);
|
|
|
|
debuginfo_cache = NULL;
|
|
|
|
goto out;
|
2015-06-17 22:58:54 +08:00
|
|
|
}
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
debuginfo_cache = open_debuginfo(module, NULL, silent);
|
2015-06-17 22:58:54 +08:00
|
|
|
if (!debuginfo_cache)
|
|
|
|
zfree(&debuginfo_cache_path);
|
|
|
|
out:
|
|
|
|
return debuginfo_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void debuginfo_cache__exit(void)
|
|
|
|
{
|
|
|
|
debuginfo__delete(debuginfo_cache);
|
|
|
|
debuginfo_cache = NULL;
|
|
|
|
zfree(&debuginfo_cache_path);
|
|
|
|
}
|
|
|
|
|
2014-08-15 09:44:32 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
static int get_text_start_address(const char *exec, unsigned long *address,
|
|
|
|
struct nsinfo *nsi)
|
2014-01-16 17:39:49 +08:00
|
|
|
{
|
|
|
|
Elf *elf;
|
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
int fd, ret = -ENOENT;
|
2017-07-06 09:48:10 +08:00
|
|
|
struct nscookie nsc;
|
2014-01-16 17:39:49 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_enter(nsi, &nsc);
|
2014-01-16 17:39:49 +08:00
|
|
|
fd = open(exec, O_RDONLY);
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_exit(&nsc);
|
2014-01-16 17:39:49 +08:00
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
|
2016-04-26 14:47:37 +08:00
|
|
|
if (elf == NULL) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out_close;
|
|
|
|
}
|
2014-01-16 17:39:49 +08:00
|
|
|
|
|
|
|
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);
|
2016-04-26 14:47:37 +08:00
|
|
|
out_close:
|
|
|
|
close(fd);
|
|
|
|
|
2014-01-16 17:39:49 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-06 13:32:23 +08: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;
|
|
|
|
}
|
2017-07-06 09:48:10 +08:00
|
|
|
ret = get_text_start_address(tp->module, &stext, NULL);
|
2014-02-06 13:32:23 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
addr += stext;
|
2015-08-25 21:27:35 +08:00
|
|
|
} else if (tp->symbol) {
|
2015-10-01 00:41:33 +08:00
|
|
|
/* If the module is given, this returns relative address */
|
|
|
|
ret = kernel_get_symbol_address_by_name(tp->symbol, &addr,
|
|
|
|
false, !!tp->module);
|
|
|
|
if (ret != 0)
|
2014-02-06 13:32:23 +08:00
|
|
|
goto error;
|
|
|
|
addr += tp->offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
|
|
|
|
tp->module ? : "kernel");
|
|
|
|
|
2017-02-17 16:17:38 +08:00
|
|
|
dinfo = debuginfo_cache__open(tp->module, verbose <= 0);
|
2015-06-17 22:58:54 +08:00
|
|
|
if (dinfo)
|
2014-02-06 13:32:23 +08:00
|
|
|
ret = debuginfo__find_probe_point(dinfo,
|
|
|
|
(unsigned long)addr, pp);
|
2015-06-17 22:58:54 +08:00
|
|
|
else
|
2014-02-06 13:32:23 +08: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;
|
|
|
|
}
|
|
|
|
|
2017-01-11 14:00:47 +08:00
|
|
|
/* Adjust symbol name and address */
|
|
|
|
static int post_process_probe_trace_point(struct probe_trace_point *tp,
|
|
|
|
struct map *map, unsigned long offs)
|
|
|
|
{
|
|
|
|
struct symbol *sym;
|
perf probe: Fix probe definition for inlined functions
In commit 613f050d68a8 ("perf probe: Fix to probe on gcc generated
functions in modules"), the offset from symbol is, incorrectly, added
to the trace point address. This leads to incorrect probe trace points
for inlined functions and when using relative line number on symbols.
Prior this patch:
$ perf probe -m nf_nat -D in_range
p:probe/in_range nf_nat:in_range.isra.9+0
$ perf probe -m i40e -D i40e_clean_rx_irq
p:probe/i40e_clean_rx_irq i40e:i40e_napi_poll+2212
$ perf probe -m i40e -D i40e_clean_rx_irq:16
p:probe/i40e_clean_rx_irq i40e:i40e_lan_xmit_frame+626
After:
$ perf probe -m nf_nat -D in_range
p:probe/in_range nf_nat:in_range.isra.9+0
$ perf probe -m i40e -D i40e_clean_rx_irq
p:probe/i40e_clean_rx_irq i40e:i40e_napi_poll+1106
$ perf probe -m i40e -D i40e_clean_rx_irq:16
p:probe/i40e_clean_rx_irq i40e:i40e_napi_poll+2665
Committer testing:
Using 'pfunct', a tool found in the 'dwarves' package [1], one can ask what are
the functions that while not being explicitely marked as inline, were inlined
by the compiler:
# pfunct --cc_inlined /lib/modules/4.12.0-rc4+/kernel/drivers/net/ethernet/intel/e1000e/e1000e.ko | head
__ew32
e1000_regdump
e1000e_dump_ps_pages
e1000_desc_unused
e1000e_systim_to_hwtstamp
e1000e_rx_hwtstamp
e1000e_update_rdt_wa
e1000e_update_tdt_wa
e1000_put_txbuf
e1000_consume_page
Then ask 'perf probe' to produce the kprobe_tracer probe definitions for two of
them:
# perf probe -m e1000e -D e1000e_rx_hwtstamp
p:probe/e1000e_rx_hwtstamp e1000e:e1000_receive_skb+74
# perf probe -m e1000e -D e1000_consume_page
p:probe/e1000_consume_page e1000e:e1000_clean_jumbo_rx_irq+876
p:probe/e1000_consume_page_1 e1000e:e1000_clean_jumbo_rx_irq+1506
p:probe/e1000_consume_page_2 e1000e:e1000_clean_rx_irq_ps+1074
Now lets concentrate on the 'e1000_consume_page' one, that was inlined twice in
e1000_clean_jumbo_rx_irq(), lets see what readelf says about the DWARF tags for
that function:
$ readelf -wi /lib/modules/4.12.0-rc4+/kernel/drivers/net/ethernet/intel/e1000e/e1000e.ko
<SNIP>
<1><13e27b>: Abbrev Number: 121 (DW_TAG_subprogram)
<13e27c> DW_AT_name : (indirect string, offset: 0xa8945): e1000_clean_jumbo_rx_irq
<13e287> DW_AT_low_pc : 0x17a30
<3><13e6ef>: Abbrev Number: 119 (DW_TAG_inlined_subroutine)
<13e6f0> DW_AT_abstract_origin: <0x13ed2c>
<13e6f4> DW_AT_low_pc : 0x17be6
<SNIP>
<1><13ed2c>: Abbrev Number: 142 (DW_TAG_subprogram)
<13ed2e> DW_AT_name : (indirect string, offset: 0xa54c3): e1000_consume_page
So, the first time in e1000_clean_jumbo_rx_irq() where e1000_consume_page() is
inlined is at PC 0x17be6, which subtracted from e1000_clean_jumbo_rx_irq()'s
address, gives us the offset we should use in the probe definition:
0x17be6 - 0x17a30 = 438
but above we have 876, which is twice as much.
Lets see the second inline expansion of e1000_consume_page() in
e1000_clean_jumbo_rx_irq():
<3><13e86e>: Abbrev Number: 119 (DW_TAG_inlined_subroutine)
<13e86f> DW_AT_abstract_origin: <0x13ed2c>
<13e873> DW_AT_low_pc : 0x17d21
0x17d21 - 0x17a30 = 753
So we where adding it at twice the offset from the containing function as we
should.
And then after this patch:
# perf probe -m e1000e -D e1000e_rx_hwtstamp
p:probe/e1000e_rx_hwtstamp e1000e:e1000_receive_skb+37
# perf probe -m e1000e -D e1000_consume_page
p:probe/e1000_consume_page e1000e:e1000_clean_jumbo_rx_irq+438
p:probe/e1000_consume_page_1 e1000e:e1000_clean_jumbo_rx_irq+753
p:probe/e1000_consume_page_2 e1000e:e1000_clean_jumbo_rx_irq+1353
#
Which matches the two first expansions and shows that because we were
doubling the offset it would spill over the next function:
readelf -sw /lib/modules/4.12.0-rc4+/kernel/drivers/net/ethernet/intel/e1000e/e1000e.ko
673: 0000000000017a30 1626 FUNC LOCAL DEFAULT 2 e1000_clean_jumbo_rx_irq
674: 0000000000018090 2013 FUNC LOCAL DEFAULT 2 e1000_clean_rx_irq_ps
This is the 3rd inline expansion of e1000_consume_page() in
e1000_clean_jumbo_rx_irq():
<3><13ec77>: Abbrev Number: 119 (DW_TAG_inlined_subroutine)
<13ec78> DW_AT_abstract_origin: <0x13ed2c>
<13ec7c> DW_AT_low_pc : 0x17f79
0x17f79 - 0x17a30 = 1353
So:
0x17a30 + 2 * 1353 = 0x184c2
And:
0x184c2 - 0x18090 = 1074
Which explains the bogus third expansion for e1000_consume_page() to end up at:
p:probe/e1000_consume_page_2 e1000e:e1000_clean_rx_irq_ps+1074
All fixed now :-)
[1] https://git.kernel.org/pub/scm/devel/pahole/pahole.git/
Signed-off-by: Björn Töpel <bjorn.topel@intel.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Acked-by: Magnus Karlsson <magnus.karlsson@intel.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: stable@vger.kernel.org
Fixes: 613f050d68a8 ("perf probe: Fix to probe on gcc generated functions in modules")
Link: http://lkml.kernel.org/r/20170621164134.5701-1-bjorn.topel@gmail.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2017-06-22 00:41:34 +08:00
|
|
|
u64 addr = tp->address - offs;
|
2017-01-11 14:00:47 +08:00
|
|
|
|
|
|
|
sym = map__find_symbol(map, addr);
|
|
|
|
if (!sym)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (strcmp(sym->name, tp->symbol)) {
|
|
|
|
/* If we have no realname, use symbol for it */
|
|
|
|
if (!tp->realname)
|
|
|
|
tp->realname = tp->symbol;
|
|
|
|
else
|
|
|
|
free(tp->symbol);
|
|
|
|
tp->symbol = strdup(sym->name);
|
|
|
|
if (!tp->symbol)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
tp->offset = addr - sym->start;
|
|
|
|
tp->address -= offs;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-04 11:30:19 +08:00
|
|
|
/*
|
|
|
|
* Rename DWARF symbols to ELF symbols -- gcc sometimes optimizes functions
|
|
|
|
* and generate new symbols with suffixes such as .constprop.N or .isra.N
|
|
|
|
* etc. Since those symbols are not recorded in DWARF, we have to find
|
|
|
|
* correct generated symbols from offline ELF binary.
|
|
|
|
* For online kernel or uprobes we don't need this because those are
|
|
|
|
* rebased on _text, or already a section relative address.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
post_process_offline_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs, const char *pathname)
|
|
|
|
{
|
|
|
|
struct map *map;
|
|
|
|
unsigned long stext = 0;
|
2017-01-11 14:00:47 +08:00
|
|
|
int i, ret = 0;
|
2017-01-04 11:30:19 +08:00
|
|
|
|
|
|
|
/* Prepare a map for offline binary */
|
|
|
|
map = dso__new_map(pathname);
|
2017-07-06 09:48:10 +08:00
|
|
|
if (!map || get_text_start_address(pathname, &stext, NULL) < 0) {
|
2017-01-04 11:30:19 +08:00
|
|
|
pr_warning("Failed to get ELF symbols for %s\n", pathname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs; i++) {
|
2017-01-11 14:00:47 +08:00
|
|
|
ret = post_process_probe_trace_point(&tevs[i].point,
|
|
|
|
map, stext);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2017-01-04 11:30:19 +08:00
|
|
|
}
|
|
|
|
map__put(map);
|
|
|
|
|
2017-01-11 14:00:47 +08:00
|
|
|
return ret;
|
2017-01-04 11:30:19 +08: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-26 13:41:53 +08:00
|
|
|
static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
|
2017-07-06 09:48:10 +08:00
|
|
|
int ntevs, const char *exec,
|
|
|
|
struct nsinfo *nsi)
|
perf probe: Support basic dwarf-based operations on uprobe events
Support basic dwarf(debuginfo) based operations for uprobe events. With
this change, perf probe can analyze debuginfo of user application binary
to set up new uprobe event.
This allows perf-probe --add(with local variables, line numbers) and
--line works with -x option. (Actually, --vars has already accepted -x
option)
For example, the following command shows the probe-able lines of a given
user space function. Something that so far was only available in the
'perf probe' tool for kernel space functions:
# ./perf probe -x perf --line map__load
<map__load@/home/fedora/ksrc/linux-2.6/tools/perf/util/map.c:0>
0 int map__load(struct map *map, symbol_filter_t filter)
1 {
2 const char *name = map->dso->long_name;
int nr;
5 if (dso__loaded(map->dso, map->type))
6 return 0;
8 nr = dso__load(map->dso, map, filter);
9 if (nr < 0) {
10 if (map->dso->has_build_id) {
And this shows the available variables at the given line of the
function.
# ./perf probe -x perf --vars map__load:8
Available variables at map__load:8
@<map__load+96>
char* name
struct map* map
symbol_filter_t filter
@<map__find_symbol+112>
char* name
symbol_filter_t filter
@<map__find_symbol_by_name+136>
char* name
symbol_filter_t filter
@<map_groups__find_symbol_by_name+176>
char* name
struct map* map
symbol_filter_t filter
And lastly, we can now define probe(s) with all available
variables on the given line:
# ./perf probe -x perf --add 'map__load:8 $vars'
Added new events:
probe_perf:map__load (on map__load:8 with $vars)
probe_perf:map__load_1 (on map__load:8 with $vars)
probe_perf:map__load_2 (on map__load:8 with $vars)
probe_perf:map__load_3 (on map__load:8 with $vars)
You can now use it in all perf tools, such as:
perf record -e probe_perf:map__load_3 -aR sleep 1
Changes from previous version:
- Add examples in the patch description.
- Use .text section start address and dwarf symbol address
for calculating the offset of given symbol, instead of
searching the symbol in symtab again.
With this change, we can safely handle multiple local
function instances (e.g. scnprintf in perf).
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: David A. Long <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: systemtap@sourceware.org
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20131226054152.22364.47021.stgit@kbuild-fedora.novalocal
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-12-26 13:41:53 +08:00
|
|
|
{
|
|
|
|
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-06 13:32:25 +08: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-26 13:41:53 +08:00
|
|
|
|
|
|
|
if (!exec)
|
|
|
|
return 0;
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
ret = get_text_start_address(exec, &stext, nsi);
|
perf probe: Support basic dwarf-based operations on uprobe events
Support basic dwarf(debuginfo) based operations for uprobe events. With
this change, perf probe can analyze debuginfo of user application binary
to set up new uprobe event.
This allows perf-probe --add(with local variables, line numbers) and
--line works with -x option. (Actually, --vars has already accepted -x
option)
For example, the following command shows the probe-able lines of a given
user space function. Something that so far was only available in the
'perf probe' tool for kernel space functions:
# ./perf probe -x perf --line map__load
<map__load@/home/fedora/ksrc/linux-2.6/tools/perf/util/map.c:0>
0 int map__load(struct map *map, symbol_filter_t filter)
1 {
2 const char *name = map->dso->long_name;
int nr;
5 if (dso__loaded(map->dso, map->type))
6 return 0;
8 nr = dso__load(map->dso, map, filter);
9 if (nr < 0) {
10 if (map->dso->has_build_id) {
And this shows the available variables at the given line of the
function.
# ./perf probe -x perf --vars map__load:8
Available variables at map__load:8
@<map__load+96>
char* name
struct map* map
symbol_filter_t filter
@<map__find_symbol+112>
char* name
symbol_filter_t filter
@<map__find_symbol_by_name+136>
char* name
symbol_filter_t filter
@<map_groups__find_symbol_by_name+176>
char* name
struct map* map
symbol_filter_t filter
And lastly, we can now define probe(s) with all available
variables on the given line:
# ./perf probe -x perf --add 'map__load:8 $vars'
Added new events:
probe_perf:map__load (on map__load:8 with $vars)
probe_perf:map__load_1 (on map__load:8 with $vars)
probe_perf:map__load_2 (on map__load:8 with $vars)
probe_perf:map__load_3 (on map__load:8 with $vars)
You can now use it in all perf tools, such as:
perf record -e probe_perf:map__load_3 -aR sleep 1
Changes from previous version:
- Add examples in the patch description.
- Use .text section start address and dwarf symbol address
for calculating the offset of given symbol, instead of
searching the symbol in symtab again.
With this change, we can safely handle multiple local
function instances (e.g. scnprintf in perf).
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: David A. Long <dave.long@linaro.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: systemtap@sourceware.org
Cc: yrl.pp-manager.tt@hitachi.com
Link: http://lkml.kernel.org/r/20131226054152.22364.47021.stgit@kbuild-fedora.novalocal
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2013-12-26 13:41:53 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs && ret >= 0; i++) {
|
2018-12-03 18:22:00 +08:00
|
|
|
/* point.address is the address 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-06 13:32:25 +08: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-26 13:41:53 +08: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-06 13:32:25 +08: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-26 13:41:53 +08:00
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tevs[i].uprobes = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-11 14:01:57 +08:00
|
|
|
static int
|
|
|
|
post_process_module_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs, const char *module,
|
|
|
|
struct debuginfo *dinfo)
|
2011-06-27 15:27:45 +08:00
|
|
|
{
|
2017-01-11 14:01:57 +08:00
|
|
|
Dwarf_Addr text_offs = 0;
|
2011-06-27 15:27:51 +08:00
|
|
|
int i, ret = 0;
|
2016-04-26 22:25:41 +08:00
|
|
|
char *mod_name = NULL;
|
2017-01-11 14:01:57 +08:00
|
|
|
struct map *map;
|
2011-06-27 15:27:51 +08:00
|
|
|
|
|
|
|
if (!module)
|
|
|
|
return 0;
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
map = get_target_map(module, NULL, false);
|
2017-01-11 14:01:57 +08:00
|
|
|
if (!map || debuginfo__get_text_offset(dinfo, &text_offs, true) < 0) {
|
|
|
|
pr_warning("Failed to get ELF symbols for %s\n", module);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2011-06-27 15:27:51 +08:00
|
|
|
|
2017-01-11 14:01:57 +08:00
|
|
|
mod_name = find_module_name(module);
|
2011-06-27 15:27:45 +08:00
|
|
|
for (i = 0; i < ntevs; i++) {
|
2017-01-11 14:01:57 +08:00
|
|
|
ret = post_process_probe_trace_point(&tevs[i].point,
|
|
|
|
map, (unsigned long)text_offs);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2016-04-26 22:25:41 +08:00
|
|
|
tevs[i].point.module =
|
|
|
|
strdup(mod_name ? mod_name : module);
|
2011-06-27 15:27:51 +08:00
|
|
|
if (!tevs[i].point.module) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-27 15:27:45 +08:00
|
|
|
}
|
2011-06-27 15:27:51 +08:00
|
|
|
|
2016-04-26 22:25:41 +08:00
|
|
|
free(mod_name);
|
2017-01-11 14:01:57 +08:00
|
|
|
map__put(map);
|
|
|
|
|
2011-06-27 15:27:51 +08:00
|
|
|
return ret;
|
2011-06-27 15:27:45 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 14:23:24 +08:00
|
|
|
static int
|
|
|
|
post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
|
|
|
|
int ntevs)
|
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-06 13:32:16 +08:00
|
|
|
{
|
|
|
|
struct ref_reloc_sym *reloc_sym;
|
|
|
|
char *tmp;
|
2015-05-06 20:46:49 +08:00
|
|
|
int i, skipped = 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-06 13:32:16 +08:00
|
|
|
|
2016-08-26 00:24:42 +08:00
|
|
|
/* Skip post process if the target is an offline kernel */
|
|
|
|
if (symbol_conf.ignore_vmlinux_buildid)
|
2017-01-04 11:30:19 +08:00
|
|
|
return post_process_offline_probe_trace_events(tevs, ntevs,
|
|
|
|
symbol_conf.vmlinux_name);
|
2016-08-26 00:24:42 +08:00
|
|
|
|
2014-02-06 13:32:20 +08: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-06 13:32:16 +08:00
|
|
|
if (!reloc_sym) {
|
|
|
|
pr_warning("Relocated base symbol is not found!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ntevs; i++) {
|
2017-03-08 16:26:09 +08:00
|
|
|
if (!tevs[i].point.address)
|
|
|
|
continue;
|
|
|
|
if (tevs[i].point.retprobe && !kretprobe_offset_is_supported())
|
2015-06-16 19:50:55 +08:00
|
|
|
continue;
|
|
|
|
/* If we found a wrong one, mark it by NULL symbol */
|
|
|
|
if (kprobe_warn_out_range(tevs[i].point.symbol,
|
|
|
|
tevs[i].point.address)) {
|
|
|
|
tmp = NULL;
|
|
|
|
skipped++;
|
|
|
|
} else {
|
|
|
|
tmp = strdup(reloc_sym->name);
|
|
|
|
if (!tmp)
|
|
|
|
return -ENOMEM;
|
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-06 13:32:16 +08:00
|
|
|
}
|
2015-06-16 19:50:55 +08:00
|
|
|
/* If we have no realname, use symbol for it */
|
|
|
|
if (!tevs[i].point.realname)
|
|
|
|
tevs[i].point.realname = tevs[i].point.symbol;
|
|
|
|
else
|
|
|
|
free(tevs[i].point.symbol);
|
|
|
|
tevs[i].point.symbol = tmp;
|
|
|
|
tevs[i].point.offset = tevs[i].point.address -
|
|
|
|
reloc_sym->unrelocated_addr;
|
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-06 13:32:16 +08:00
|
|
|
}
|
2015-05-06 20:46:49 +08:00
|
|
|
return skipped;
|
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-06 13:32:16 +08:00
|
|
|
}
|
|
|
|
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
void __weak
|
|
|
|
arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
|
|
|
|
int ntevs __maybe_unused)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-08-09 14:23:24 +08:00
|
|
|
/* Post processing the probe events */
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
static int post_process_probe_trace_events(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event *tevs,
|
2016-08-09 14:23:24 +08:00
|
|
|
int ntevs, const char *module,
|
2017-01-11 14:01:57 +08:00
|
|
|
bool uprobe, struct debuginfo *dinfo)
|
2016-08-09 14:23:24 +08:00
|
|
|
{
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
int ret;
|
2016-08-09 14:23:24 +08:00
|
|
|
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
if (uprobe)
|
2017-07-06 09:48:10 +08:00
|
|
|
ret = add_exec_to_probe_trace_events(tevs, ntevs, module,
|
|
|
|
pev->nsi);
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
else if (module)
|
2016-08-09 14:23:24 +08:00
|
|
|
/* Currently ref_reloc_sym based probe is not for drivers */
|
2017-01-11 14:01:57 +08:00
|
|
|
ret = post_process_module_probe_trace_events(tevs, ntevs,
|
|
|
|
module, dinfo);
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
else
|
|
|
|
ret = post_process_kernel_probe_trace_events(tevs, ntevs);
|
2016-08-09 14:23:24 +08:00
|
|
|
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
if (ret >= 0)
|
|
|
|
arch__post_process_probe_trace_events(pev, ntevs);
|
|
|
|
|
|
|
|
return ret;
|
2016-08-09 14:23:24 +08:00
|
|
|
}
|
|
|
|
|
2010-03-23 00:10:26 +08:00
|
|
|
/* Try to find perf_probe_event with debuginfo */
|
2010-07-29 22:13:51 +08:00
|
|
|
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct probe_trace_event **tevs)
|
2010-03-23 00:10:26 +08:00
|
|
|
{
|
|
|
|
bool need_dwarf = perf_probe_event_need_dwarf(pev);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
struct perf_probe_point tmp;
|
2012-04-16 20:09:09 +08:00
|
|
|
struct debuginfo *dinfo;
|
2011-06-27 15:27:45 +08:00
|
|
|
int ntevs, ret = 0;
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
dinfo = open_debuginfo(pev->target, pev->nsi, !need_dwarf);
|
2011-06-27 15:27:39 +08:00
|
|
|
if (!dinfo) {
|
2014-08-15 09:44:32 +08:00
|
|
|
if (need_dwarf)
|
2011-06-27 15:27:39 +08:00
|
|
|
return -ENOENT;
|
|
|
|
pr_debug("Could not open debuginfo. Try to use symbols.\n");
|
2010-03-23 00:10:26 +08: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-06 13:32:16 +08:00
|
|
|
pr_debug("Try to find probe point from debuginfo.\n");
|
2011-06-27 15:27:39 +08:00
|
|
|
/* Searching trace events corresponding to a probe event */
|
2015-05-08 09:03:31 +08:00
|
|
|
ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
|
2011-06-27 15:27:39 +08:00
|
|
|
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (ntevs == 0) { /* Not found, retry with an alternative */
|
2015-05-08 09:03:28 +08:00
|
|
|
ret = get_alternative_probe_event(dinfo, pev, &tmp);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (!ret) {
|
2015-05-08 09:03:31 +08:00
|
|
|
ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
/*
|
|
|
|
* Write back to the original probe_event for
|
|
|
|
* setting appropriate (user given) event name
|
|
|
|
*/
|
|
|
|
clear_perf_probe_point(&pev->point);
|
|
|
|
memcpy(&pev->point, &tmp, sizeof(tmp));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-13 01:17:42 +08: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-06 13:32:16 +08:00
|
|
|
pr_debug("Found %d probe_trace_events.\n", ntevs);
|
perf probe ppc64le: Fix probe location when using DWARF
Powerpc has Global Entry Point and Local Entry Point for functions. LEP
catches call from both the GEP and the LEP. Symbol table of ELF contains
GEP and Offset from which we can calculate LEP, but debuginfo does not
have LEP info.
Currently, perf prioritize symbol table over dwarf to probe on LEP for
ppc64le. But when user tries to probe with function parameter, we fall
back to using dwarf(i.e. GEP) and when function called via LEP, probe
will never hit.
For example:
$ objdump -d vmlinux
...
do_sys_open():
c0000000002eb4a0: e8 00 4c 3c addis r2,r12,232
c0000000002eb4a4: 60 00 42 38 addi r2,r2,96
c0000000002eb4a8: a6 02 08 7c mflr r0
c0000000002eb4ac: d0 ff 41 fb std r26,-48(r1)
$ sudo ./perf probe do_sys_open
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060896 filename_string=+0(%gpr4):string
For second case, perf probed on GEP. So when function will be called via
LEP, probe won't hit.
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.195 MB perf.data ]
To resolve this issue, let's not prioritize symbol table, let perf
decide what it wants to use. Perf is already converting GEP to LEP when
it uses symbol table. When perf uses debuginfo, let it find LEP offset
form symbol table. This way we fall back to probe on LEP for all cases.
After patch:
$ sudo ./perf probe 'do_sys_open filename:string'
$ sudo cat /sys/kernel/debug/tracing/kprobe_events
p:probe/do_sys_open _text+3060904 filename_string=+0(%gpr4):string
$ sudo ./perf record -a -e probe:do_sys_open ls
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.197 MB perf.data (11 samples) ]
Signed-off-by: Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com>
Acked-by: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1470723805-5081-2-git-send-email-ravi.bangoria@linux.vnet.ibm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:23:25 +08:00
|
|
|
ret = post_process_probe_trace_events(pev, *tevs, ntevs,
|
2017-01-11 14:01:57 +08:00
|
|
|
pev->target, pev->uprobes, dinfo);
|
2015-05-06 20:46:49 +08:00
|
|
|
if (ret < 0 || ret == ntevs) {
|
2017-01-11 14:01:57 +08:00
|
|
|
pr_debug("Post processing failed or all events are skipped. (%d)\n", ret);
|
2014-01-16 17:39:44 +08:00
|
|
|
clear_probe_trace_events(*tevs, ntevs);
|
|
|
|
zfree(tevs);
|
2017-01-11 14:01:57 +08:00
|
|
|
ntevs = 0;
|
2014-01-16 17:39:44 +08:00
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2017-01-11 14:01:57 +08:00
|
|
|
debuginfo__delete(dinfo);
|
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ntevs == 0) { /* No error but failed to find probe point. */
|
2015-03-06 15:31:25 +08:00
|
|
|
pr_warning("Probe point '%s' not found.\n",
|
2010-04-13 01:17:42 +08:00
|
|
|
synthesize_perf_probe_point(&pev->point));
|
2015-03-06 15:31:25 +08:00
|
|
|
return -ENOENT;
|
2017-01-11 14:01:57 +08:00
|
|
|
} else if (ntevs < 0) {
|
|
|
|
/* Error path : ntevs < 0 */
|
|
|
|
pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
|
2015-08-21 18:09:02 +08:00
|
|
|
if (ntevs == -EBADF)
|
|
|
|
pr_warning("Warning: No dwarf info found in the vmlinux - "
|
|
|
|
"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
|
2010-04-22 03:56:24 +08:00
|
|
|
if (!need_dwarf) {
|
2010-12-17 21:12:11 +08:00
|
|
|
pr_debug("Trying to use symbols.\n");
|
2010-04-22 03:56:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
2010-04-22 03:56:24 +08:00
|
|
|
return ntevs;
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define LINEBUF_SIZE 256
|
|
|
|
#define NR_ADDITIONAL_LINES 2
|
|
|
|
|
2010-12-20 22:18:04 +08:00
|
|
|
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
|
2010-03-23 00:10:26 +08:00
|
|
|
{
|
2014-08-14 10:22:34 +08:00
|
|
|
char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
|
2010-12-20 22:18:01 +08:00
|
|
|
const char *color = show_num ? "" : PERF_COLOR_BLUE;
|
|
|
|
const char *prefix = NULL;
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2010-12-20 22:18:01 +08:00
|
|
|
do {
|
2010-03-23 00:10:26 +08:00
|
|
|
if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
|
|
|
|
goto error;
|
2010-12-20 22:18:01 +08:00
|
|
|
if (skip)
|
|
|
|
continue;
|
|
|
|
if (!prefix) {
|
|
|
|
prefix = show_num ? "%7d " : " ";
|
|
|
|
color_fprintf(stdout, color, prefix, l);
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
2010-12-20 22:18:01 +08:00
|
|
|
color_fprintf(stdout, color, "%s", buf);
|
|
|
|
|
|
|
|
} while (strchr(buf, '\n') == NULL);
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2010-12-20 22:18:04 +08:00
|
|
|
return 1;
|
2010-03-23 00:10:26 +08:00
|
|
|
error:
|
2010-12-20 22:18:04 +08:00
|
|
|
if (ferror(fp)) {
|
2014-08-14 10:22:34 +08:00
|
|
|
pr_warning("File read error: %s\n",
|
tools: Introduce str_error_r()
The tools so far have been using the strerror_r() GNU variant, that
returns a string, be it the buffer passed or something else.
But that, besides being tricky in cases where we expect that the
function using strerror_r() returns the error formatted in a provided
buffer (we have to check if it returned something else and copy that
instead), breaks the build on systems not using glibc, like Alpine
Linux, where musl libc is used.
So, introduce yet another wrapper, str_error_r(), that has the GNU
interface, but uses the portable XSI variant of strerror_r(), so that
users rest asured that the provided buffer is used and it is what is
returned.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-d4t42fnf48ytlk8rjxs822tf@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-07-06 22:56:20 +08:00
|
|
|
str_error_r(errno, sbuf, sizeof(sbuf)));
|
2010-12-20 22:18:04 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2010-12-20 22:18:04 +08: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-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
2010-12-20 22:18:04 +08: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-23 00:10:26 +08:00
|
|
|
/*
|
|
|
|
* Show line-range always requires debuginfo to find source file and
|
|
|
|
* line number.
|
|
|
|
*/
|
2015-03-06 15:31:22 +08:00
|
|
|
static int __show_line_range(struct line_range *lr, const char *module,
|
|
|
|
bool user)
|
2010-03-23 00:10:26 +08:00
|
|
|
{
|
2010-04-15 06:39:42 +08:00
|
|
|
int l = 1;
|
2014-02-06 13:32:09 +08:00
|
|
|
struct int_node *ln;
|
2011-06-27 15:27:39 +08:00
|
|
|
struct debuginfo *dinfo;
|
2010-03-23 00:10:26 +08:00
|
|
|
FILE *fp;
|
2011-06-27 15:27:39 +08:00
|
|
|
int ret;
|
2010-07-09 17:28:59 +08:00
|
|
|
char *tmp;
|
2014-08-14 10:22:34 +08:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2010-03-23 00:10:26 +08:00
|
|
|
|
|
|
|
/* Search a line range */
|
2017-07-06 09:48:10 +08:00
|
|
|
dinfo = open_debuginfo(module, NULL, false);
|
2014-08-15 09:44:32 +08:00
|
|
|
if (!dinfo)
|
2011-06-27 15:27:39 +08:00
|
|
|
return -ENOENT;
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2011-06-27 15:27:39 +08:00
|
|
|
ret = debuginfo__find_line_range(dinfo, lr);
|
2015-03-06 15:31:22 +08:00
|
|
|
if (!ret) { /* Not found, retry with an alternative */
|
|
|
|
ret = get_alternative_line_range(dinfo, lr, module, user);
|
|
|
|
if (!ret)
|
|
|
|
ret = debuginfo__find_line_range(dinfo, lr);
|
|
|
|
}
|
2011-06-27 15:27:39 +08:00
|
|
|
debuginfo__delete(dinfo);
|
2014-06-06 15:14:06 +08:00
|
|
|
if (ret == 0 || ret == -ENOENT) {
|
2010-04-13 01:17:42 +08:00
|
|
|
pr_warning("Specified source line is not found.\n");
|
|
|
|
return -ENOENT;
|
|
|
|
} else if (ret < 0) {
|
2014-06-06 15:14:06 +08:00
|
|
|
pr_warning("Debuginfo analysis failed.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2010-07-09 17:28:59 +08:00
|
|
|
/* Convert source file path */
|
|
|
|
tmp = lr->path;
|
2010-07-09 17:29:11 +08:00
|
|
|
ret = get_real_path(tmp, lr->comp_dir, &lr->path);
|
2015-03-04 18:01:42 +08:00
|
|
|
|
|
|
|
/* Free old path when new path is assigned */
|
|
|
|
if (tmp != lr->path)
|
|
|
|
free(tmp);
|
|
|
|
|
2010-07-09 17:28:59 +08:00
|
|
|
if (ret < 0) {
|
2014-06-06 15:14:06 +08:00
|
|
|
pr_warning("Failed to find source file path.\n");
|
2010-07-09 17:28:59 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-03-23 00:10:26 +08:00
|
|
|
setup_pager();
|
|
|
|
|
|
|
|
if (lr->function)
|
2011-02-10 17:08:16 +08:00
|
|
|
fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
|
2010-03-23 00:10:26 +08:00
|
|
|
lr->start - lr->offset);
|
|
|
|
else
|
2010-12-20 22:18:00 +08:00
|
|
|
fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
|
2010-03-23 00:10:26 +08:00
|
|
|
|
|
|
|
fp = fopen(lr->path, "r");
|
2010-04-13 01:17:42 +08:00
|
|
|
if (fp == NULL) {
|
|
|
|
pr_warning("Failed to open %s: %s\n", lr->path,
|
tools: Introduce str_error_r()
The tools so far have been using the strerror_r() GNU variant, that
returns a string, be it the buffer passed or something else.
But that, besides being tricky in cases where we expect that the
function using strerror_r() returns the error formatted in a provided
buffer (we have to check if it returned something else and copy that
instead), breaks the build on systems not using glibc, like Alpine
Linux, where musl libc is used.
So, introduce yet another wrapper, str_error_r(), that has the GNU
interface, but uses the portable XSI variant of strerror_r(), so that
users rest asured that the provided buffer is used and it is what is
returned.
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-d4t42fnf48ytlk8rjxs822tf@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-07-06 22:56:20 +08:00
|
|
|
str_error_r(errno, sbuf, sizeof(sbuf)));
|
2010-04-13 01:17:42 +08:00
|
|
|
return -errno;
|
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
/* Skip to starting line number */
|
2010-12-20 22:18:02 +08:00
|
|
|
while (l < lr->start) {
|
2010-12-20 22:18:04 +08:00
|
|
|
ret = skip_one_line(fp, l++);
|
2010-12-20 22:18:02 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
}
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2016-06-23 22:39:19 +08:00
|
|
|
intlist__for_each_entry(ln, lr->line_list) {
|
2014-02-06 13:32:09 +08:00
|
|
|
for (; ln->i > l; l++) {
|
2010-12-20 22:18:04 +08:00
|
|
|
ret = show_one_line(fp, l - lr->offset);
|
2010-12-20 22:18:02 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
|
|
|
}
|
2010-12-20 22:18:04 +08:00
|
|
|
ret = show_one_line_with_num(fp, l++ - lr->offset);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lr->end == INT_MAX)
|
|
|
|
lr->end = l + NR_ADDITIONAL_LINES;
|
2010-12-20 22:18:04 +08:00
|
|
|
while (l <= lr->end) {
|
|
|
|
ret = show_one_line_or_eof(fp, l++ - lr->offset);
|
|
|
|
if (ret <= 0)
|
2010-12-20 22:18:02 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
end:
|
2010-03-23 00:10:26 +08:00
|
|
|
fclose(fp);
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
int show_line_range(struct line_range *lr, const char *module,
|
|
|
|
struct nsinfo *nsi, bool user)
|
2014-02-06 13:32:04 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2017-07-06 09:48:10 +08:00
|
|
|
struct nscookie nsc;
|
2014-02-06 13:32:04 +08:00
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
ret = init_probe_symbol_maps(user);
|
2014-02-06 13:32:04 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_enter(nsi, &nsc);
|
2015-03-06 15:31:22 +08:00
|
|
|
ret = __show_line_range(lr, module, user);
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_exit(&nsc);
|
2015-09-10 10:27:05 +08:00
|
|
|
exit_probe_symbol_maps();
|
2014-02-06 13:32:04 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-27 15:27:39 +08:00
|
|
|
static int show_available_vars_at(struct debuginfo *dinfo,
|
|
|
|
struct perf_probe_event *pev,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct strfilter *_filter)
|
2010-10-21 18:13:23 +08:00
|
|
|
{
|
|
|
|
char *buf;
|
2011-01-20 22:15:39 +08:00
|
|
|
int ret, i, nvars;
|
2010-10-21 18:13:23 +08:00
|
|
|
struct str_node *node;
|
|
|
|
struct variable_list *vls = NULL, *vl;
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
struct perf_probe_point tmp;
|
2011-01-20 22:15:39 +08:00
|
|
|
const char *var;
|
2010-10-21 18:13:23 +08:00
|
|
|
|
|
|
|
buf = synthesize_perf_probe_point(&pev->point);
|
|
|
|
if (!buf)
|
|
|
|
return -EINVAL;
|
|
|
|
pr_debug("Searching variables at %s\n", buf);
|
|
|
|
|
2015-05-08 09:03:31 +08:00
|
|
|
ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (!ret) { /* Not found, retry with an alternative */
|
2015-05-08 09:03:28 +08:00
|
|
|
ret = get_alternative_probe_event(dinfo, pev, &tmp);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
if (!ret) {
|
|
|
|
ret = debuginfo__find_available_vars_at(dinfo, pev,
|
2015-05-08 09:03:31 +08:00
|
|
|
&vls);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
/* Release the old probe_point */
|
|
|
|
clear_perf_probe_point(&tmp);
|
|
|
|
}
|
|
|
|
}
|
2011-01-20 22:15:39 +08:00
|
|
|
if (ret <= 0) {
|
2014-06-06 15:13:59 +08: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 22:15:39 +08:00
|
|
|
goto end;
|
|
|
|
}
|
2014-06-06 15:13:59 +08:00
|
|
|
|
2011-01-20 22:15:39 +08: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-28 03:55:14 +08:00
|
|
|
zfree(&vl->point.symbol);
|
2011-01-20 22:15:39 +08:00
|
|
|
nvars = 0;
|
|
|
|
if (vl->vars) {
|
2016-06-23 22:31:20 +08:00
|
|
|
strlist__for_each_entry(node, vl->vars) {
|
2011-01-20 22:15:39 +08:00
|
|
|
var = strchr(node->s, '\t') + 1;
|
|
|
|
if (strfilter__compare(_filter, var)) {
|
2010-10-21 18:13:23 +08:00
|
|
|
fprintf(stdout, "\t\t%s\n", node->s);
|
2011-01-20 22:15:39 +08:00
|
|
|
nvars++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strlist__delete(vl->vars);
|
2010-10-21 18:13:23 +08:00
|
|
|
}
|
2011-01-20 22:15:39 +08:00
|
|
|
if (nvars == 0)
|
|
|
|
fprintf(stdout, "\t\t(No matched variables)\n");
|
|
|
|
}
|
|
|
|
free(vls);
|
|
|
|
end:
|
2010-10-21 18:13:23 +08:00
|
|
|
free(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Show available variables on given probe point */
|
|
|
|
int show_available_vars(struct perf_probe_event *pevs, int npevs,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct strfilter *_filter)
|
2010-10-21 18:13:23 +08:00
|
|
|
{
|
2011-06-27 15:27:39 +08:00
|
|
|
int i, ret = 0;
|
|
|
|
struct debuginfo *dinfo;
|
2010-10-21 18:13:23 +08:00
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
ret = init_probe_symbol_maps(pevs->uprobes);
|
2010-10-21 18:13:23 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
dinfo = open_debuginfo(pevs->target, pevs->nsi, false);
|
2011-06-27 15:27:39 +08:00
|
|
|
if (!dinfo) {
|
2014-02-06 13:32:04 +08:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
2011-06-27 15:27:39 +08:00
|
|
|
}
|
|
|
|
|
2010-10-21 18:13:23 +08:00
|
|
|
setup_pager();
|
|
|
|
|
2011-06-27 15:27:39 +08:00
|
|
|
for (i = 0; i < npevs && ret >= 0; i++)
|
2015-05-08 09:03:31 +08:00
|
|
|
ret = show_available_vars_at(dinfo, &pevs[i], _filter);
|
2011-06-27 15:27:39 +08:00
|
|
|
|
|
|
|
debuginfo__delete(dinfo);
|
2014-02-06 13:32:04 +08:00
|
|
|
out:
|
2015-09-10 10:27:05 +08:00
|
|
|
exit_probe_symbol_maps();
|
2010-10-21 18:13:23 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-09-30 18:07:11 +08:00
|
|
|
#else /* !HAVE_DWARF_SUPPORT */
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2015-06-17 22:58:54 +08:00
|
|
|
static void debuginfo_cache__exit(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-02-06 13:32:23 +08: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-23 00:10:26 +08:00
|
|
|
{
|
2014-02-06 13:32:23 +08:00
|
|
|
return -ENOSYS;
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct probe_trace_event **tevs __maybe_unused)
|
2010-03-23 00:10:26 +08:00
|
|
|
{
|
2010-04-13 01:17:42 +08:00
|
|
|
if (perf_probe_event_need_dwarf(pev)) {
|
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2010-03-23 00:10:26 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-11 06:15:03 +08:00
|
|
|
int show_line_range(struct line_range *lr __maybe_unused,
|
2014-09-17 16:40:54 +08:00
|
|
|
const char *module __maybe_unused,
|
2017-07-06 09:48:10 +08:00
|
|
|
struct nsinfo *nsi __maybe_unused,
|
2014-09-17 16:40:54 +08:00
|
|
|
bool user __maybe_unused)
|
2010-03-23 00:10:26 +08:00
|
|
|
{
|
2010-04-13 01:17:42 +08:00
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
2010-03-23 00:10:26 +08:00
|
|
|
}
|
|
|
|
|
2012-09-11 06:15:03 +08:00
|
|
|
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
|
2015-05-08 09:03:31 +08:00
|
|
|
int npevs __maybe_unused,
|
|
|
|
struct strfilter *filter __maybe_unused)
|
2010-10-21 18:13:23 +08:00
|
|
|
{
|
|
|
|
pr_warning("Debuginfo-analysis is not supported.\n");
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2010-03-17 06:05:37 +08:00
|
|
|
#endif
|
|
|
|
|
2014-01-16 17:39:47 +08:00
|
|
|
void line_range__clear(struct line_range *lr)
|
|
|
|
{
|
|
|
|
free(lr->function);
|
|
|
|
free(lr->file);
|
|
|
|
free(lr->path);
|
|
|
|
free(lr->comp_dir);
|
2014-02-06 13:32:09 +08:00
|
|
|
intlist__delete(lr->line_list);
|
2014-01-16 17:39:47 +08:00
|
|
|
memset(lr, 0, sizeof(*lr));
|
|
|
|
}
|
|
|
|
|
2014-02-06 13:32:09 +08:00
|
|
|
int line_range__init(struct line_range *lr)
|
2014-01-16 17:39:47 +08:00
|
|
|
{
|
|
|
|
memset(lr, 0, sizeof(*lr));
|
2014-02-06 13:32:09 +08:00
|
|
|
lr->line_list = intlist__new(NULL);
|
|
|
|
if (!lr->line_list)
|
|
|
|
return -ENOMEM;
|
|
|
|
else
|
|
|
|
return 0;
|
2014-01-16 17:39:47 +08:00
|
|
|
}
|
|
|
|
|
2010-12-20 22:18:05 +08: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;
|
|
|
|
}
|
|
|
|
|
2015-05-06 20:46:47 +08:00
|
|
|
/* Check the name is good for event, group or function */
|
|
|
|
static bool is_c_func_name(const char *name)
|
|
|
|
{
|
|
|
|
if (!isalpha(*name) && *name != '_')
|
|
|
|
return false;
|
|
|
|
while (*++name != '\0') {
|
|
|
|
if (!isalpha(*name) && !isdigit(*name) && *name != '_')
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-12-20 22:18:03 +08: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 17:08:10 +08:00
|
|
|
* FNC[@SRC][:SLN[+NUM|-ELN]]
|
2010-12-20 22:18:03 +08:00
|
|
|
*/
|
2010-04-13 01:17:42 +08:00
|
|
|
int parse_line_range_desc(const char *arg, struct line_range *lr)
|
2010-01-06 22:45:34 +08:00
|
|
|
{
|
2011-02-10 17:08:10 +08:00
|
|
|
char *range, *file, *name = strdup(arg);
|
2010-12-20 22:18:05 +08: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 22:18:03 +08:00
|
|
|
|
2010-04-15 06:39:42 +08:00
|
|
|
pr_debug("Line range is %d to %d\n", lr->start, lr->end);
|
2010-12-20 22:18:05 +08:00
|
|
|
|
|
|
|
err = -EINVAL;
|
2010-04-15 06:39:42 +08:00
|
|
|
if (lr->start > lr->end) {
|
2010-01-06 22:45:34 +08:00
|
|
|
semantic_error("Start line must be smaller"
|
2010-04-13 01:17:42 +08:00
|
|
|
" than end line.\n");
|
2010-12-20 22:18:05 +08:00
|
|
|
goto err;
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2010-12-20 22:18:05 +08:00
|
|
|
if (*range != '\0') {
|
|
|
|
semantic_error("Tailing with invalid str '%s'.\n", range);
|
|
|
|
goto err;
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2010-04-15 06:39:42 +08:00
|
|
|
}
|
2010-04-13 01:17:56 +08:00
|
|
|
|
2011-02-10 17:08:10 +08:00
|
|
|
file = strchr(name, '@');
|
|
|
|
if (file) {
|
|
|
|
*file = '\0';
|
|
|
|
lr->file = strdup(++file);
|
|
|
|
if (lr->file == NULL) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
lr->function = name;
|
2015-05-06 20:46:47 +08:00
|
|
|
} else if (strchr(name, '/') || strchr(name, '.'))
|
2010-12-20 22:18:05 +08:00
|
|
|
lr->file = name;
|
2015-05-06 20:46:47 +08:00
|
|
|
else if (is_c_func_name(name))/* We reuse it for checking funcname */
|
2010-12-20 22:18:05 +08:00
|
|
|
lr->function = name;
|
2015-05-06 20:46:47 +08:00
|
|
|
else { /* Invalid name */
|
|
|
|
semantic_error("'%s' is not a valid function name.\n", name);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
|
|
|
|
return 0;
|
2010-12-20 22:18:05 +08:00
|
|
|
err:
|
|
|
|
free(name);
|
|
|
|
return err;
|
2010-01-06 22:45:34 +08:00
|
|
|
}
|
|
|
|
|
2016-07-12 18:04:43 +08:00
|
|
|
static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
|
|
|
|
{
|
|
|
|
char *ptr;
|
|
|
|
|
2017-12-12 23:05:12 +08:00
|
|
|
ptr = strpbrk_esc(*arg, ":");
|
2016-07-12 18:04:43 +08:00
|
|
|
if (ptr) {
|
|
|
|
*ptr = '\0';
|
2016-07-12 18:05:18 +08:00
|
|
|
if (!pev->sdt && !is_c_func_name(*arg))
|
2016-07-12 18:04:43 +08:00
|
|
|
goto ng_name;
|
2017-12-12 23:05:12 +08:00
|
|
|
pev->group = strdup_esc(*arg);
|
2016-07-12 18:04:43 +08:00
|
|
|
if (!pev->group)
|
|
|
|
return -ENOMEM;
|
|
|
|
*arg = ptr + 1;
|
|
|
|
} else
|
|
|
|
pev->group = NULL;
|
2017-12-12 23:05:12 +08:00
|
|
|
|
|
|
|
pev->event = strdup_esc(*arg);
|
|
|
|
if (pev->event == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!pev->sdt && !is_c_func_name(pev->event)) {
|
|
|
|
zfree(&pev->event);
|
2016-07-12 18:04:43 +08:00
|
|
|
ng_name:
|
2017-12-12 23:05:12 +08:00
|
|
|
zfree(&pev->group);
|
2016-07-12 18:04:43 +08:00
|
|
|
semantic_error("%s is bad for event name -it must "
|
|
|
|
"follow C symbol-naming rule.\n", *arg);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-01 08:19:58 +08:00
|
|
|
/* Parse probepoint definition. */
|
2010-04-13 01:17:42 +08:00
|
|
|
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
|
2009-12-01 08:19:58 +08:00
|
|
|
{
|
2010-03-17 06:06:12 +08:00
|
|
|
struct perf_probe_point *pp = &pev->point;
|
2009-12-01 08:19:58 +08:00
|
|
|
char *ptr, *tmp;
|
|
|
|
char c, nc = 0;
|
2015-04-28 20:05:34 +08:00
|
|
|
bool file_spec = false;
|
2016-07-12 18:04:43 +08:00
|
|
|
int ret;
|
|
|
|
|
2009-12-01 08:19:58 +08:00
|
|
|
/*
|
|
|
|
* <Syntax>
|
2016-07-01 16:04:01 +08:00
|
|
|
* perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
|
|
|
|
* perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
|
2016-07-12 18:04:43 +08:00
|
|
|
* perf probe %[GRP:]SDT_EVENT
|
2009-12-01 08:19:58 +08:00
|
|
|
*/
|
2015-04-28 16:46:09 +08:00
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2017-03-14 23:06:52 +08:00
|
|
|
if (is_sdt_event(arg)) {
|
2016-07-12 18:04:43 +08:00
|
|
|
pev->sdt = true;
|
2016-07-12 18:05:46 +08:00
|
|
|
if (arg[0] == '%')
|
|
|
|
arg++;
|
2016-07-12 18:04:43 +08:00
|
|
|
}
|
|
|
|
|
2017-12-12 23:05:12 +08:00
|
|
|
ptr = strpbrk_esc(arg, ";=@+%");
|
2016-07-12 18:04:43 +08:00
|
|
|
if (pev->sdt) {
|
2016-07-01 16:04:01 +08:00
|
|
|
if (ptr) {
|
perf probe: Support @BUILDID or @FILE suffix for SDT events
Support @BUILDID or @FILE suffix for SDT events. This allows perf to add
probes on SDTs/pre-cached events on given FILE or the file which has
given BUILDID (also, this complements BUILDID.)
For example, both gcc and libstdc++ has same SDTs as below. If you
would like to add a probe on sdt_libstdcxx:catch on gcc, you can do as
below.
----
# perf list sdt | tail -n 6
sdt_libstdcxx:catch@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
sdt_libstdcxx:rethrow@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:rethrow@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
sdt_libstdcxx:throw@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:throw@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
# perf probe -a %sdt_libstdcxx:catch@0cc
Added new event:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
----
Committer note:
Doing the full sequence of steps to get the results above:
With a clean build-id cache:
[root@jouet ~]# rm -rf ~/.debug/
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
[root@jouet ~]#
No events whatsoever, then, we can add all events in gcc to the build-id
cache, doing a --add + --dry-run:
[root@jouet ~]# perf probe --dry-run --cache -x /usr/bin/gcc --add %sdt_libstdcxx:\*
Added new events:
sdt_libstdcxx:throw (on %* in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on %* in /usr/bin/gcc)
sdt_libstdcxx:catch (on %* in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]#
It really didn't add any events, it just cached them:
[root@jouet ~]# perf probe -l
[root@jouet ~]#
We can see that it was cached as:
[root@jouet ~]# ls -la ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/
total 976
drwxr-xr-x. 2 root root 4096 Jul 13 21:47 .
drwxr-xr-x. 3 root root 4096 Jul 13 21:47 ..
-rwxr-xr-x. 4 root root 985912 Jun 22 18:52 elf
-rw-r--r--. 1 root root 303 Jul 13 21:47 probes
[root@jouet ~]# file ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/elf
/root/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/elf: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2, stripped
[root@jouet ~]# cat ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/probes
%sdt_libstdcxx:throw=throw
p:sdt_libstdcxx/throw /usr/bin/gcc:0x71ffd
%sdt_libstdcxx:rethrow=rethrow
p:sdt_libstdcxx/rethrow /usr/bin/gcc:0x720b8
%sdt_libstdcxx:catch=catch
p:sdt_libstdcxx/catch /usr/bin/gcc:0x7307f
%sdt_libgcc:unwind=unwind
p:sdt_libgcc/unwind /usr/bin/gcc:0x7eec0
#sdt_libstdcxx:*=%*
[root@jouet ~]#
Ok, now we can use 'perf probe' to refer to those cached entries as:
Humm, nope, doing as above we end up with:
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch
Semantic error :* is bad for event name -it must follow C symbol-naming rule.
Error: Failed to add events.
[root@jouet ~]#
But it worked at some point, lets try not using --dry-run:
Resetting everything:
# rm -rf ~/.debug/
# perf probe -d *:*
# perf probe -l
# perf list sdt
List of pre-defined events (to be used in -e):
#
Ok, now it cached everything, even things we haven't asked it to
(sdt_libgcc:unwind):
[root@jouet ~]# perf probe -x /usr/bin/gcc --add %sdt_libstdcxx:\*
Added new events:
sdt_libstdcxx:throw (on %* in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on %* in /usr/bin/gcc)
sdt_libstdcxx:catch (on %* in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
sdt_libgcc:unwind [SDT event]
sdt_libstdcxx:catch [SDT event]
sdt_libstdcxx:rethrow [SDT event]
sdt_libstdcxx:throw [SDT event]
[root@jouet ~]#
And we have the events in place:
[root@jouet ~]# perf probe -l
sdt_libstdcxx:catch (on execute_cfa_program+1551@../../../libgcc/unwind-dw2.c in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on d_print_subexpr+280@libsupc++/cp-demangle.c in /usr/bin/gcc)
sdt_libstdcxx:throw (on d_print_subexpr+93@libsupc++/cp-demangle.c in /usr/bin/gcc)
[root@jouet ~]#
And trying to use them at least has 'perf trace --event sdt*:*' working.
Then, if we try to add the ones in libstdc++:
[root@jouet ~]# perf probe -x /usr/lib64/libstdc++.so.6 -a %sdt_libstdcxx:\*
Error: event "catch" already exists.
Hint: Remove existing event by 'perf probe -d'
or force duplicates by 'perf probe -f'
or set 'force=yes' in BPF source.
Error: Failed to add events.
[root@jouet ~]#
Doesn't work, dups, but at least this served to, unbeknownst to the user, add
the SDT probes in /usr/lib64/libstdc++.so.6!
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
sdt_libgcc:unwind [SDT event]
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
sdt_libstdcxx:rethrow@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:rethrow@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
sdt_libstdcxx:throw@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:throw@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
Now we should be able to get to the original cset comment, if we remove all
SDTs events in place, not from the cache, from the kernel, where it was set up as:
[root@jouet ~]# ls -la /sys/kernel/debug/tracing/events/sdt_libstdcxx/
total 0
drwxr-xr-x. 5 root root 0 Jul 13 22:00 .
drwxr-xr-x. 80 root root 0 Jul 13 21:56 ..
drwxr-xr-x. 2 root root 0 Jul 13 22:00 catch
-rw-r--r--. 1 root root 0 Jul 13 22:00 enable
-rw-r--r--. 1 root root 0 Jul 13 22:00 filter
drwxr-xr-x. 2 root root 0 Jul 13 22:00 rethrow
drwxr-xr-x. 2 root root 0 Jul 13 22:00 throw
[root@jouet ~]#
[root@jouet ~]# head -2 /sys/kernel/debug/tracing/events/sdt_libstdcxx/throw/format
name: throw
ID: 2059
[root@jouet ~]#
Now to remove it:
[root@jouet ~]# perf probe -d sdt_libstdc*:*
Removed event: sdt_libstdcxx:catch
Removed event: sdt_libstdcxx:rethrow
Removed event: sdt_libstdcxx:throw
[root@jouet ~]#
Which caused:
[root@jouet ~]# ls -la /sys/kernel/debug/tracing/events/sdt_libstdcxx/
ls: cannot access '/sys/kernel/debug/tracing/events/sdt_libstdcxx/': No such file or directory
[root@jouet ~]#
Ok, now we can do:
[root@jouet ~]# perf list sdt_libstdcxx:catch
List of pre-defined events (to be used in -e):
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
So, these are not really 'pre-defined events', i.e. we can't use them with
'perf record --event':
[root@jouet ~]# perf record --event sdt_libstdcxx:catch*
event syntax error: 'sdt_libstdcxx:catch*'
\___ unknown tracepoint
Error: File /sys/kernel/debug/tracing/events/sdt_libstdcxx/catch* not found.
Hint: Perhaps this kernel misses some CONFIG_ setting to enable this feature?.
<SNIP>
[root@jouet ~]#
To have it really pre-defined we must use perf probe to get its definition from
the cache and set it up in the kernel, creating the tracepoint to _then_ use it
with 'perf record --event':
[root@jouet ~]# perf probe -a sdt_libstdcxx:catch
Semantic error :There is non-digit char in line number.
<SNIP>
Oops, there is another gotcha here, we need that pesky '%' character:
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch
Added new events:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
sdt_libstdcxx:catch_1 (on %catch in /usr/lib64/libstdc++.so.6.0.22)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch_1 -aR sleep 1
[root@jouet ~]#
But then we added _two_ events, one with the name we expected, the other one
with a _ added, when doing the analysis we need to pay attention to who maps to
who.
And here is where we get to the point of this patch, which is to be able to
disambiguate those definitions for 'catch' in the build-id cache, but first we need
remove those events we just added:
[root@jouet ~]# perf probe -d %sdt_libstdcxx:catch
Oops, that didn't remove anything, we need to _remove_ that % char in this case:
[root@jouet ~]# perf probe -d sdt_libstdcxx:catch
Removed event: sdt_libstdcxx:catch
And we need to remove the other event added, i.e. I forgot to add a * at the end:
[root@jouet ~]# perf probe -d sdt_libstdcxx:catch*
Removed event: sdt_libstdcxx:catch_1
[root@jouet ~]#
Ok, disambiguating it using what is in this patch:
[root@jouet ~]# perf list sdt_libstdcxx:catch
List of pre-defined events (to be used in -e):
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch@9a07
Added new event:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]# perf probe -l
sdt_libstdcxx:catch (on execute_cfa_program+1551@../../../libgcc/unwind-dw2.c in /usr/bin/gcc)
[root@jouet ~]#
Yeah, it works! But we need to try and simplify this :-)
Update: Some aspects of this simplification take place in the following
patches.
Signed-off-by: Masami Hiramatsu <mhiramat@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@linux.vnet.ibm.com>
Cc: Brendan Gregg <brendan.d.gregg@gmail.com>
Cc: Hemant Kumar <hemant@linux.vnet.ibm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/146831793746.17065.13065062753978236612.stgit@devbox
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-07-12 18:05:37 +08:00
|
|
|
if (*ptr != '@') {
|
|
|
|
semantic_error("%s must be an SDT name.\n",
|
|
|
|
arg);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/* This must be a target file name or build id */
|
|
|
|
tmp = build_id_cache__complement(ptr + 1);
|
|
|
|
if (tmp) {
|
|
|
|
pev->target = build_id_cache__origname(tmp);
|
|
|
|
free(tmp);
|
|
|
|
} else
|
2017-12-12 23:05:12 +08:00
|
|
|
pev->target = strdup_esc(ptr + 1);
|
perf probe: Support @BUILDID or @FILE suffix for SDT events
Support @BUILDID or @FILE suffix for SDT events. This allows perf to add
probes on SDTs/pre-cached events on given FILE or the file which has
given BUILDID (also, this complements BUILDID.)
For example, both gcc and libstdc++ has same SDTs as below. If you
would like to add a probe on sdt_libstdcxx:catch on gcc, you can do as
below.
----
# perf list sdt | tail -n 6
sdt_libstdcxx:catch@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
sdt_libstdcxx:rethrow@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:rethrow@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
sdt_libstdcxx:throw@/usr/bin/gcc(0cc207fc4b27) [SDT event]
sdt_libstdcxx:throw@/usr/lib64/libstdc++.so.6.0.20(91c7a88fdf49)
# perf probe -a %sdt_libstdcxx:catch@0cc
Added new event:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
----
Committer note:
Doing the full sequence of steps to get the results above:
With a clean build-id cache:
[root@jouet ~]# rm -rf ~/.debug/
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
[root@jouet ~]#
No events whatsoever, then, we can add all events in gcc to the build-id
cache, doing a --add + --dry-run:
[root@jouet ~]# perf probe --dry-run --cache -x /usr/bin/gcc --add %sdt_libstdcxx:\*
Added new events:
sdt_libstdcxx:throw (on %* in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on %* in /usr/bin/gcc)
sdt_libstdcxx:catch (on %* in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]#
It really didn't add any events, it just cached them:
[root@jouet ~]# perf probe -l
[root@jouet ~]#
We can see that it was cached as:
[root@jouet ~]# ls -la ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/
total 976
drwxr-xr-x. 2 root root 4096 Jul 13 21:47 .
drwxr-xr-x. 3 root root 4096 Jul 13 21:47 ..
-rwxr-xr-x. 4 root root 985912 Jun 22 18:52 elf
-rw-r--r--. 1 root root 303 Jul 13 21:47 probes
[root@jouet ~]# file ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/elf
/root/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/elf: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2, stripped
[root@jouet ~]# cat ~/.debug/usr/bin/gcc/9a0730e2bcc6d2a2003d21ac46807e8ee6bcb7c2/probes
%sdt_libstdcxx:throw=throw
p:sdt_libstdcxx/throw /usr/bin/gcc:0x71ffd
%sdt_libstdcxx:rethrow=rethrow
p:sdt_libstdcxx/rethrow /usr/bin/gcc:0x720b8
%sdt_libstdcxx:catch=catch
p:sdt_libstdcxx/catch /usr/bin/gcc:0x7307f
%sdt_libgcc:unwind=unwind
p:sdt_libgcc/unwind /usr/bin/gcc:0x7eec0
#sdt_libstdcxx:*=%*
[root@jouet ~]#
Ok, now we can use 'perf probe' to refer to those cached entries as:
Humm, nope, doing as above we end up with:
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch
Semantic error :* is bad for event name -it must follow C symbol-naming rule.
Error: Failed to add events.
[root@jouet ~]#
But it worked at some point, lets try not using --dry-run:
Resetting everything:
# rm -rf ~/.debug/
# perf probe -d *:*
# perf probe -l
# perf list sdt
List of pre-defined events (to be used in -e):
#
Ok, now it cached everything, even things we haven't asked it to
(sdt_libgcc:unwind):
[root@jouet ~]# perf probe -x /usr/bin/gcc --add %sdt_libstdcxx:\*
Added new events:
sdt_libstdcxx:throw (on %* in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on %* in /usr/bin/gcc)
sdt_libstdcxx:catch (on %* in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
sdt_libgcc:unwind [SDT event]
sdt_libstdcxx:catch [SDT event]
sdt_libstdcxx:rethrow [SDT event]
sdt_libstdcxx:throw [SDT event]
[root@jouet ~]#
And we have the events in place:
[root@jouet ~]# perf probe -l
sdt_libstdcxx:catch (on execute_cfa_program+1551@../../../libgcc/unwind-dw2.c in /usr/bin/gcc)
sdt_libstdcxx:rethrow (on d_print_subexpr+280@libsupc++/cp-demangle.c in /usr/bin/gcc)
sdt_libstdcxx:throw (on d_print_subexpr+93@libsupc++/cp-demangle.c in /usr/bin/gcc)
[root@jouet ~]#
And trying to use them at least has 'perf trace --event sdt*:*' working.
Then, if we try to add the ones in libstdc++:
[root@jouet ~]# perf probe -x /usr/lib64/libstdc++.so.6 -a %sdt_libstdcxx:\*
Error: event "catch" already exists.
Hint: Remove existing event by 'perf probe -d'
or force duplicates by 'perf probe -f'
or set 'force=yes' in BPF source.
Error: Failed to add events.
[root@jouet ~]#
Doesn't work, dups, but at least this served to, unbeknownst to the user, add
the SDT probes in /usr/lib64/libstdc++.so.6!
[root@jouet ~]# perf list sdt
List of pre-defined events (to be used in -e):
sdt_libgcc:unwind [SDT event]
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
sdt_libstdcxx:rethrow@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:rethrow@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
sdt_libstdcxx:throw@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:throw@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
Now we should be able to get to the original cset comment, if we remove all
SDTs events in place, not from the cache, from the kernel, where it was set up as:
[root@jouet ~]# ls -la /sys/kernel/debug/tracing/events/sdt_libstdcxx/
total 0
drwxr-xr-x. 5 root root 0 Jul 13 22:00 .
drwxr-xr-x. 80 root root 0 Jul 13 21:56 ..
drwxr-xr-x. 2 root root 0 Jul 13 22:00 catch
-rw-r--r--. 1 root root 0 Jul 13 22:00 enable
-rw-r--r--. 1 root root 0 Jul 13 22:00 filter
drwxr-xr-x. 2 root root 0 Jul 13 22:00 rethrow
drwxr-xr-x. 2 root root 0 Jul 13 22:00 throw
[root@jouet ~]#
[root@jouet ~]# head -2 /sys/kernel/debug/tracing/events/sdt_libstdcxx/throw/format
name: throw
ID: 2059
[root@jouet ~]#
Now to remove it:
[root@jouet ~]# perf probe -d sdt_libstdc*:*
Removed event: sdt_libstdcxx:catch
Removed event: sdt_libstdcxx:rethrow
Removed event: sdt_libstdcxx:throw
[root@jouet ~]#
Which caused:
[root@jouet ~]# ls -la /sys/kernel/debug/tracing/events/sdt_libstdcxx/
ls: cannot access '/sys/kernel/debug/tracing/events/sdt_libstdcxx/': No such file or directory
[root@jouet ~]#
Ok, now we can do:
[root@jouet ~]# perf list sdt_libstdcxx:catch
List of pre-defined events (to be used in -e):
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
So, these are not really 'pre-defined events', i.e. we can't use them with
'perf record --event':
[root@jouet ~]# perf record --event sdt_libstdcxx:catch*
event syntax error: 'sdt_libstdcxx:catch*'
\___ unknown tracepoint
Error: File /sys/kernel/debug/tracing/events/sdt_libstdcxx/catch* not found.
Hint: Perhaps this kernel misses some CONFIG_ setting to enable this feature?.
<SNIP>
[root@jouet ~]#
To have it really pre-defined we must use perf probe to get its definition from
the cache and set it up in the kernel, creating the tracepoint to _then_ use it
with 'perf record --event':
[root@jouet ~]# perf probe -a sdt_libstdcxx:catch
Semantic error :There is non-digit char in line number.
<SNIP>
Oops, there is another gotcha here, we need that pesky '%' character:
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch
Added new events:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
sdt_libstdcxx:catch_1 (on %catch in /usr/lib64/libstdc++.so.6.0.22)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch_1 -aR sleep 1
[root@jouet ~]#
But then we added _two_ events, one with the name we expected, the other one
with a _ added, when doing the analysis we need to pay attention to who maps to
who.
And here is where we get to the point of this patch, which is to be able to
disambiguate those definitions for 'catch' in the build-id cache, but first we need
remove those events we just added:
[root@jouet ~]# perf probe -d %sdt_libstdcxx:catch
Oops, that didn't remove anything, we need to _remove_ that % char in this case:
[root@jouet ~]# perf probe -d sdt_libstdcxx:catch
Removed event: sdt_libstdcxx:catch
And we need to remove the other event added, i.e. I forgot to add a * at the end:
[root@jouet ~]# perf probe -d sdt_libstdcxx:catch*
Removed event: sdt_libstdcxx:catch_1
[root@jouet ~]#
Ok, disambiguating it using what is in this patch:
[root@jouet ~]# perf list sdt_libstdcxx:catch
List of pre-defined events (to be used in -e):
sdt_libstdcxx:catch@/usr/bin/gcc(9a0730e2bcc6) [SDT event]
sdt_libstdcxx:catch@/usr/lib64/libstdc++.so.6.0.22(ef2b7066559a) [SDT event]
[root@jouet ~]#
[root@jouet ~]# perf probe -a %sdt_libstdcxx:catch@9a07
Added new event:
sdt_libstdcxx:catch (on %catch in /usr/bin/gcc)
You can now use it in all perf tools, such as:
perf record -e sdt_libstdcxx:catch -aR sleep 1
[root@jouet ~]# perf probe -l
sdt_libstdcxx:catch (on execute_cfa_program+1551@../../../libgcc/unwind-dw2.c in /usr/bin/gcc)
[root@jouet ~]#
Yeah, it works! But we need to try and simplify this :-)
Update: Some aspects of this simplification take place in the following
patches.
Signed-off-by: Masami Hiramatsu <mhiramat@kernel.org>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@linux.vnet.ibm.com>
Cc: Brendan Gregg <brendan.d.gregg@gmail.com>
Cc: Hemant Kumar <hemant@linux.vnet.ibm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/146831793746.17065.13065062753978236612.stgit@devbox
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-07-12 18:05:37 +08:00
|
|
|
if (!pev->target)
|
|
|
|
return -ENOMEM;
|
|
|
|
*ptr = '\0';
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2016-07-12 18:04:43 +08:00
|
|
|
ret = parse_perf_probe_event_name(&arg, pev);
|
|
|
|
if (ret == 0) {
|
|
|
|
if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
|
|
|
|
ret = -errno;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ptr && *ptr == '=') { /* Event name */
|
|
|
|
*ptr = '\0';
|
|
|
|
tmp = ptr + 1;
|
|
|
|
ret = parse_perf_probe_event_name(&arg, pev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-12-15 23:32:18 +08:00
|
|
|
arg = tmp;
|
|
|
|
}
|
|
|
|
|
2015-04-28 20:05:34 +08:00
|
|
|
/*
|
|
|
|
* Check arg is function or file name and copy it.
|
|
|
|
*
|
|
|
|
* We consider arg to be a file spec if and only if it satisfies
|
|
|
|
* all of the below criteria::
|
|
|
|
* - it does not include any of "+@%",
|
|
|
|
* - it includes one of ":;", and
|
|
|
|
* - it has a period '.' in the name.
|
|
|
|
*
|
|
|
|
* Otherwise, we consider arg to be a function specification.
|
|
|
|
*/
|
2017-12-12 23:05:12 +08:00
|
|
|
if (!strpbrk_esc(arg, "+@%")) {
|
|
|
|
ptr = strpbrk_esc(arg, ";:");
|
2015-04-28 20:05:34 +08:00
|
|
|
/* This is a file spec if it includes a '.' before ; or : */
|
2017-12-12 23:05:12 +08:00
|
|
|
if (ptr && memchr(arg, '.', ptr - arg))
|
2015-04-28 20:05:34 +08:00
|
|
|
file_spec = true;
|
|
|
|
}
|
|
|
|
|
2017-12-12 23:05:12 +08:00
|
|
|
ptr = strpbrk_esc(arg, ";:+@%");
|
2009-12-01 08:19:58 +08:00
|
|
|
if (ptr) {
|
|
|
|
nc = *ptr;
|
|
|
|
*ptr++ = '\0';
|
|
|
|
}
|
|
|
|
|
2015-08-26 18:57:44 +08:00
|
|
|
if (arg[0] == '\0')
|
|
|
|
tmp = NULL;
|
|
|
|
else {
|
2017-12-12 23:05:12 +08:00
|
|
|
tmp = strdup_esc(arg);
|
2015-08-26 18:57:44 +08:00
|
|
|
if (tmp == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-04-13 01:17:56 +08:00
|
|
|
|
2015-04-28 20:05:34 +08:00
|
|
|
if (file_spec)
|
2010-04-13 01:17:56 +08:00
|
|
|
pp->file = tmp;
|
2015-08-26 18:57:45 +08:00
|
|
|
else {
|
2010-04-13 01:17:56 +08:00
|
|
|
pp->function = tmp;
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
/*
|
|
|
|
* Keep pp->function even if this is absolute address,
|
|
|
|
* so it can mark whether abs_address is valid.
|
|
|
|
* Which make 'perf probe lib.bin 0x0' possible.
|
|
|
|
*
|
|
|
|
* Note that checking length of tmp is not needed
|
|
|
|
* because when we access tmp[1] we know tmp[0] is '0',
|
|
|
|
* so tmp[1] should always valid (but could be '\0').
|
|
|
|
*/
|
|
|
|
if (tmp && !strncmp(tmp, "0x", 2)) {
|
|
|
|
pp->abs_address = strtoul(pp->function, &tmp, 0);
|
|
|
|
if (*tmp != '\0') {
|
|
|
|
semantic_error("Invalid absolute address.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-01 08:19:58 +08:00
|
|
|
/* Parse other options */
|
|
|
|
while (ptr) {
|
|
|
|
arg = ptr;
|
|
|
|
c = nc;
|
2010-02-25 21:36:12 +08:00
|
|
|
if (c == ';') { /* Lazy pattern must be the last part */
|
2017-12-12 23:05:12 +08:00
|
|
|
pp->lazy_line = strdup(arg); /* let leave escapes */
|
2010-04-13 01:17:56 +08:00
|
|
|
if (pp->lazy_line == NULL)
|
|
|
|
return -ENOMEM;
|
2010-02-25 21:36:12 +08:00
|
|
|
break;
|
|
|
|
}
|
2017-12-12 23:05:12 +08:00
|
|
|
ptr = strpbrk_esc(arg, ";:+@%");
|
2009-12-01 08:19:58 +08:00
|
|
|
if (ptr) {
|
|
|
|
nc = *ptr;
|
|
|
|
*ptr++ = '\0';
|
|
|
|
}
|
|
|
|
switch (c) {
|
|
|
|
case ':': /* Line number */
|
|
|
|
pp->line = strtoul(arg, &tmp, 0);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (*tmp != '\0') {
|
2010-02-25 21:36:12 +08:00
|
|
|
semantic_error("There is non-digit char"
|
2010-04-13 01:17:42 +08:00
|
|
|
" in line number.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
break;
|
|
|
|
case '+': /* Byte offset from a symbol */
|
|
|
|
pp->offset = strtoul(arg, &tmp, 0);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (*tmp != '\0') {
|
2010-02-25 21:36:12 +08:00
|
|
|
semantic_error("There is non-digit character"
|
2010-04-13 01:17:42 +08:00
|
|
|
" in offset.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
break;
|
|
|
|
case '@': /* File name */
|
2010-04-13 01:17:42 +08:00
|
|
|
if (pp->file) {
|
|
|
|
semantic_error("SRC@SRC is not allowed.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2017-12-12 23:05:12 +08:00
|
|
|
pp->file = strdup_esc(arg);
|
2010-04-13 01:17:56 +08:00
|
|
|
if (pp->file == NULL)
|
|
|
|
return -ENOMEM;
|
2009-12-01 08:19:58 +08:00
|
|
|
break;
|
|
|
|
case '%': /* Probe places */
|
|
|
|
if (strcmp(arg, "return") == 0) {
|
|
|
|
pp->retprobe = 1;
|
2010-04-13 01:17:42 +08:00
|
|
|
} else { /* Others not supported yet */
|
|
|
|
semantic_error("%%%s is not supported.\n", arg);
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
break;
|
2010-04-13 01:17:42 +08:00
|
|
|
default: /* Buggy case */
|
|
|
|
pr_err("This program has a bug at %s:%d.\n",
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
return -ENOTSUP;
|
2009-12-01 08:19:58 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exclusion check */
|
2010-04-13 01:17:42 +08:00
|
|
|
if (pp->lazy_line && pp->line) {
|
2010-12-17 21:12:11 +08:00
|
|
|
semantic_error("Lazy pattern can't be used with"
|
|
|
|
" line number.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-02-25 21:36:12 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if (pp->lazy_line && pp->offset) {
|
2010-12-17 21:12:11 +08:00
|
|
|
semantic_error("Lazy pattern can't be used with offset.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-02-25 21:36:12 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if (pp->line && pp->offset) {
|
2010-12-17 21:12:11 +08:00
|
|
|
semantic_error("Offset can't be used with line number.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
|
2010-02-25 21:36:12 +08:00
|
|
|
semantic_error("File always requires line number or "
|
2010-12-17 21:12:11 +08:00
|
|
|
"lazy pattern.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if (pp->offset && !pp->function) {
|
2010-12-17 21:12:11 +08:00
|
|
|
semantic_error("Offset requires an entry function.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
|
2010-02-25 21:36:12 +08:00
|
|
|
semantic_error("Offset/Line/Lazy pattern can't be used with "
|
2010-12-17 21:12:11 +08:00
|
|
|
"return probe.\n");
|
2010-04-13 01:17:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
|
2010-02-25 21:36:12 +08:00
|
|
|
pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
|
|
|
|
pp->lazy_line);
|
2010-04-13 01:17:42 +08:00
|
|
|
return 0;
|
2009-12-01 08:19:58 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:26 +08:00
|
|
|
/* Parse perf-probe event argument */
|
2010-04-13 01:17:42 +08:00
|
|
|
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
|
2010-03-17 06:06:26 +08:00
|
|
|
{
|
2010-05-20 03:57:42 +08:00
|
|
|
char *tmp, *goodname;
|
2010-03-17 06:06:26 +08:00
|
|
|
struct perf_probe_arg_field **fieldp;
|
|
|
|
|
|
|
|
pr_debug("parsing arg: %s into ", str);
|
|
|
|
|
2010-04-13 01:16:53 +08:00
|
|
|
tmp = strchr(str, '=');
|
|
|
|
if (tmp) {
|
2010-04-13 01:17:56 +08:00
|
|
|
arg->name = strndup(str, tmp - str);
|
|
|
|
if (arg->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-13 01:17:22 +08:00
|
|
|
pr_debug("name:%s ", arg->name);
|
2010-04-13 01:16:53 +08:00
|
|
|
str = tmp + 1;
|
|
|
|
}
|
|
|
|
|
2010-04-13 01:17:22 +08:00
|
|
|
tmp = strchr(str, ':');
|
|
|
|
if (tmp) { /* Type setting */
|
|
|
|
*tmp = '\0';
|
2010-04-13 01:17:56 +08:00
|
|
|
arg->type = strdup(tmp + 1);
|
|
|
|
if (arg->type == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-13 01:17:22 +08:00
|
|
|
pr_debug("type:%s ", arg->type);
|
|
|
|
}
|
|
|
|
|
2010-05-20 03:57:42 +08:00
|
|
|
tmp = strpbrk(str, "-.[");
|
2010-03-17 06:06:26 +08:00
|
|
|
if (!is_c_varname(str) || !tmp) {
|
|
|
|
/* A variable, register, symbol or special value */
|
2010-04-13 01:17:56 +08:00
|
|
|
arg->var = strdup(str);
|
|
|
|
if (arg->var == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-13 01:16:53 +08:00
|
|
|
pr_debug("%s\n", arg->var);
|
2010-04-13 01:17:42 +08:00
|
|
|
return 0;
|
2010-03-17 06:06:26 +08:00
|
|
|
}
|
|
|
|
|
2010-05-20 03:57:42 +08:00
|
|
|
/* Structure fields or array element */
|
2010-04-13 01:17:56 +08:00
|
|
|
arg->var = strndup(str, tmp - str);
|
|
|
|
if (arg->var == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-20 03:57:42 +08:00
|
|
|
goodname = arg->var;
|
2010-04-13 01:16:53 +08:00
|
|
|
pr_debug("%s, ", arg->var);
|
2010-03-17 06:06:26 +08:00
|
|
|
fieldp = &arg->field;
|
|
|
|
|
|
|
|
do {
|
2010-04-13 01:17:49 +08:00
|
|
|
*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
|
|
|
|
if (*fieldp == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-20 03:57:42 +08:00
|
|
|
if (*tmp == '[') { /* Array */
|
|
|
|
str = tmp;
|
|
|
|
(*fieldp)->index = strtol(str + 1, &tmp, 0);
|
2010-03-17 06:06:26 +08:00
|
|
|
(*fieldp)->ref = true;
|
2010-05-20 03:57:42 +08: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-13 01:17:42 +08:00
|
|
|
}
|
2010-03-17 06:06:26 +08:00
|
|
|
if (tmp) {
|
2010-04-13 01:17:56 +08:00
|
|
|
(*fieldp)->name = strndup(str, tmp - str);
|
|
|
|
if ((*fieldp)->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-20 03:57:42 +08:00
|
|
|
if (*str != '[')
|
|
|
|
goodname = (*fieldp)->name;
|
2010-03-17 06:06:26 +08:00
|
|
|
pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
|
|
|
|
fieldp = &(*fieldp)->next;
|
|
|
|
}
|
|
|
|
} while (tmp);
|
2010-04-13 01:17:56 +08:00
|
|
|
(*fieldp)->name = strdup(str);
|
|
|
|
if ((*fieldp)->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-05-20 03:57:42 +08:00
|
|
|
if (*str != '[')
|
|
|
|
goodname = (*fieldp)->name;
|
2010-03-17 06:06:26 +08:00
|
|
|
pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
|
2010-04-13 01:17:00 +08:00
|
|
|
|
2010-05-20 03:57:42 +08:00
|
|
|
/* If no name is specified, set the last field name (not array index)*/
|
2010-04-13 01:17:56 +08:00
|
|
|
if (!arg->name) {
|
2010-05-20 03:57:42 +08:00
|
|
|
arg->name = strdup(goodname);
|
2010-04-13 01:17:56 +08:00
|
|
|
if (arg->name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
return 0;
|
2010-03-17 06:06:26 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Parse perf-probe event command */
|
2010-04-13 01:17:42 +08:00
|
|
|
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
|
2009-12-01 08:19:58 +08:00
|
|
|
{
|
2009-12-01 08:20:05 +08:00
|
|
|
char **argv;
|
2010-04-13 01:17:42 +08:00
|
|
|
int argc, i, ret = 0;
|
2009-12-15 23:31:14 +08:00
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
argv = argv_split(cmd, &argc);
|
2010-04-13 01:17:42 +08: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-12-01 08:19:58 +08:00
|
|
|
/* Parse probe point */
|
2010-04-13 01:17:42 +08:00
|
|
|
ret = parse_perf_probe_point(argv[0], pev);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2009-12-01 08:20:05 +08:00
|
|
|
/* Copy arguments and ensure return probe has no C argument */
|
2010-03-17 06:06:12 +08:00
|
|
|
pev->nargs = argc - 1;
|
2010-04-13 01:17:49 +08:00
|
|
|
pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
|
|
|
|
if (pev->args == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-04-13 01:17:42 +08: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-17 06:06:12 +08:00
|
|
|
semantic_error("You can't specify local variable for"
|
2010-04-13 01:17:42 +08:00
|
|
|
" kretprobe.\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2009-12-01 08:20:05 +08:00
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
out:
|
2009-12-01 08:20:05 +08:00
|
|
|
argv_free(argv);
|
2010-04-13 01:17:42 +08:00
|
|
|
|
|
|
|
return ret;
|
2009-12-01 08:19:58 +08:00
|
|
|
}
|
|
|
|
|
2016-08-03 16:58:44 +08:00
|
|
|
/* Returns true if *any* ARG is either C variable, $params or $vars. */
|
|
|
|
bool perf_probe_with_var(struct perf_probe_event *pev)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < pev->nargs; i++)
|
|
|
|
if (is_c_varname(pev->args[i].var) ||
|
|
|
|
!strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
|
|
|
|
!strcmp(pev->args[i].var, PROBE_ARG_VARS))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Return true if this perf_probe_event requires debuginfo */
|
|
|
|
bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
|
|
|
|
{
|
|
|
|
if (pev->point.file || pev->point.line || pev->point.lazy_line)
|
|
|
|
return true;
|
|
|
|
|
2016-08-03 16:58:44 +08:00
|
|
|
if (perf_probe_with_var(pev))
|
|
|
|
return true;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
/* Parse probe_events event into struct probe_point */
|
2015-07-15 17:14:07 +08:00
|
|
|
int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
|
2009-12-01 08:20:17 +08:00
|
|
|
{
|
2010-07-29 22:13:51 +08:00
|
|
|
struct probe_trace_point *tp = &tev->point;
|
2009-12-01 08:20:17 +08:00
|
|
|
char pr;
|
|
|
|
char *p;
|
2012-09-21 04:37:50 +08:00
|
|
|
char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
|
2009-12-01 08:20:17 +08:00
|
|
|
int ret, i, argc;
|
|
|
|
char **argv;
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
pr_debug("Parsing probe_events: %s\n", cmd);
|
2010-03-17 06:06:12 +08:00
|
|
|
argv = argv_split(cmd, &argc);
|
2010-04-13 01:17:42 +08: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-12-01 08:20:17 +08:00
|
|
|
|
|
|
|
/* Scan event and group name. */
|
2012-09-21 04:37:50 +08: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-13 01:17:42 +08:00
|
|
|
semantic_error("Failed to parse event name: %s\n", argv[0]);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-09-21 04:37:50 +08: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-17 06:06:12 +08:00
|
|
|
pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
|
2009-12-01 08:20:17 +08:00
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
tp->retprobe = (pr == 'r');
|
2009-12-01 08:20:17 +08:00
|
|
|
|
2011-06-27 15:27:45 +08:00
|
|
|
/* Scan module name(if there), function name and offset */
|
|
|
|
p = strchr(argv[1], ':');
|
|
|
|
if (p) {
|
|
|
|
tp->module = strndup(argv[1], p - argv[1]);
|
2016-06-08 17:29:21 +08:00
|
|
|
if (!tp->module) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-07-12 18:05:18 +08:00
|
|
|
tev->uprobes = (tp->module[0] == '/');
|
2011-06-27 15:27:45 +08:00
|
|
|
p++;
|
|
|
|
} else
|
|
|
|
p = argv[1];
|
2012-09-21 04:37:50 +08:00
|
|
|
fmt1_str = strtok_r(p, "+", &fmt);
|
2015-08-26 18:57:43 +08:00
|
|
|
/* only the address started with 0x */
|
|
|
|
if (fmt1_str[0] == '0') {
|
|
|
|
/*
|
|
|
|
* Fix a special case:
|
|
|
|
* if address == 0, kernel reports something like:
|
|
|
|
* p:probe_libc/abs_0 /lib/libc-2.18.so:0x (null) arg1=%ax
|
|
|
|
* Newer kernel may fix that, but we want to
|
|
|
|
* support old kernel also.
|
|
|
|
*/
|
|
|
|
if (strcmp(fmt1_str, "0x") == 0) {
|
|
|
|
if (!argv[2] || strcmp(argv[2], "(null)")) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
tp->address = 0;
|
|
|
|
|
|
|
|
free(argv[2]);
|
|
|
|
for (i = 2; argv[i + 1] != NULL; i++)
|
|
|
|
argv[i] = argv[i + 1];
|
|
|
|
|
|
|
|
argv[i] = NULL;
|
|
|
|
argc -= 1;
|
|
|
|
} else
|
|
|
|
tp->address = strtoul(fmt1_str, NULL, 0);
|
|
|
|
} else {
|
2014-02-06 13:32:23 +08:00
|
|
|
/* 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-21 04:37:50 +08:00
|
|
|
}
|
2009-12-01 08:20:17 +08:00
|
|
|
|
2018-08-20 12:42:50 +08:00
|
|
|
if (tev->uprobes) {
|
|
|
|
fmt2_str = strchr(p, '(');
|
|
|
|
if (fmt2_str)
|
|
|
|
tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0);
|
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
tev->nargs = argc - 2;
|
2010-07-29 22:13:51 +08:00
|
|
|
tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
|
2010-04-13 01:17:49 +08:00
|
|
|
if (tev->args == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-03-17 06:06:12 +08:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
2009-12-01 08:20:17 +08:00
|
|
|
p = strchr(argv[i + 2], '=');
|
|
|
|
if (p) /* We don't need which register is assigned. */
|
2010-03-17 06:06:12 +08:00
|
|
|
*p++ = '\0';
|
|
|
|
else
|
|
|
|
p = argv[i + 2];
|
2010-04-13 01:17:56 +08:00
|
|
|
tev->args[i].name = strdup(argv[i + 2]);
|
2010-03-17 06:06:12 +08:00
|
|
|
/* TODO: parse regs and offset */
|
2010-04-13 01:17:56 +08:00
|
|
|
tev->args[i].value = strdup(p);
|
|
|
|
if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2012-09-21 04:37:50 +08:00
|
|
|
free(argv0_str);
|
2009-12-01 08:20:17 +08:00
|
|
|
argv_free(argv);
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:26 +08:00
|
|
|
/* Compose only probe arg */
|
2016-04-28 02:37:14 +08:00
|
|
|
char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
|
2010-03-17 06:06:26 +08:00
|
|
|
{
|
|
|
|
struct perf_probe_arg_field *field = pa->field;
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf buf;
|
2016-05-10 13:47:07 +08:00
|
|
|
char *ret = NULL;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (strbuf_init(&buf, 64) < 0)
|
|
|
|
return NULL;
|
2010-03-17 06:06:26 +08:00
|
|
|
|
2010-04-13 01:16:53 +08:00
|
|
|
if (pa->name && pa->var)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
|
2010-04-13 01:16:53 +08:00
|
|
|
else
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addstr(&buf, pa->name ?: pa->var);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2010-03-17 06:06:26 +08:00
|
|
|
|
|
|
|
while (field) {
|
2010-05-20 03:57:42 +08:00
|
|
|
if (field->name[0] == '[')
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addstr(&buf, field->name);
|
2010-05-20 03:57:42 +08:00
|
|
|
else
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
|
|
|
|
field->name);
|
2010-03-17 06:06:26 +08:00
|
|
|
field = field->next;
|
2016-05-10 13:47:07 +08:00
|
|
|
if (err)
|
|
|
|
goto out;
|
2010-03-17 06:06:26 +08:00
|
|
|
}
|
2010-04-13 01:17:22 +08:00
|
|
|
|
2016-04-28 02:37:14 +08:00
|
|
|
if (pa->type)
|
2016-05-10 13:47:07 +08:00
|
|
|
if (strbuf_addf(&buf, ":%s", pa->type) < 0)
|
|
|
|
goto out;
|
2016-04-28 02:37:14 +08:00
|
|
|
|
|
|
|
ret = strbuf_detach(&buf, NULL);
|
2016-05-10 13:47:07 +08:00
|
|
|
out:
|
|
|
|
strbuf_release(&buf);
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2010-03-17 06:06:26 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Compose only probe point (not argument) */
|
2016-06-08 17:29:50 +08:00
|
|
|
char *synthesize_perf_probe_point(struct perf_probe_point *pp)
|
2009-12-01 08:20:17 +08:00
|
|
|
{
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf buf;
|
2016-05-10 13:47:07 +08:00
|
|
|
char *tmp, *ret = NULL;
|
|
|
|
int len, err = 0;
|
|
|
|
|
|
|
|
if (strbuf_init(&buf, 64) < 0)
|
|
|
|
return NULL;
|
2016-04-28 02:37:14 +08:00
|
|
|
|
|
|
|
if (pp->function) {
|
2016-05-10 13:47:07 +08:00
|
|
|
if (strbuf_addstr(&buf, pp->function) < 0)
|
|
|
|
goto out;
|
2016-04-28 02:37:14 +08:00
|
|
|
if (pp->offset)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "+%lu", pp->offset);
|
2016-04-28 02:37:14 +08:00
|
|
|
else if (pp->line)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, ":%d", pp->line);
|
2016-04-28 02:37:14 +08:00
|
|
|
else if (pp->retprobe)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addstr(&buf, "%return");
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2010-03-17 06:06:19 +08:00
|
|
|
}
|
|
|
|
if (pp->file) {
|
2010-12-23 23:04:23 +08:00
|
|
|
tmp = pp->file;
|
|
|
|
len = strlen(tmp);
|
|
|
|
if (len > 30) {
|
|
|
|
tmp = strchr(pp->file + len - 30, '/');
|
|
|
|
tmp = tmp ? tmp + 1 : pp->file + len - 30;
|
|
|
|
}
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "@%s", tmp);
|
|
|
|
if (!err && !pp->function && pp->line)
|
|
|
|
err = strbuf_addf(&buf, ":%d", pp->line);
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
2016-05-10 13:47:07 +08:00
|
|
|
if (!err)
|
|
|
|
ret = strbuf_detach(&buf, NULL);
|
|
|
|
out:
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
2009-12-15 23:32:47 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
|
2009-12-15 23:32:47 +08:00
|
|
|
{
|
2016-06-08 17:29:50 +08:00
|
|
|
struct strbuf buf;
|
|
|
|
char *tmp, *ret = NULL;
|
|
|
|
int i;
|
2009-12-15 23:32:47 +08:00
|
|
|
|
2016-06-08 17:29:50 +08:00
|
|
|
if (strbuf_init(&buf, 64))
|
2010-03-17 06:06:12 +08:00
|
|
|
return NULL;
|
2016-06-08 17:29:50 +08:00
|
|
|
if (pev->event)
|
|
|
|
if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
|
|
|
|
pev->event) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tmp = synthesize_perf_probe_point(&pev->point);
|
|
|
|
if (!tmp || strbuf_addstr(&buf, tmp) < 0)
|
|
|
|
goto out;
|
|
|
|
free(tmp);
|
2009-12-01 08:20:17 +08:00
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
for (i = 0; i < pev->nargs; i++) {
|
2016-06-08 17:29:50 +08:00
|
|
|
tmp = synthesize_perf_probe_arg(pev->args + i);
|
|
|
|
if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
|
|
|
|
goto out;
|
|
|
|
free(tmp);
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
|
|
|
|
2016-06-08 17:29:50 +08:00
|
|
|
ret = strbuf_detach(&buf, NULL);
|
|
|
|
out:
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf *buf, int depth)
|
2010-03-17 06:06:12 +08:00
|
|
|
{
|
2016-05-10 13:47:07 +08:00
|
|
|
int err;
|
2010-03-17 06:06:12 +08:00
|
|
|
if (ref->next) {
|
2010-07-29 22:13:51 +08:00
|
|
|
depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
|
2016-04-28 02:37:14 +08:00
|
|
|
depth + 1);
|
2010-03-17 06:06:12 +08:00
|
|
|
if (depth < 0)
|
2016-05-10 13:47:07 +08:00
|
|
|
return depth;
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(buf, "%+ld(", ref->offset);
|
|
|
|
return (err < 0) ? err : depth;
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf *buf)
|
2009-12-01 08:19:58 +08:00
|
|
|
{
|
2010-07-29 22:13:51 +08:00
|
|
|
struct probe_trace_arg_ref *ref = arg->ref;
|
2016-05-10 13:47:07 +08:00
|
|
|
int depth = 0, err;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
|
|
|
/* Argument name or separator */
|
|
|
|
if (arg->name)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(buf, " %s=", arg->name);
|
2010-03-17 06:06:12 +08:00
|
|
|
else
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addch(buf, ' ');
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2010-05-20 03:57:49 +08:00
|
|
|
/* Special case: @XXX */
|
|
|
|
if (arg->value[0] == '@' && arg->ref)
|
|
|
|
ref = ref->next;
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Dereferencing arguments */
|
2010-05-20 03:57:49 +08:00
|
|
|
if (ref) {
|
2016-04-28 02:37:14 +08:00
|
|
|
depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
|
2010-03-17 06:06:12 +08:00
|
|
|
if (depth < 0)
|
|
|
|
return depth;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print argument value */
|
2010-05-20 03:57:49 +08:00
|
|
|
if (arg->value[0] == '@' && arg->ref)
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
|
2010-05-20 03:57:49 +08:00
|
|
|
else
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addstr(buf, arg->value);
|
2010-03-17 06:06:12 +08:00
|
|
|
|
|
|
|
/* Closing */
|
2016-05-10 13:47:07 +08:00
|
|
|
while (!err && depth--)
|
|
|
|
err = strbuf_addch(buf, ')');
|
|
|
|
|
2010-04-13 01:17:15 +08:00
|
|
|
/* Print argument type */
|
2016-05-10 13:47:07 +08:00
|
|
|
if (!err && arg->type)
|
|
|
|
err = strbuf_addf(buf, ":%s", arg->type);
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
return err;
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
|
|
|
|
2018-08-20 12:42:50 +08:00
|
|
|
static int
|
|
|
|
synthesize_uprobe_trace_def(struct probe_trace_event *tev, struct strbuf *buf)
|
|
|
|
{
|
|
|
|
struct probe_trace_point *tp = &tev->point;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = strbuf_addf(buf, "%s:0x%lx", tp->module, tp->address);
|
|
|
|
|
|
|
|
if (err >= 0 && tp->ref_ctr_offset) {
|
|
|
|
if (!uprobe_ref_ctr_is_supported())
|
|
|
|
return -1;
|
|
|
|
err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset);
|
|
|
|
}
|
|
|
|
return err >= 0 ? 0 : -1;
|
|
|
|
}
|
|
|
|
|
2010-07-29 22:13:51 +08:00
|
|
|
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
|
2010-03-17 06:06:12 +08:00
|
|
|
{
|
2010-07-29 22:13:51 +08:00
|
|
|
struct probe_trace_point *tp = &tev->point;
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf buf;
|
|
|
|
char *ret = NULL;
|
2016-05-10 13:47:07 +08:00
|
|
|
int i, err;
|
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-06 13:32:25 +08:00
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
/* Uprobes must have tp->module */
|
|
|
|
if (tev->uprobes && !tp->module)
|
2016-04-28 02:37:14 +08:00
|
|
|
return NULL;
|
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
if (strbuf_init(&buf, 32) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
|
|
|
|
tev->group, tev->event) < 0)
|
|
|
|
goto error;
|
2015-08-26 18:57:45 +08:00
|
|
|
/*
|
|
|
|
* If tp->address == 0, then this point must be a
|
|
|
|
* absolute address uprobe.
|
|
|
|
* try_to_find_absolute_address() should have made
|
|
|
|
* tp->symbol to "0x0".
|
|
|
|
*/
|
|
|
|
if (tev->uprobes && !tp->address) {
|
|
|
|
if (!tp->symbol || strcmp(tp->symbol, "0x0"))
|
|
|
|
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-06 13:32:25 +08:00
|
|
|
|
|
|
|
/* Use the tp->address for uprobes */
|
2018-08-20 12:42:50 +08:00
|
|
|
if (tev->uprobes) {
|
|
|
|
err = synthesize_uprobe_trace_def(tev, &buf);
|
|
|
|
} else if (!strncmp(tp->symbol, "0x", 2)) {
|
2015-08-26 18:57:45 +08:00
|
|
|
/* Absolute address. See try_to_find_absolute_address() */
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
|
|
|
|
tp->module ? ":" : "", tp->address);
|
2018-08-20 12:42:50 +08:00
|
|
|
} else {
|
2016-05-10 13:47:07 +08:00
|
|
|
err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
|
|
|
|
tp->module ? ":" : "", tp->symbol, tp->offset);
|
2018-08-20 12:42:50 +08:00
|
|
|
}
|
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
if (err)
|
|
|
|
goto error;
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2016-04-28 02:37:14 +08:00
|
|
|
for (i = 0; i < tev->nargs; i++)
|
|
|
|
if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
|
2009-12-01 08:19:58 +08:00
|
|
|
goto error;
|
|
|
|
|
2016-04-28 02:37:14 +08:00
|
|
|
ret = strbuf_detach(&buf, NULL);
|
2009-12-01 08:19:58 +08:00
|
|
|
error:
|
2016-04-28 02:37:14 +08:00
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2014-02-06 13:32:23 +08: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;
|
2017-02-15 02:28:41 +08:00
|
|
|
struct map *map = NULL;
|
2015-08-25 21:27:35 +08:00
|
|
|
u64 addr = tp->address;
|
2014-02-06 13:32:23 +08:00
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
if (!is_kprobe) {
|
|
|
|
map = dso__new_map(tp->module);
|
|
|
|
if (!map)
|
|
|
|
goto out;
|
2016-09-02 06:25:52 +08:00
|
|
|
sym = map__find_symbol(map, addr);
|
2014-02-06 13:32:23 +08:00
|
|
|
} else {
|
2015-10-01 00:41:33 +08:00
|
|
|
if (tp->symbol && !addr) {
|
2015-11-06 16:30:03 +08:00
|
|
|
if (kernel_get_symbol_address_by_name(tp->symbol,
|
|
|
|
&addr, true, false) < 0)
|
2015-10-01 00:41:33 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2014-02-06 13:32:23 +08:00
|
|
|
if (addr) {
|
|
|
|
addr += tp->offset;
|
2018-04-30 23:20:54 +08:00
|
|
|
sym = machine__find_kernel_symbol(host_machine, addr, &map);
|
2014-02-06 13:32:23 +08:00
|
|
|
}
|
|
|
|
}
|
2015-11-05 21:19:25 +08:00
|
|
|
|
2014-02-06 13:32:23 +08:00
|
|
|
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) {
|
2015-05-26 03:59:56 +08:00
|
|
|
map__put(map);
|
2014-02-06 13:32:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_to_perf_probe_point(struct probe_trace_point *tp,
|
2015-08-26 18:57:45 +08:00
|
|
|
struct perf_probe_point *pp,
|
|
|
|
bool is_kprobe)
|
2014-02-06 13:32:23 +08:00
|
|
|
{
|
|
|
|
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;
|
2015-08-26 18:57:42 +08:00
|
|
|
} else {
|
2014-02-06 13:32:23 +08:00
|
|
|
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 22:13:51 +08:00
|
|
|
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
|
2012-04-16 20:09:09 +08:00
|
|
|
struct perf_probe_event *pev, bool is_kprobe)
|
2010-03-17 06:06:12 +08:00
|
|
|
{
|
2016-04-28 02:37:14 +08:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2010-04-13 01:17:42 +08:00
|
|
|
int i, ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2010-03-23 00:10:26 +08:00
|
|
|
/* Convert event/group name */
|
2010-04-13 01:17:56 +08:00
|
|
|
pev->event = strdup(tev->event);
|
|
|
|
pev->group = strdup(tev->group);
|
|
|
|
if (pev->event == NULL || pev->group == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-17 06:06:19 +08:00
|
|
|
|
2010-03-23 00:10:26 +08:00
|
|
|
/* Convert trace_point to probe_point */
|
2014-02-06 13:32:23 +08:00
|
|
|
ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-03-23 00:10:26 +08:00
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Convert trace_arg to probe_arg */
|
|
|
|
pev->nargs = tev->nargs;
|
2010-04-13 01:17:49 +08:00
|
|
|
pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
|
|
|
|
if (pev->args == NULL)
|
|
|
|
return -ENOMEM;
|
2010-04-13 01:17:56 +08:00
|
|
|
for (i = 0; i < tev->nargs && ret >= 0; i++) {
|
2010-03-17 06:06:12 +08:00
|
|
|
if (tev->args[i].name)
|
2010-04-13 01:17:56 +08:00
|
|
|
pev->args[i].name = strdup(tev->args[i].name);
|
2010-03-17 06:06:12 +08:00
|
|
|
else {
|
2016-05-10 13:47:07 +08:00
|
|
|
if ((ret = strbuf_init(&buf, 32)) < 0)
|
|
|
|
goto error;
|
2016-04-28 02:37:14 +08:00
|
|
|
ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
|
|
|
|
pev->args[i].name = strbuf_detach(&buf, NULL);
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
2010-04-13 01:17:56 +08:00
|
|
|
if (pev->args[i].name == NULL && ret >= 0)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
}
|
2016-05-10 13:47:07 +08:00
|
|
|
error:
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
clear_perf_probe_event(pev);
|
|
|
|
|
|
|
|
return ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void clear_perf_probe_event(struct perf_probe_event *pev)
|
|
|
|
{
|
2010-03-17 06:06:26 +08:00
|
|
|
struct perf_probe_arg_field *field, *next;
|
2010-03-17 06:06:12 +08:00
|
|
|
int i;
|
|
|
|
|
2013-12-27 02:54:57 +08:00
|
|
|
free(pev->event);
|
|
|
|
free(pev->group);
|
2015-04-01 18:25:39 +08:00
|
|
|
free(pev->target);
|
perf probe: Fix to handle aliased symbols in glibc
Fix perf probe to handle aliased symbols correctly in glibc. In the
glibc, several symbols are defined as an alias of __libc_XXX, e.g.
malloc is an alias of __libc_malloc.
In such cases, dwarf has no subroutine instances of the alias functions
(e.g. no "malloc" instance), but the map has that symbol and its
address.
Thus, if we search the alieased symbol in debuginfo, we always fail to
find it, but it is in the map.
To solve this problem, this fails back to address-based alternative
search, which searches the symbol in the map, translates its address to
alternative (correct) function name by using debuginfo, and retry to
find the alternative function point from debuginfo.
This adds fail-back process to --vars, --lines and --add options. So,
now you can use those on malloc@libc :)
Without this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Failed to find the address of malloc
Error: Failed to show vars.
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Probe point 'malloc' not found in debuginfo.
Error: Failed to add events.
-----
With this patch;
-----
# ./perf probe -x /usr/lib64/libc-2.17.so -V malloc
Available variables at malloc
@<__libc_malloc+0>
size_t bytes
# ./perf probe -x /usr/lib64/libc-2.17.so -a "malloc bytes"
Added new event:
probe_libc:malloc (on malloc in /usr/lib64/libc-2.17.so with bytes)
You can now use it in all perf tools, such as:
perf record -e probe_libc:malloc -aR sleep 1
-----
Reported-by: Arnaldo Carvalho de Melo <acme@kernel.org>
Signed-off-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Naohiro Aota <naota@elisp.net>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150306073120.6904.13779.stgit@localhost.localdomain
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-03-06 15:31:20 +08:00
|
|
|
clear_perf_probe_point(&pev->point);
|
2013-12-27 02:54:57 +08:00
|
|
|
|
2010-03-17 06:06:26 +08:00
|
|
|
for (i = 0; i < pev->nargs; i++) {
|
2013-12-27 02:54:57 +08:00
|
|
|
free(pev->args[i].name);
|
|
|
|
free(pev->args[i].var);
|
|
|
|
free(pev->args[i].type);
|
2010-03-17 06:06:26 +08:00
|
|
|
field = pev->args[i].field;
|
|
|
|
while (field) {
|
|
|
|
next = field->next;
|
2013-12-28 03:55:14 +08:00
|
|
|
zfree(&field->name);
|
2010-03-17 06:06:26 +08:00
|
|
|
free(field);
|
|
|
|
field = next;
|
|
|
|
}
|
|
|
|
}
|
2013-12-27 02:54:57 +08:00
|
|
|
free(pev->args);
|
2010-03-17 06:06:12 +08:00
|
|
|
memset(pev, 0, sizeof(*pev));
|
|
|
|
}
|
|
|
|
|
2016-06-08 17:29:40 +08:00
|
|
|
#define strdup_or_goto(str, label) \
|
|
|
|
({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
|
|
|
|
|
|
|
|
static int perf_probe_point__copy(struct perf_probe_point *dst,
|
|
|
|
struct perf_probe_point *src)
|
|
|
|
{
|
|
|
|
dst->file = strdup_or_goto(src->file, out_err);
|
|
|
|
dst->function = strdup_or_goto(src->function, out_err);
|
|
|
|
dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
|
|
|
|
dst->line = src->line;
|
|
|
|
dst->retprobe = src->retprobe;
|
|
|
|
dst->offset = src->offset;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
clear_perf_probe_point(dst);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int perf_probe_arg__copy(struct perf_probe_arg *dst,
|
|
|
|
struct perf_probe_arg *src)
|
|
|
|
{
|
|
|
|
struct perf_probe_arg_field *field, **ppfield;
|
|
|
|
|
|
|
|
dst->name = strdup_or_goto(src->name, out_err);
|
|
|
|
dst->var = strdup_or_goto(src->var, out_err);
|
|
|
|
dst->type = strdup_or_goto(src->type, out_err);
|
|
|
|
|
|
|
|
field = src->field;
|
|
|
|
ppfield = &(dst->field);
|
|
|
|
while (field) {
|
|
|
|
*ppfield = zalloc(sizeof(*field));
|
|
|
|
if (!*ppfield)
|
|
|
|
goto out_err;
|
|
|
|
(*ppfield)->name = strdup_or_goto(field->name, out_err);
|
|
|
|
(*ppfield)->index = field->index;
|
|
|
|
(*ppfield)->ref = field->ref;
|
|
|
|
field = field->next;
|
|
|
|
ppfield = &((*ppfield)->next);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
int perf_probe_event__copy(struct perf_probe_event *dst,
|
|
|
|
struct perf_probe_event *src)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dst->event = strdup_or_goto(src->event, out_err);
|
|
|
|
dst->group = strdup_or_goto(src->group, out_err);
|
|
|
|
dst->target = strdup_or_goto(src->target, out_err);
|
|
|
|
dst->uprobes = src->uprobes;
|
|
|
|
|
|
|
|
if (perf_probe_point__copy(&dst->point, &src->point) < 0)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
|
|
|
|
if (!dst->args)
|
|
|
|
goto out_err;
|
|
|
|
dst->nargs = src->nargs;
|
|
|
|
|
|
|
|
for (i = 0; i < src->nargs; i++)
|
|
|
|
if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
|
|
|
|
goto out_err;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
clear_perf_probe_event(dst);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
void clear_probe_trace_event(struct probe_trace_event *tev)
|
2010-03-17 06:06:12 +08:00
|
|
|
{
|
2010-07-29 22:13:51 +08:00
|
|
|
struct probe_trace_arg_ref *ref, *next;
|
2010-03-17 06:06:12 +08:00
|
|
|
int i;
|
|
|
|
|
2013-12-27 02:54:57 +08:00
|
|
|
free(tev->event);
|
|
|
|
free(tev->group);
|
|
|
|
free(tev->point.symbol);
|
2015-05-08 09:03:35 +08:00
|
|
|
free(tev->point.realname);
|
2013-12-27 02:54:57 +08:00
|
|
|
free(tev->point.module);
|
2010-03-17 06:06:12 +08:00
|
|
|
for (i = 0; i < tev->nargs; i++) {
|
2013-12-27 02:54:57 +08:00
|
|
|
free(tev->args[i].name);
|
|
|
|
free(tev->args[i].value);
|
|
|
|
free(tev->args[i].type);
|
2010-03-17 06:06:12 +08:00
|
|
|
ref = tev->args[i].ref;
|
|
|
|
while (ref) {
|
|
|
|
next = ref->next;
|
|
|
|
free(ref);
|
|
|
|
ref = next;
|
|
|
|
}
|
|
|
|
}
|
2013-12-27 02:54:57 +08:00
|
|
|
free(tev->args);
|
2010-03-17 06:06:12 +08:00
|
|
|
memset(tev, 0, sizeof(*tev));
|
2009-12-01 08:19:58 +08:00
|
|
|
}
|
|
|
|
|
2015-02-19 22:31:13 +08:00
|
|
|
struct kprobe_blacklist_node {
|
|
|
|
struct list_head list;
|
|
|
|
unsigned long start;
|
|
|
|
unsigned long end;
|
|
|
|
char *symbol;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void kprobe_blacklist__delete(struct list_head *blacklist)
|
|
|
|
{
|
|
|
|
struct kprobe_blacklist_node *node;
|
|
|
|
|
|
|
|
while (!list_empty(blacklist)) {
|
|
|
|
node = list_first_entry(blacklist,
|
|
|
|
struct kprobe_blacklist_node, list);
|
|
|
|
list_del(&node->list);
|
|
|
|
free(node->symbol);
|
|
|
|
free(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int kprobe_blacklist__load(struct list_head *blacklist)
|
|
|
|
{
|
|
|
|
struct kprobe_blacklist_node *node;
|
2015-09-02 15:56:43 +08:00
|
|
|
const char *__debugfs = debugfs__mountpoint();
|
2015-02-19 22:31:13 +08:00
|
|
|
char buf[PATH_MAX], *p;
|
|
|
|
FILE *fp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (__debugfs == NULL)
|
|
|
|
return -ENOTSUP;
|
|
|
|
|
|
|
|
ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
fp = fopen(buf, "r");
|
|
|
|
if (!fp)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
while (fgets(buf, PATH_MAX, fp)) {
|
|
|
|
node = zalloc(sizeof(*node));
|
|
|
|
if (!node) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
INIT_LIST_HEAD(&node->list);
|
|
|
|
list_add_tail(&node->list, blacklist);
|
|
|
|
if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p = strchr(buf, '\t');
|
|
|
|
if (p) {
|
|
|
|
p++;
|
|
|
|
if (p[strlen(p) - 1] == '\n')
|
|
|
|
p[strlen(p) - 1] = '\0';
|
|
|
|
} else
|
|
|
|
p = (char *)"unknown";
|
|
|
|
node->symbol = strdup(p);
|
|
|
|
if (!node->symbol) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
|
|
|
|
node->start, node->end, node->symbol);
|
|
|
|
ret++;
|
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
kprobe_blacklist__delete(blacklist);
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct kprobe_blacklist_node *
|
|
|
|
kprobe_blacklist__find_by_address(struct list_head *blacklist,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
struct kprobe_blacklist_node *node;
|
|
|
|
|
|
|
|
list_for_each_entry(node, blacklist, list) {
|
2017-08-29 20:57:23 +08:00
|
|
|
if (node->start <= address && address < node->end)
|
2015-02-19 22:31:13 +08:00
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-06-16 19:50:55 +08:00
|
|
|
static LIST_HEAD(kprobe_blacklist);
|
|
|
|
|
|
|
|
static void kprobe_blacklist__init(void)
|
|
|
|
{
|
|
|
|
if (!list_empty(&kprobe_blacklist))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
|
|
|
|
pr_debug("No kprobe blacklist support, ignored\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void kprobe_blacklist__release(void)
|
|
|
|
{
|
|
|
|
kprobe_blacklist__delete(&kprobe_blacklist);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool kprobe_blacklist__listed(unsigned long address)
|
|
|
|
{
|
|
|
|
return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
|
|
|
|
}
|
|
|
|
|
2015-06-16 19:50:57 +08:00
|
|
|
static int perf_probe_event__sprintf(const char *group, const char *event,
|
|
|
|
struct perf_probe_event *pev,
|
2015-06-13 09:31:16 +08:00
|
|
|
const char *module,
|
|
|
|
struct strbuf *result)
|
2009-12-09 06:02:40 +08:00
|
|
|
{
|
2016-05-10 13:47:07 +08:00
|
|
|
int i, ret;
|
2016-04-28 02:37:14 +08:00
|
|
|
char *buf;
|
2009-12-09 06:02:40 +08:00
|
|
|
|
2016-04-28 02:37:14 +08:00
|
|
|
if (asprintf(&buf, "%s:%s", group, event) < 0)
|
|
|
|
return -errno;
|
2016-05-10 13:47:07 +08:00
|
|
|
ret = strbuf_addf(result, " %-20s (on ", buf);
|
2016-04-28 02:37:14 +08:00
|
|
|
free(buf);
|
2016-05-10 13:47:07 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2016-04-28 02:37:14 +08:00
|
|
|
/* Synthesize only event probe point */
|
|
|
|
buf = synthesize_perf_probe_point(&pev->point);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
2016-05-10 13:47:07 +08:00
|
|
|
ret = strbuf_addstr(result, buf);
|
2016-04-28 02:37:14 +08:00
|
|
|
free(buf);
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
if (!ret && module)
|
|
|
|
ret = strbuf_addf(result, " in %s", module);
|
2009-12-09 06:02:40 +08:00
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
if (!ret && pev->nargs > 0) {
|
|
|
|
ret = strbuf_add(result, " with", 5);
|
|
|
|
for (i = 0; !ret && i < pev->nargs; i++) {
|
2016-04-28 02:37:14 +08:00
|
|
|
buf = synthesize_perf_probe_arg(&pev->args[i]);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
2016-05-10 13:47:07 +08:00
|
|
|
ret = strbuf_addf(result, " %s", buf);
|
2016-04-28 02:37:14 +08:00
|
|
|
free(buf);
|
2010-03-17 06:06:26 +08:00
|
|
|
}
|
2009-12-09 06:02:40 +08:00
|
|
|
}
|
2016-05-10 13:47:07 +08:00
|
|
|
if (!ret)
|
|
|
|
ret = strbuf_addch(result, ')');
|
2016-04-28 02:37:14 +08:00
|
|
|
|
2016-05-10 13:47:07 +08:00
|
|
|
return ret;
|
2009-12-09 06:02:40 +08:00
|
|
|
}
|
|
|
|
|
2015-06-13 09:31:16 +08:00
|
|
|
/* Show an event */
|
2015-09-04 20:16:01 +08:00
|
|
|
int show_perf_probe_event(const char *group, const char *event,
|
|
|
|
struct perf_probe_event *pev,
|
|
|
|
const char *module, bool use_stdout)
|
2015-06-13 09:31:16 +08:00
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret;
|
|
|
|
|
2015-06-16 19:50:57 +08:00
|
|
|
ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
|
2015-06-13 09:31:16 +08:00
|
|
|
if (ret >= 0) {
|
|
|
|
if (use_stdout)
|
|
|
|
printf("%s\n", buf.buf);
|
|
|
|
else
|
|
|
|
pr_info("%s\n", buf.buf);
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-24 17:47:50 +08:00
|
|
|
static bool filter_probe_trace_event(struct probe_trace_event *tev,
|
|
|
|
struct strfilter *filter)
|
|
|
|
{
|
|
|
|
char tmp[128];
|
|
|
|
|
|
|
|
/* At first, check the event name itself */
|
|
|
|
if (strfilter__compare(filter, tev->event))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Next, check the combination of name and group */
|
|
|
|
if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
|
|
|
|
return false;
|
|
|
|
return strfilter__compare(filter, tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __show_perf_probe_events(int fd, bool is_kprobe,
|
|
|
|
struct strfilter *filter)
|
2009-12-01 08:20:17 +08:00
|
|
|
{
|
2012-04-16 20:09:09 +08:00
|
|
|
int ret = 0;
|
2010-07-29 22:13:51 +08:00
|
|
|
struct probe_trace_event tev;
|
2010-03-17 06:06:12 +08:00
|
|
|
struct perf_probe_event pev;
|
2009-12-01 08:20:17 +08:00
|
|
|
struct strlist *rawlist;
|
|
|
|
struct str_node *ent;
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
memset(&tev, 0, sizeof(tev));
|
|
|
|
memset(&pev, 0, sizeof(pev));
|
2010-01-06 06:47:10 +08:00
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
rawlist = probe_file__get_rawlist(fd);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (!rawlist)
|
2014-08-14 10:22:30 +08:00
|
|
|
return -ENOMEM;
|
2009-12-01 08:20:17 +08:00
|
|
|
|
2016-06-23 22:31:20 +08:00
|
|
|
strlist__for_each_entry(ent, rawlist) {
|
2010-07-29 22:13:51 +08:00
|
|
|
ret = parse_probe_trace_command(ent->s, &tev);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret >= 0) {
|
2015-04-24 17:47:50 +08:00
|
|
|
if (!filter_probe_trace_event(&tev, filter))
|
|
|
|
goto next;
|
2012-04-16 20:09:09 +08:00
|
|
|
ret = convert_to_perf_probe_event(&tev, &pev,
|
|
|
|
is_kprobe);
|
2015-06-13 09:31:16 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto next;
|
2015-06-16 19:50:57 +08:00
|
|
|
ret = show_perf_probe_event(pev.group, pev.event,
|
|
|
|
&pev, tev.point.module,
|
2015-06-13 09:31:16 +08:00
|
|
|
true);
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2015-04-24 17:47:50 +08:00
|
|
|
next:
|
2010-03-17 06:06:12 +08:00
|
|
|
clear_perf_probe_event(&pev);
|
2010-07-29 22:13:51 +08:00
|
|
|
clear_probe_trace_event(&tev);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
|
|
|
strlist__delete(rawlist);
|
2015-06-17 22:58:54 +08:00
|
|
|
/* Cleanup cached debuginfo if needed */
|
|
|
|
debuginfo_cache__exit();
|
2010-04-13 01:17:42 +08:00
|
|
|
|
|
|
|
return ret;
|
2009-12-01 08:20:17 +08:00
|
|
|
}
|
|
|
|
|
2012-04-16 20:09:09 +08:00
|
|
|
/* List up current perf-probe events */
|
2015-04-24 17:47:50 +08:00
|
|
|
int show_perf_probe_events(struct strfilter *filter)
|
2012-04-16 20:09:09 +08:00
|
|
|
{
|
2014-08-14 00:12:48 +08:00
|
|
|
int kp_fd, up_fd, ret;
|
2012-04-16 20:09:09 +08:00
|
|
|
|
|
|
|
setup_pager();
|
|
|
|
|
2016-07-01 16:03:26 +08:00
|
|
|
if (probe_conf.cache)
|
|
|
|
return probe_cache__show_all_caches(filter);
|
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
ret = init_probe_symbol_maps(false);
|
2012-04-16 20:09:09 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
ret = probe_file__open_both(&kp_fd, &up_fd, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
if (kp_fd >= 0)
|
|
|
|
ret = __show_perf_probe_events(kp_fd, true, filter);
|
|
|
|
if (up_fd >= 0 && ret >= 0)
|
2015-04-24 17:47:50 +08:00
|
|
|
ret = __show_perf_probe_events(up_fd, false, filter);
|
2015-07-15 17:14:07 +08:00
|
|
|
if (kp_fd > 0)
|
|
|
|
close(kp_fd);
|
|
|
|
if (up_fd > 0)
|
2014-08-14 00:12:48 +08:00
|
|
|
close(up_fd);
|
2015-09-10 10:27:05 +08:00
|
|
|
exit_probe_symbol_maps();
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2009-12-01 08:19:58 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
static int get_new_event_name(char *buf, size_t len, const char *base,
|
2017-12-09 00:27:44 +08:00
|
|
|
struct strlist *namelist, bool ret_event,
|
|
|
|
bool allow_suffix)
|
2009-12-01 08:20:25 +08:00
|
|
|
{
|
|
|
|
int i, ret;
|
2015-10-01 00:41:30 +08:00
|
|
|
char *p, *nbase;
|
2009-12-09 06:03:02 +08:00
|
|
|
|
2015-04-28 20:05:34 +08:00
|
|
|
if (*base == '.')
|
|
|
|
base++;
|
2015-10-01 00:41:30 +08:00
|
|
|
nbase = strdup(base);
|
|
|
|
if (!nbase)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-12-12 02:19:25 +08:00
|
|
|
/* Cut off the dot suffixes (e.g. .const, .isra) and version suffixes */
|
|
|
|
p = strpbrk(nbase, ".@");
|
2015-10-01 00:41:30 +08:00
|
|
|
if (p && p != nbase)
|
|
|
|
*p = '\0';
|
2015-04-28 20:05:34 +08:00
|
|
|
|
2015-10-01 00:41:30 +08:00
|
|
|
/* Try no suffix number */
|
2017-12-09 00:27:44 +08:00
|
|
|
ret = e_snprintf(buf, len, "%s%s", nbase, ret_event ? "__return" : "");
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0) {
|
2014-08-14 10:22:34 +08:00
|
|
|
pr_debug("snprintf() failed: %d\n", ret);
|
2015-10-01 00:41:30 +08:00
|
|
|
goto out;
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2009-12-09 06:03:02 +08:00
|
|
|
if (!strlist__has_entry(namelist, buf))
|
2015-10-01 00:41:30 +08:00
|
|
|
goto out;
|
2009-12-09 06:03:02 +08:00
|
|
|
|
2009-12-15 23:32:25 +08:00
|
|
|
if (!allow_suffix) {
|
2015-11-16 20:10:08 +08:00
|
|
|
pr_warning("Error: event \"%s\" already exists.\n"
|
|
|
|
" Hint: Remove existing event by 'perf probe -d'\n"
|
|
|
|
" or force duplicates by 'perf probe -f'\n"
|
|
|
|
" or set 'force=yes' in BPF source.\n",
|
|
|
|
buf);
|
2015-10-01 00:41:30 +08:00
|
|
|
ret = -EEXIST;
|
|
|
|
goto out;
|
2009-12-15 23:32:25 +08:00
|
|
|
}
|
|
|
|
|
2009-12-09 06:03:02 +08:00
|
|
|
/* Try to add suffix */
|
|
|
|
for (i = 1; i < MAX_EVENT_INDEX; i++) {
|
2015-10-01 00:41:30 +08:00
|
|
|
ret = e_snprintf(buf, len, "%s_%d", nbase, i);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0) {
|
2014-08-14 10:22:34 +08:00
|
|
|
pr_debug("snprintf() failed: %d\n", ret);
|
2015-10-01 00:41:30 +08:00
|
|
|
goto out;
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2009-12-01 08:20:25 +08:00
|
|
|
if (!strlist__has_entry(namelist, buf))
|
|
|
|
break;
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
if (i == MAX_EVENT_INDEX) {
|
|
|
|
pr_warning("Too many events are on the same function.\n");
|
|
|
|
ret = -ERANGE;
|
|
|
|
}
|
|
|
|
|
2015-10-01 00:41:30 +08:00
|
|
|
out:
|
|
|
|
free(nbase);
|
2017-12-09 00:26:46 +08:00
|
|
|
|
|
|
|
/* Final validation */
|
|
|
|
if (ret >= 0 && !is_c_func_name(buf)) {
|
|
|
|
pr_warning("Internal error: \"%s\" is an invalid event name.\n",
|
|
|
|
buf);
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2009-12-01 08:20:25 +08:00
|
|
|
}
|
|
|
|
|
2015-02-28 10:53:29 +08:00
|
|
|
/* Warn if the current kernel's uprobe implementation is old */
|
|
|
|
static void warn_uprobe_event_compat(struct probe_trace_event *tev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *buf = synthesize_probe_trace_command(tev);
|
2018-08-20 12:42:50 +08:00
|
|
|
struct probe_trace_point *tp = &tev->point;
|
|
|
|
|
|
|
|
if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) {
|
|
|
|
pr_warning("A semaphore is associated with %s:%s and "
|
|
|
|
"seems your kernel doesn't support it.\n",
|
|
|
|
tev->group, tev->event);
|
|
|
|
}
|
2015-02-28 10:53:29 +08:00
|
|
|
|
|
|
|
/* Old uprobe event doesn't support memory dereference */
|
|
|
|
if (!tev->uprobes || tev->nargs == 0 || !buf)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (i = 0; i < tev->nargs; i++)
|
|
|
|
if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
|
|
|
|
pr_warning("Please upgrade your kernel to at least "
|
|
|
|
"3.14 to have access to feature %s\n",
|
|
|
|
tev->args[i].value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
2015-07-15 17:14:00 +08:00
|
|
|
/* Set new name from original perf_probe_event and namelist */
|
|
|
|
static int probe_trace_event__set_name(struct probe_trace_event *tev,
|
|
|
|
struct perf_probe_event *pev,
|
|
|
|
struct strlist *namelist,
|
|
|
|
bool allow_suffix)
|
|
|
|
{
|
|
|
|
const char *event, *group;
|
|
|
|
char buf[64];
|
|
|
|
int ret;
|
|
|
|
|
2016-07-01 16:03:12 +08:00
|
|
|
/* If probe_event or trace_event already have the name, reuse it */
|
2016-07-12 18:05:18 +08:00
|
|
|
if (pev->event && !pev->sdt)
|
2015-07-15 17:14:00 +08:00
|
|
|
event = pev->event;
|
2016-07-01 16:03:12 +08:00
|
|
|
else if (tev->event)
|
|
|
|
event = tev->event;
|
|
|
|
else {
|
|
|
|
/* Or generate new one from probe point */
|
2015-08-26 18:57:45 +08:00
|
|
|
if (pev->point.function &&
|
|
|
|
(strncmp(pev->point.function, "0x", 2) != 0) &&
|
|
|
|
!strisglob(pev->point.function))
|
2015-07-15 17:14:00 +08:00
|
|
|
event = pev->point.function;
|
|
|
|
else
|
|
|
|
event = tev->point.realname;
|
2016-07-01 16:03:12 +08:00
|
|
|
}
|
2016-07-12 18:05:18 +08:00
|
|
|
if (pev->group && !pev->sdt)
|
2015-07-15 17:14:00 +08:00
|
|
|
group = pev->group;
|
2016-07-01 16:03:12 +08:00
|
|
|
else if (tev->group)
|
|
|
|
group = tev->group;
|
2015-07-15 17:14:00 +08:00
|
|
|
else
|
|
|
|
group = PERFPROBE_GROUP;
|
|
|
|
|
|
|
|
/* Get an unused new event name */
|
2017-12-09 00:27:44 +08:00
|
|
|
ret = get_new_event_name(buf, 64, event, namelist,
|
|
|
|
tev->point.retprobe, allow_suffix);
|
2015-07-15 17:14:00 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
event = buf;
|
|
|
|
|
|
|
|
tev->event = strdup(event);
|
|
|
|
tev->group = strdup(group);
|
|
|
|
if (tev->event == NULL || tev->group == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Add added event name to namelist */
|
|
|
|
strlist__add(namelist, event);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-12 18:05:28 +08:00
|
|
|
static int __open_probe_file_and_namelist(bool uprobe,
|
|
|
|
struct strlist **namelist)
|
2009-12-01 08:19:58 +08:00
|
|
|
{
|
2016-07-12 18:05:28 +08:00
|
|
|
int fd;
|
2009-12-01 08:19:58 +08:00
|
|
|
|
2016-07-12 18:05:28 +08:00
|
|
|
fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
|
2015-07-15 17:14:07 +08:00
|
|
|
if (fd < 0)
|
2010-04-13 01:17:42 +08:00
|
|
|
return fd;
|
2014-08-14 00:12:48 +08:00
|
|
|
|
2009-12-01 08:20:25 +08:00
|
|
|
/* Get current event names */
|
2016-07-12 18:05:28 +08:00
|
|
|
*namelist = probe_file__get_namelist(fd);
|
|
|
|
if (!(*namelist)) {
|
2010-04-13 01:17:42 +08:00
|
|
|
pr_debug("Failed to get current event list.\n");
|
2016-07-12 18:05:28 +08:00
|
|
|
close(fd);
|
|
|
|
return -ENOMEM;
|
2010-04-13 01:17:42 +08:00
|
|
|
}
|
2016-07-12 18:05:28 +08:00
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __add_probe_trace_events(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event *tevs,
|
|
|
|
int ntevs, bool allow_suffix)
|
|
|
|
{
|
|
|
|
int i, fd[2] = {-1, -1}, up, ret;
|
|
|
|
struct probe_trace_event *tev = NULL;
|
|
|
|
struct probe_cache *cache = NULL;
|
|
|
|
struct strlist *namelist[2] = {NULL, NULL};
|
2017-07-06 09:48:10 +08:00
|
|
|
struct nscookie nsc;
|
2016-07-12 18:05:28 +08:00
|
|
|
|
|
|
|
up = pev->uprobes ? 1 : 0;
|
|
|
|
fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
|
|
|
|
if (fd[up] < 0)
|
|
|
|
return fd[up];
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2010-04-13 01:17:42 +08:00
|
|
|
ret = 0;
|
2010-04-13 01:17:56 +08:00
|
|
|
for (i = 0; i < ntevs; i++) {
|
2010-03-17 06:06:12 +08:00
|
|
|
tev = &tevs[i];
|
2016-07-12 18:05:28 +08:00
|
|
|
up = tev->uprobes ? 1 : 0;
|
|
|
|
if (fd[up] == -1) { /* Open the kprobe/uprobe_events */
|
|
|
|
fd[up] = __open_probe_file_and_namelist(up,
|
|
|
|
&namelist[up]);
|
|
|
|
if (fd[up] < 0)
|
|
|
|
goto close_out;
|
|
|
|
}
|
2015-06-16 19:50:55 +08:00
|
|
|
/* Skip if the symbol is out of .text or blacklisted */
|
2016-07-01 16:03:12 +08:00
|
|
|
if (!tev->point.symbol && !pev->uprobes)
|
2015-05-06 20:46:49 +08:00
|
|
|
continue;
|
2015-02-19 22:31:13 +08:00
|
|
|
|
2015-07-15 17:14:00 +08:00
|
|
|
/* Set new name for tev (and update namelist) */
|
2016-07-12 18:05:28 +08:00
|
|
|
ret = probe_trace_event__set_name(tev, pev, namelist[up],
|
2015-07-15 17:14:00 +08:00
|
|
|
allow_suffix);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_enter(pev->nsi, &nsc);
|
2016-07-12 18:05:28 +08:00
|
|
|
ret = probe_file__add_event(fd[up], tev);
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__mountns_exit(&nsc);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-12-01 08:19:58 +08:00
|
|
|
}
|
2015-02-28 10:53:29 +08:00
|
|
|
if (ret == -EINVAL && pev->uprobes)
|
|
|
|
warn_uprobe_event_compat(tev);
|
2016-06-15 11:28:40 +08:00
|
|
|
if (ret == 0 && probe_conf.cache) {
|
2017-07-06 09:48:11 +08:00
|
|
|
cache = probe_cache__new(pev->target, pev->nsi);
|
2016-06-15 11:28:40 +08:00
|
|
|
if (!cache ||
|
|
|
|
probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
|
|
|
|
probe_cache__commit(cache) < 0)
|
|
|
|
pr_warning("Failed to add event to probe cache\n");
|
|
|
|
probe_cache__delete(cache);
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2015-05-06 20:46:40 +08:00
|
|
|
close_out:
|
2016-07-12 18:05:28 +08:00
|
|
|
for (up = 0; up < 2; up++) {
|
|
|
|
strlist__delete(namelist[up]);
|
|
|
|
if (fd[up] >= 0)
|
|
|
|
close(fd[up]);
|
|
|
|
}
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2009-12-01 08:19:58 +08:00
|
|
|
}
|
2009-12-09 06:03:23 +08:00
|
|
|
|
2015-05-29 17:45:47 +08:00
|
|
|
static int find_probe_functions(struct map *map, char *name,
|
|
|
|
struct symbol **syms)
|
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-06 13:32:25 +08:00
|
|
|
{
|
2015-01-14 19:18:07 +08:00
|
|
|
int found = 0;
|
2015-01-17 03:40:25 +08:00
|
|
|
struct symbol *sym;
|
2015-05-08 09:03:35 +08:00
|
|
|
struct rb_node *tmp;
|
2017-12-09 00:28:12 +08:00
|
|
|
const char *norm, *ver;
|
|
|
|
char *buf = NULL;
|
2017-12-12 23:05:12 +08:00
|
|
|
bool cut_version = true;
|
2015-01-14 19:18:07 +08:00
|
|
|
|
2016-09-02 06:25:52 +08:00
|
|
|
if (map__load(map) < 0)
|
2015-05-15 20:14:44 +08:00
|
|
|
return 0;
|
|
|
|
|
2017-12-12 23:05:12 +08:00
|
|
|
/* If user gives a version, don't cut off the version from symbols */
|
|
|
|
if (strchr(name, '@'))
|
|
|
|
cut_version = false;
|
|
|
|
|
2015-05-08 09:03:35 +08:00
|
|
|
map__for_each_symbol(map, sym, tmp) {
|
2017-12-09 00:28:12 +08:00
|
|
|
norm = arch__normalize_symbol_name(sym->name);
|
|
|
|
if (!norm)
|
|
|
|
continue;
|
|
|
|
|
2017-12-12 23:05:12 +08:00
|
|
|
if (cut_version) {
|
|
|
|
/* We don't care about default symbol or not */
|
|
|
|
ver = strchr(norm, '@');
|
|
|
|
if (ver) {
|
|
|
|
buf = strndup(norm, ver - norm);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
norm = buf;
|
|
|
|
}
|
2017-12-09 00:28:12 +08:00
|
|
|
}
|
2017-12-12 23:05:12 +08:00
|
|
|
|
2017-12-09 00:28:12 +08:00
|
|
|
if (strglobmatch(norm, name)) {
|
2015-05-08 09:03:35 +08:00
|
|
|
found++;
|
2015-05-29 17:45:47 +08:00
|
|
|
if (syms && found < probe_conf.max_probes)
|
|
|
|
syms[found - 1] = sym;
|
|
|
|
}
|
2017-12-09 00:28:12 +08:00
|
|
|
if (buf)
|
|
|
|
zfree(&buf);
|
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-06 13:32:25 +08:00
|
|
|
}
|
2015-01-14 19:18:07 +08:00
|
|
|
|
|
|
|
return found;
|
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-06 13:32:25 +08:00
|
|
|
}
|
|
|
|
|
2015-04-28 20:05:40 +08:00
|
|
|
void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
|
|
|
|
struct probe_trace_event *tev __maybe_unused,
|
2016-04-12 17:10:50 +08:00
|
|
|
struct map *map __maybe_unused,
|
|
|
|
struct symbol *sym __maybe_unused) { }
|
2015-04-28 20:05:40 +08: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-06 13:32:25 +08:00
|
|
|
/*
|
|
|
|
* 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,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct probe_trace_event **tevs)
|
2010-03-17 06:05:37 +08: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-06 13:32:25 +08:00
|
|
|
struct map *map = NULL;
|
|
|
|
struct ref_reloc_sym *reloc_sym = NULL;
|
2010-03-17 06:05:37 +08:00
|
|
|
struct symbol *sym;
|
2015-05-29 17:45:47 +08:00
|
|
|
struct symbol **syms = NULL;
|
2010-07-29 22:13:51 +08: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-06 13:32:25 +08:00
|
|
|
struct perf_probe_point *pp = &pev->point;
|
|
|
|
struct probe_trace_point *tp;
|
2015-01-14 19:18:07 +08:00
|
|
|
int num_matched_functions;
|
2015-06-16 19:50:55 +08:00
|
|
|
int ret, i, j, skipped = 0;
|
2016-04-26 22:25:40 +08:00
|
|
|
char *mod_name;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
map = get_target_map(pev->target, pev->nsi, pev->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-06 13:32:25 +08:00
|
|
|
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-26 13:41:53 +08:00
|
|
|
}
|
|
|
|
|
2015-05-29 17:45:47 +08:00
|
|
|
syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
|
|
|
|
if (!syms) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
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-06 13:32:25 +08:00
|
|
|
/*
|
|
|
|
* Load matched symbols: Since the different local symbols may have
|
|
|
|
* same name but different addresses, this lists all the symbols.
|
|
|
|
*/
|
2015-05-29 17:45:47 +08:00
|
|
|
num_matched_functions = find_probe_functions(map, pp->function, syms);
|
2017-12-09 00:28:12 +08:00
|
|
|
if (num_matched_functions <= 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-06 13:32:25 +08:00
|
|
|
pr_err("Failed to find symbol %s in %s\n", pp->function,
|
2015-05-08 09:03:28 +08:00
|
|
|
pev->target ? : "kernel");
|
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-06 13:32:25 +08:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
2015-05-08 09:03:31 +08:00
|
|
|
} else if (num_matched_functions > probe_conf.max_probes) {
|
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-06 13:32:25 +08:00
|
|
|
pr_err("Too many functions matched in %s\n",
|
2015-05-08 09:03:28 +08:00
|
|
|
pev->target ? : "kernel");
|
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-06 13:32:25 +08:00
|
|
|
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-26 13:41:53 +08:00
|
|
|
}
|
|
|
|
|
2015-10-02 20:58:32 +08:00
|
|
|
/* Note that the symbols in the kmodule are not relocated */
|
2017-03-08 16:26:09 +08:00
|
|
|
if (!pev->uprobes && !pev->target &&
|
|
|
|
(!pp->retprobe || kretprobe_offset_is_supported())) {
|
2015-03-20 09:56:56 +08:00
|
|
|
reloc_sym = kernel_get_ref_reloc_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-06 13:32:25 +08:00
|
|
|
if (!reloc_sym) {
|
|
|
|
pr_warning("Relocated base symbol is not found!\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2010-03-17 06:06:12 +08: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-06 13:32:25 +08:00
|
|
|
/* Setup result trace-probe-events */
|
|
|
|
*tevs = zalloc(sizeof(*tev) * num_matched_functions);
|
|
|
|
if (!*tevs) {
|
2010-04-13 01:17:56 +08: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-06 13:32:25 +08:00
|
|
|
goto out;
|
2010-04-13 01:17:56 +08:00
|
|
|
}
|
2011-07-25 22:08:08 +08: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-06 13:32:25 +08:00
|
|
|
ret = 0;
|
2015-01-14 19:18:07 +08:00
|
|
|
|
2015-05-29 17:45:47 +08:00
|
|
|
for (j = 0; j < num_matched_functions; j++) {
|
|
|
|
sym = syms[j];
|
|
|
|
|
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-06 13:32:25 +08:00
|
|
|
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 22:08:08 +08: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-06 13:32:25 +08:00
|
|
|
ret++;
|
2011-07-25 22:08:08 +08: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-06 13:32:25 +08: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;
|
2015-10-02 20:58:32 +08:00
|
|
|
|
|
|
|
/* Check the kprobe (not in module) is within .text */
|
|
|
|
if (!pev->uprobes && !pev->target &&
|
2015-06-16 19:50:55 +08:00
|
|
|
kprobe_warn_out_range(sym->name, tp->address)) {
|
|
|
|
tp->symbol = NULL; /* Skip it */
|
|
|
|
skipped++;
|
|
|
|
} else if (reloc_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-06 13:32:25 +08:00
|
|
|
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;
|
|
|
|
}
|
2015-05-29 17:45:47 +08:00
|
|
|
tp->realname = strdup_or_goto(sym->name, nomem_out);
|
|
|
|
|
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-06 13:32:25 +08:00
|
|
|
tp->retprobe = pp->retprobe;
|
2016-04-26 22:25:40 +08:00
|
|
|
if (pev->target) {
|
|
|
|
if (pev->uprobes) {
|
|
|
|
tev->point.module = strdup_or_goto(pev->target,
|
|
|
|
nomem_out);
|
|
|
|
} else {
|
|
|
|
mod_name = find_module_name(pev->target);
|
|
|
|
tev->point.module =
|
|
|
|
strdup(mod_name ? mod_name : pev->target);
|
|
|
|
free(mod_name);
|
|
|
|
if (!tev->point.module)
|
|
|
|
goto nomem_out;
|
|
|
|
}
|
|
|
|
}
|
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-06 13:32:25 +08:00
|
|
|
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-13 01:17:49 +08:00
|
|
|
}
|
2010-04-13 01:16:53 +08: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-06 13:32:25 +08: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-13 01:16:53 +08:00
|
|
|
}
|
2016-04-12 17:10:50 +08:00
|
|
|
arch__fix_tev_from_maps(pev, tev, map, sym);
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
2015-06-16 19:50:55 +08:00
|
|
|
if (ret == skipped) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto err_out;
|
|
|
|
}
|
2010-03-17 06:06:12 +08: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-06 13:32:25 +08:00
|
|
|
out:
|
2017-01-04 11:29:05 +08:00
|
|
|
map__put(map);
|
2015-05-29 17:45:47 +08:00
|
|
|
free(syms);
|
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-06 13:32:25 +08:00
|
|
|
return ret;
|
2012-04-16 20:09:09 +08: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-06 13:32:25 +08:00
|
|
|
nomem_out:
|
|
|
|
ret = -ENOMEM;
|
|
|
|
err_out:
|
|
|
|
clear_probe_trace_events(*tevs, num_matched_functions);
|
|
|
|
zfree(tevs);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-02-28 12:13:01 +08:00
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
static int try_to_find_absolute_address(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs)
|
|
|
|
{
|
|
|
|
struct perf_probe_point *pp = &pev->point;
|
|
|
|
struct probe_trace_event *tev;
|
|
|
|
struct probe_trace_point *tp;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
|
|
|
|
return -EINVAL;
|
|
|
|
if (perf_probe_event_need_dwarf(pev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
|
|
|
|
* absolute address.
|
|
|
|
*
|
|
|
|
* Only one tev can be generated by this.
|
|
|
|
*/
|
|
|
|
*tevs = zalloc(sizeof(*tev));
|
|
|
|
if (!*tevs)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
tev = *tevs;
|
|
|
|
tp = &tev->point;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't use tp->offset, use address directly, because
|
|
|
|
* in synthesize_probe_trace_command() address cannot be
|
|
|
|
* zero.
|
|
|
|
*/
|
|
|
|
tp->address = pev->point.abs_address;
|
|
|
|
tp->retprobe = pp->retprobe;
|
|
|
|
tev->uprobes = pev->uprobes;
|
|
|
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
/*
|
|
|
|
* Give it a '0x' leading symbol name.
|
|
|
|
* In __add_probe_trace_events, a NULL symbol is interpreted as
|
2018-12-03 18:22:00 +08:00
|
|
|
* invalid.
|
2015-08-26 18:57:45 +08:00
|
|
|
*/
|
|
|
|
if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
/* For kprobe, check range */
|
|
|
|
if ((!tev->uprobes) &&
|
|
|
|
(kprobe_warn_out_range(tev->point.symbol,
|
|
|
|
tev->point.address))) {
|
|
|
|
err = -EACCES;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
if (pev->target) {
|
|
|
|
tp->module = strdup(pev->target);
|
|
|
|
if (!tp->module)
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tev->group) {
|
|
|
|
tev->group = strdup(pev->group);
|
|
|
|
if (!tev->group)
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pev->event) {
|
|
|
|
tev->event = strdup(pev->event);
|
|
|
|
if (!tev->event)
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
tev->nargs = pev->nargs;
|
|
|
|
tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
|
2017-01-23 22:10:19 +08:00
|
|
|
if (!tev->args)
|
2015-08-26 18:57:45 +08:00
|
|
|
goto errout;
|
2017-01-23 22:10:19 +08:00
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
for (i = 0; i < tev->nargs; i++)
|
|
|
|
copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
errout:
|
2017-01-23 21:54:26 +08:00
|
|
|
clear_probe_trace_events(*tevs, 1);
|
|
|
|
*tevs = NULL;
|
2015-08-26 18:57:45 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-07-12 18:05:18 +08:00
|
|
|
/* Concatinate two arrays */
|
|
|
|
static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
|
|
|
|
{
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
ret = malloc(sz_a + sz_b);
|
|
|
|
if (ret) {
|
|
|
|
memcpy(ret, a, sz_a);
|
|
|
|
memcpy(ret + sz_a, b, sz_b);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
|
|
|
|
struct probe_trace_event **tevs2, int ntevs2)
|
|
|
|
{
|
|
|
|
struct probe_trace_event *new_tevs;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-03-08 14:59:07 +08:00
|
|
|
if (*ntevs == 0) {
|
2016-07-12 18:05:18 +08:00
|
|
|
*tevs = *tevs2;
|
|
|
|
*ntevs = ntevs2;
|
|
|
|
*tevs2 = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*ntevs + ntevs2 > probe_conf.max_probes)
|
|
|
|
ret = -E2BIG;
|
|
|
|
else {
|
|
|
|
/* Concatinate the array of probe_trace_event */
|
|
|
|
new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
|
|
|
|
*tevs2, ntevs2 * sizeof(**tevs2));
|
|
|
|
if (!new_tevs)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
else {
|
|
|
|
free(*tevs);
|
|
|
|
*tevs = new_tevs;
|
|
|
|
*ntevs += ntevs2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
clear_probe_trace_events(*tevs2, ntevs2);
|
|
|
|
zfree(tevs2);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to find probe_trace_event from given probe caches. Return the number
|
|
|
|
* of cached events found, if an error occurs return the error.
|
|
|
|
*/
|
|
|
|
static int find_cached_events(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs,
|
|
|
|
const char *target)
|
|
|
|
{
|
|
|
|
struct probe_cache *cache;
|
|
|
|
struct probe_cache_entry *entry;
|
|
|
|
struct probe_trace_event *tmp_tevs = NULL;
|
|
|
|
int ntevs = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-07-06 09:48:11 +08:00
|
|
|
cache = probe_cache__new(target, pev->nsi);
|
2016-07-12 18:05:18 +08:00
|
|
|
/* Return 0 ("not found") if the target has no probe cache. */
|
|
|
|
if (!cache)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for_each_probe_cache_entry(entry, cache) {
|
|
|
|
/* Skip the cache entry which has no name */
|
|
|
|
if (!entry->pev.event || !entry->pev.group)
|
|
|
|
continue;
|
|
|
|
if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
|
|
|
|
strglobmatch(entry->pev.event, pev->event)) {
|
|
|
|
ret = probe_cache_entry__get_event(entry, &tmp_tevs);
|
|
|
|
if (ret > 0)
|
|
|
|
ret = concat_probe_trace_events(tevs, &ntevs,
|
|
|
|
&tmp_tevs, ret);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
probe_cache__delete(cache);
|
|
|
|
if (ret < 0) {
|
|
|
|
clear_probe_trace_events(*tevs, ntevs);
|
|
|
|
zfree(tevs);
|
|
|
|
} else {
|
|
|
|
ret = ntevs;
|
|
|
|
if (ntevs > 0 && target && target[0] == '/')
|
|
|
|
pev->uprobes = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-12 18:05:28 +08:00
|
|
|
/* Try to find probe_trace_event from all probe caches */
|
|
|
|
static int find_cached_events_all(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs)
|
|
|
|
{
|
|
|
|
struct probe_trace_event *tmp_tevs = NULL;
|
|
|
|
struct strlist *bidlist;
|
|
|
|
struct str_node *nd;
|
|
|
|
char *pathname;
|
|
|
|
int ntevs = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Get the buildid list of all valid caches */
|
|
|
|
bidlist = build_id_cache__list_all(true);
|
|
|
|
if (!bidlist) {
|
|
|
|
ret = -errno;
|
|
|
|
pr_debug("Failed to get buildids: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
strlist__for_each_entry(nd, bidlist) {
|
|
|
|
pathname = build_id_cache__origname(nd->s);
|
|
|
|
ret = find_cached_events(pev, &tmp_tevs, pathname);
|
|
|
|
/* In the case of cnt == 0, we just skip it */
|
|
|
|
if (ret > 0)
|
|
|
|
ret = concat_probe_trace_events(tevs, &ntevs,
|
|
|
|
&tmp_tevs, ret);
|
|
|
|
free(pathname);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strlist__delete(bidlist);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
clear_probe_trace_events(*tevs, ntevs);
|
|
|
|
zfree(tevs);
|
|
|
|
} else
|
|
|
|
ret = ntevs;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-01 16:03:12 +08:00
|
|
|
static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
|
|
|
|
struct probe_trace_event **tevs)
|
|
|
|
{
|
|
|
|
struct probe_cache *cache;
|
|
|
|
struct probe_cache_entry *entry;
|
|
|
|
struct probe_trace_event *tev;
|
|
|
|
struct str_node *node;
|
|
|
|
int ret, i;
|
|
|
|
|
2016-07-12 18:05:28 +08:00
|
|
|
if (pev->sdt) {
|
2016-07-12 18:05:18 +08:00
|
|
|
/* For SDT/cached events, we use special search functions */
|
2016-07-12 18:05:28 +08:00
|
|
|
if (!pev->target)
|
|
|
|
return find_cached_events_all(pev, tevs);
|
|
|
|
else
|
|
|
|
return find_cached_events(pev, tevs, pev->target);
|
|
|
|
}
|
2017-07-06 09:48:11 +08:00
|
|
|
cache = probe_cache__new(pev->target, pev->nsi);
|
2016-07-01 16:03:12 +08:00
|
|
|
if (!cache)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
entry = probe_cache__find(cache, pev);
|
|
|
|
if (!entry) {
|
2016-07-12 18:04:43 +08:00
|
|
|
/* SDT must be in the cache */
|
|
|
|
ret = pev->sdt ? -ENOENT : 0;
|
2016-07-01 16:03:12 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = strlist__nr_entries(entry->tevlist);
|
|
|
|
if (ret > probe_conf.max_probes) {
|
|
|
|
pr_debug("Too many entries matched in the cache of %s\n",
|
|
|
|
pev->target ? : "kernel");
|
|
|
|
ret = -E2BIG;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tevs = zalloc(ret * sizeof(*tev));
|
|
|
|
if (!*tevs) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
strlist__for_each_entry(node, entry->tevlist) {
|
|
|
|
tev = &(*tevs)[i++];
|
|
|
|
ret = parse_probe_trace_command(node->s, tev);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
/* Set the uprobes attribute as same as original */
|
|
|
|
tev->uprobes = pev->uprobes;
|
|
|
|
}
|
|
|
|
ret = i;
|
|
|
|
|
|
|
|
out:
|
|
|
|
probe_cache__delete(cache);
|
|
|
|
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-06 13:32:25 +08:00
|
|
|
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
|
2015-05-08 09:03:31 +08:00
|
|
|
struct probe_trace_event **tevs)
|
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-06 13:32:25 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2016-07-12 18:04:43 +08:00
|
|
|
if (!pev->group && !pev->sdt) {
|
2016-04-26 17:04:13 +08:00
|
|
|
/* Set group name if not given */
|
|
|
|
if (!pev->uprobes) {
|
|
|
|
pev->group = strdup(PERFPROBE_GROUP);
|
|
|
|
ret = pev->group ? 0 : -ENOMEM;
|
|
|
|
} else
|
|
|
|
ret = convert_exec_to_group(pev->target, &pev->group);
|
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-06 13:32:25 +08:00
|
|
|
if (ret != 0) {
|
|
|
|
pr_warning("Failed to make a group name.\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2010-04-13 01:17:56 +08:00
|
|
|
}
|
2010-04-13 01:17:49 +08:00
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
ret = try_to_find_absolute_address(pev, tevs);
|
|
|
|
if (ret > 0)
|
|
|
|
return ret;
|
|
|
|
|
2016-07-01 16:03:12 +08:00
|
|
|
/* At first, we need to lookup cache entry */
|
|
|
|
ret = find_probe_trace_events_from_cache(pev, tevs);
|
2016-07-12 18:04:43 +08:00
|
|
|
if (ret > 0 || pev->sdt) /* SDT can be found only in the cache */
|
|
|
|
return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
|
2016-07-01 16:03:12 +08: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-06 13:32:25 +08:00
|
|
|
/* Convert perf_probe_event with debuginfo */
|
2015-05-08 09:03:31 +08:00
|
|
|
ret = try_to_find_probe_trace_events(pev, tevs);
|
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-06 13:32:25 +08:00
|
|
|
if (ret != 0)
|
|
|
|
return ret; /* Found in debuginfo or got an error */
|
|
|
|
|
2015-05-08 09:03:31 +08:00
|
|
|
return find_probe_trace_events_from_map(pev, tevs);
|
2010-03-17 06:06:12 +08:00
|
|
|
}
|
|
|
|
|
2015-09-04 20:16:00 +08:00
|
|
|
int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
|
2010-03-17 06:06:12 +08:00
|
|
|
{
|
2015-09-04 20:15:59 +08:00
|
|
|
int i, ret;
|
2010-03-17 06:06:12 +08:00
|
|
|
|
|
|
|
/* Loop 1: convert all events */
|
|
|
|
for (i = 0; i < npevs; i++) {
|
2015-06-16 19:50:55 +08:00
|
|
|
/* Init kprobe blacklist if needed */
|
2015-09-04 20:16:00 +08:00
|
|
|
if (!pevs[i].uprobes)
|
2015-06-16 19:50:55 +08:00
|
|
|
kprobe_blacklist__init();
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Convert with or without debuginfo */
|
2015-09-04 20:16:00 +08:00
|
|
|
ret = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
|
2010-04-13 01:17:42 +08:00
|
|
|
if (ret < 0)
|
2015-09-04 20:15:59 +08:00
|
|
|
return ret;
|
2015-09-04 20:16:00 +08:00
|
|
|
pevs[i].ntevs = ret;
|
2010-03-17 06:05:37 +08:00
|
|
|
}
|
2015-06-16 19:50:55 +08:00
|
|
|
/* This just release blacklist only if allocated */
|
|
|
|
kprobe_blacklist__release();
|
2010-03-17 06:05:37 +08:00
|
|
|
|
2015-09-04 20:15:59 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-26 00:24:27 +08:00
|
|
|
static int show_probe_trace_event(struct probe_trace_event *tev)
|
|
|
|
{
|
|
|
|
char *buf = synthesize_probe_trace_command(tev);
|
|
|
|
|
|
|
|
if (!buf) {
|
|
|
|
pr_debug("Failed to synthesize probe trace event.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Showing definition always go stdout */
|
|
|
|
printf("%s\n", buf);
|
|
|
|
free(buf);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
|
|
|
|
{
|
|
|
|
struct strlist *namelist = strlist__new(NULL, NULL);
|
|
|
|
struct probe_trace_event *tev;
|
|
|
|
struct perf_probe_event *pev;
|
|
|
|
int i, j, ret = 0;
|
|
|
|
|
|
|
|
if (!namelist)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (j = 0; j < npevs && !ret; j++) {
|
|
|
|
pev = &pevs[j];
|
|
|
|
for (i = 0; i < pev->ntevs && !ret; i++) {
|
|
|
|
tev = &pev->tevs[i];
|
|
|
|
/* Skip if the symbol is out of .text or blacklisted */
|
|
|
|
if (!tev->point.symbol && !pev->uprobes)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Set new name for tev (and update namelist) */
|
|
|
|
ret = probe_trace_event__set_name(tev, pev,
|
|
|
|
namelist, true);
|
|
|
|
if (!ret)
|
|
|
|
ret = show_probe_trace_event(tev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strlist__delete(namelist);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-09-04 20:16:00 +08:00
|
|
|
int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
|
2015-09-04 20:15:59 +08:00
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
2010-03-17 06:06:12 +08:00
|
|
|
/* Loop 2: add all events */
|
2011-02-22 17:56:18 +08:00
|
|
|
for (i = 0; i < npevs; i++) {
|
2015-09-04 20:16:00 +08:00
|
|
|
ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
|
|
|
|
pevs[i].ntevs,
|
2015-05-08 09:03:31 +08:00
|
|
|
probe_conf.force_add);
|
2011-02-22 00:23:57 +08:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
2015-09-04 20:15:59 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-09-04 20:16:00 +08:00
|
|
|
void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
|
2015-09-04 20:15:59 +08:00
|
|
|
{
|
|
|
|
int i, j;
|
2017-07-06 09:48:10 +08:00
|
|
|
struct perf_probe_event *pev;
|
2015-09-04 20:15:59 +08:00
|
|
|
|
2010-08-03 10:11:40 +08:00
|
|
|
/* Loop 3: cleanup and free trace events */
|
|
|
|
for (i = 0; i < npevs; i++) {
|
2017-07-06 09:48:10 +08:00
|
|
|
pev = &pevs[i];
|
2015-09-04 20:16:00 +08:00
|
|
|
for (j = 0; j < pevs[i].ntevs; j++)
|
|
|
|
clear_probe_trace_event(&pevs[i].tevs[j]);
|
|
|
|
zfree(&pevs[i].tevs);
|
|
|
|
pevs[i].ntevs = 0;
|
2017-07-06 09:48:10 +08:00
|
|
|
nsinfo__zput(pev->nsi);
|
2015-09-10 10:27:04 +08:00
|
|
|
clear_perf_probe_event(&pevs[i]);
|
2010-08-03 10:11:40 +08:00
|
|
|
}
|
2015-09-04 20:15:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
ret = init_probe_symbol_maps(pevs->uprobes);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-09-04 20:16:00 +08:00
|
|
|
ret = convert_perf_probe_events(pevs, npevs);
|
2015-09-04 20:15:59 +08:00
|
|
|
if (ret == 0)
|
2015-09-04 20:16:00 +08:00
|
|
|
ret = apply_perf_probe_events(pevs, npevs);
|
2015-09-04 20:15:59 +08:00
|
|
|
|
2015-09-04 20:16:00 +08:00
|
|
|
cleanup_perf_probe_events(pevs, npevs);
|
2010-04-13 01:17:42 +08:00
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
exit_probe_symbol_maps();
|
2010-04-13 01:17:42 +08:00
|
|
|
return ret;
|
2010-03-17 06:05:37 +08:00
|
|
|
}
|
|
|
|
|
2015-05-05 10:29:48 +08:00
|
|
|
int del_perf_probe_events(struct strfilter *filter)
|
2009-12-09 06:03:23 +08:00
|
|
|
{
|
2015-05-05 10:29:48 +08:00
|
|
|
int ret, ret2, ufd = -1, kfd = -1;
|
|
|
|
char *str = strfilter__string(filter);
|
|
|
|
|
|
|
|
if (!str)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-12-09 06:03:23 +08:00
|
|
|
/* Get current event names */
|
2015-07-15 17:14:07 +08:00
|
|
|
ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2014-08-14 00:12:50 +08:00
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
ret = probe_file__del_events(kfd, filter);
|
2015-05-05 10:29:48 +08:00
|
|
|
if (ret < 0 && ret != -ENOENT)
|
2012-04-16 20:09:09 +08:00
|
|
|
goto error;
|
|
|
|
|
2015-07-15 17:14:07 +08:00
|
|
|
ret2 = probe_file__del_events(ufd, filter);
|
2015-05-27 16:37:25 +08:00
|
|
|
if (ret2 < 0 && ret2 != -ENOENT) {
|
2015-05-05 10:29:48 +08:00
|
|
|
ret = ret2;
|
2015-05-27 16:37:25 +08:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ret = 0;
|
2012-04-16 20:09:09 +08:00
|
|
|
|
|
|
|
error:
|
2015-07-15 17:14:07 +08:00
|
|
|
if (kfd >= 0)
|
2012-04-16 20:09:09 +08:00
|
|
|
close(kfd);
|
2015-07-15 17:14:07 +08:00
|
|
|
if (ufd >= 0)
|
2012-04-16 20:09:09 +08:00
|
|
|
close(ufd);
|
2015-07-15 17:14:07 +08:00
|
|
|
out:
|
2015-05-05 10:29:48 +08:00
|
|
|
free(str);
|
2010-04-13 01:17:42 +08:00
|
|
|
|
|
|
|
return ret;
|
2009-12-09 06:03:23 +08:00
|
|
|
}
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2017-07-06 09:48:10 +08:00
|
|
|
int show_available_funcs(const char *target, struct nsinfo *nsi,
|
|
|
|
struct strfilter *_filter, bool user)
|
2011-01-13 20:46:11 +08:00
|
|
|
{
|
2016-08-31 21:04:27 +08:00
|
|
|
struct rb_node *nd;
|
2011-01-13 20:46:11 +08:00
|
|
|
struct map *map;
|
|
|
|
int ret;
|
|
|
|
|
2015-09-10 10:27:05 +08:00
|
|
|
ret = init_probe_symbol_maps(user);
|
2011-01-13 20:46:11 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-02-06 13:32:11 +08:00
|
|
|
/* Get a symbol map */
|
2017-07-06 09:48:10 +08:00
|
|
|
map = get_target_map(target, nsi, user);
|
2011-01-13 20:46:11 +08:00
|
|
|
if (!map) {
|
2014-02-06 13:32:11 +08:00
|
|
|
pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
|
2011-01-13 20:46:11 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2016-09-02 06:25:52 +08:00
|
|
|
ret = map__load(map);
|
2016-07-19 00:12:41 +08:00
|
|
|
if (ret) {
|
|
|
|
if (ret == -2) {
|
|
|
|
char *str = strfilter__string(_filter);
|
|
|
|
pr_err("Failed to find symbols matched to \"%s\"\n",
|
|
|
|
str);
|
|
|
|
free(str);
|
|
|
|
} else
|
|
|
|
pr_err("Failed to load symbols in %s\n",
|
|
|
|
(target) ? : "kernel");
|
2014-02-06 13:32:11 +08:00
|
|
|
goto end;
|
|
|
|
}
|
2018-04-27 03:52:34 +08:00
|
|
|
if (!dso__sorted_by_name(map->dso))
|
|
|
|
dso__sort_by_name(map->dso);
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2014-02-06 13:32:11 +08:00
|
|
|
/* Show all (filtered) symbols */
|
|
|
|
setup_pager();
|
2016-08-31 21:04:27 +08:00
|
|
|
|
2018-12-07 03:18:17 +08:00
|
|
|
for (nd = rb_first_cached(&map->dso->symbol_names); nd;
|
|
|
|
nd = rb_next(nd)) {
|
2016-08-31 21:04:27 +08:00
|
|
|
struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
|
|
|
|
|
|
|
|
if (strfilter__compare(_filter, pos->sym.name))
|
|
|
|
printf("%s\n", pos->sym.name);
|
2018-04-27 03:52:34 +08:00
|
|
|
}
|
2014-02-06 13:32:11 +08:00
|
|
|
end:
|
2017-01-04 11:29:05 +08:00
|
|
|
map__put(map);
|
2015-09-10 10:27:05 +08:00
|
|
|
exit_probe_symbol_maps();
|
2012-04-16 20:09:09 +08:00
|
|
|
|
2014-02-06 13:32:11 +08:00
|
|
|
return ret;
|
2012-04-16 20:09:09 +08:00
|
|
|
}
|
|
|
|
|
2015-08-26 18:57:45 +08:00
|
|
|
int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
|
|
|
|
struct perf_probe_arg *pvar)
|
|
|
|
{
|
|
|
|
tvar->value = strdup(pvar->var);
|
|
|
|
if (tvar->value == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (pvar->type) {
|
|
|
|
tvar->type = strdup(pvar->type);
|
|
|
|
if (tvar->type == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (pvar->name) {
|
|
|
|
tvar->name = strdup(pvar->name);
|
|
|
|
if (tvar->name == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
} else
|
|
|
|
tvar->name = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|