2009-08-13 14:35:11 -06:00
|
|
|
/*
|
2009-11-03 17:12:47 -07:00
|
|
|
* Kprobes-based tracing events
|
2009-08-13 14:35:11 -06:00
|
|
|
*
|
|
|
|
* Created 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 version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
|
2012-04-09 03:11:44 -06:00
|
|
|
#include "trace_probe.h"
|
2011-02-04 05:52:05 -07:00
|
|
|
|
2012-04-09 03:11:44 -06:00
|
|
|
#define KPROBE_EVENT_SYSTEM "kprobes"
|
2010-07-05 12:54:45 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
/**
|
2009-11-03 17:12:47 -07:00
|
|
|
* Kprobe event core functions
|
2009-08-13 14:35:11 -06:00
|
|
|
*/
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe {
|
2009-08-13 14:35:11 -06:00
|
|
|
struct list_head list;
|
2009-09-10 21:31:21 -06:00
|
|
|
struct kretprobe rp; /* Use rp.kp for kprobe use */
|
2016-02-03 13:28:28 -07:00
|
|
|
unsigned long __percpu *nhit;
|
2009-08-13 14:35:11 -06:00
|
|
|
const char *symbol; /* symbol name */
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_probe tp;
|
2009-08-13 14:35:11 -06:00
|
|
|
};
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
#define SIZEOF_TRACE_KPROBE(n) \
|
|
|
|
(offsetof(struct trace_kprobe, tp.args) + \
|
2009-09-10 17:53:38 -06:00
|
|
|
(sizeof(struct probe_arg) * (n)))
|
2009-08-13 14:35:18 -06:00
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline bool trace_kprobe_is_return(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
return tk->rp.handler != NULL;
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline const char *trace_kprobe_symbol(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
return tk->symbol ? tk->symbol : "unknown";
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline unsigned long trace_kprobe_offset(struct trace_kprobe *tk)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
return tk->rp.kp.offset;
|
2011-06-27 01:26:56 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline bool trace_kprobe_has_gone(struct trace_kprobe *tk)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
return !!(kprobe_gone(&tk->rp.kp));
|
2011-06-27 01:26:56 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline bool trace_kprobe_within_module(struct trace_kprobe *tk,
|
2013-07-02 22:50:51 -06:00
|
|
|
struct module *mod)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
|
|
|
int len = strlen(mod->name);
|
2013-07-02 22:50:51 -06:00
|
|
|
const char *name = trace_kprobe_symbol(tk);
|
2011-06-27 01:26:56 -06:00
|
|
|
return strncmp(mod->name, name, len) == 0 && name[len] == ':';
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline bool trace_kprobe_is_on_module(struct trace_kprobe *tk)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
return !!strchr(trace_kprobe_symbol(tk), ':');
|
2011-06-27 01:26:56 -06:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static int register_kprobe_event(struct trace_kprobe *tk);
|
|
|
|
static int unregister_kprobe_event(struct trace_kprobe *tk);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
static DEFINE_MUTEX(probe_lock);
|
|
|
|
static LIST_HEAD(probe_list);
|
|
|
|
|
2009-09-14 14:49:20 -06:00
|
|
|
static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
|
|
|
|
static int kretprobe_dispatcher(struct kretprobe_instance *ri,
|
|
|
|
struct pt_regs *regs);
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
/* Memory fetching by symbol */
|
|
|
|
struct symbol_cache {
|
|
|
|
char *symbol;
|
|
|
|
long offset;
|
|
|
|
unsigned long addr;
|
|
|
|
};
|
|
|
|
|
|
|
|
unsigned long update_symbol_cache(struct symbol_cache *sc)
|
|
|
|
{
|
|
|
|
sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol);
|
|
|
|
|
|
|
|
if (sc->addr)
|
|
|
|
sc->addr += sc->offset;
|
|
|
|
|
|
|
|
return sc->addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_symbol_cache(struct symbol_cache *sc)
|
|
|
|
{
|
|
|
|
kfree(sc->symbol);
|
|
|
|
kfree(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct symbol_cache *alloc_symbol_cache(const char *sym, long offset)
|
|
|
|
{
|
|
|
|
struct symbol_cache *sc;
|
|
|
|
|
|
|
|
if (!sym || strlen(sym) == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sc = kzalloc(sizeof(struct symbol_cache), GFP_KERNEL);
|
|
|
|
if (!sc)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sc->symbol = kstrdup(sym, GFP_KERNEL);
|
|
|
|
if (!sc->symbol) {
|
|
|
|
kfree(sc);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
sc->offset = offset;
|
|
|
|
update_symbol_cache(sc);
|
|
|
|
|
|
|
|
return sc;
|
|
|
|
}
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
/*
|
|
|
|
* Kprobes-specific fetch functions
|
|
|
|
*/
|
|
|
|
#define DEFINE_FETCH_stack(type) \
|
2014-04-17 02:18:28 -06:00
|
|
|
static void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs, \
|
2013-11-25 23:21:04 -07:00
|
|
|
void *offset, void *dest) \
|
|
|
|
{ \
|
|
|
|
*(type *)dest = (type)regs_get_kernel_stack_nth(regs, \
|
|
|
|
(unsigned int)((unsigned long)offset)); \
|
2014-04-17 02:18:28 -06:00
|
|
|
} \
|
|
|
|
NOKPROBE_SYMBOL(FETCH_FUNC_NAME(stack, type));
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(stack)
|
|
|
|
/* No string on the stack entry */
|
|
|
|
#define fetch_stack_string NULL
|
|
|
|
#define fetch_stack_string_size NULL
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
#define DEFINE_FETCH_memory(type) \
|
2014-04-17 02:18:28 -06:00
|
|
|
static void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs, \
|
2013-11-25 23:21:04 -07:00
|
|
|
void *addr, void *dest) \
|
|
|
|
{ \
|
|
|
|
type retval; \
|
|
|
|
if (probe_kernel_address(addr, retval)) \
|
|
|
|
*(type *)dest = 0; \
|
|
|
|
else \
|
|
|
|
*(type *)dest = retval; \
|
2014-04-17 02:18:28 -06:00
|
|
|
} \
|
|
|
|
NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, type));
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(memory)
|
|
|
|
/*
|
|
|
|
* Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max
|
|
|
|
* length and relative data location.
|
|
|
|
*/
|
2014-04-17 02:18:28 -06:00
|
|
|
static void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs,
|
|
|
|
void *addr, void *dest)
|
2013-11-25 23:21:04 -07:00
|
|
|
{
|
|
|
|
int maxlen = get_rloc_len(*(u32 *)dest);
|
|
|
|
u8 *dst = get_rloc_data(dest);
|
2015-08-28 16:56:22 -06:00
|
|
|
long ret;
|
2013-11-25 23:21:04 -07:00
|
|
|
|
|
|
|
if (!maxlen)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to get string again, since the string can be changed while
|
|
|
|
* probing.
|
|
|
|
*/
|
2015-08-28 16:56:22 -06:00
|
|
|
ret = strncpy_from_unsafe(dst, addr, maxlen);
|
2013-11-25 23:21:04 -07:00
|
|
|
|
|
|
|
if (ret < 0) { /* Failed to fetch string */
|
2015-08-28 16:56:22 -06:00
|
|
|
dst[0] = '\0';
|
2013-11-25 23:21:04 -07:00
|
|
|
*(u32 *)dest = make_data_rloc(0, get_rloc_offs(*(u32 *)dest));
|
|
|
|
} else {
|
2015-08-28 16:56:22 -06:00
|
|
|
*(u32 *)dest = make_data_rloc(ret, get_rloc_offs(*(u32 *)dest));
|
2013-11-25 23:21:04 -07:00
|
|
|
}
|
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, string));
|
2013-11-25 23:21:04 -07:00
|
|
|
|
|
|
|
/* Return the length of string -- including null terminal byte */
|
2014-04-17 02:18:28 -06:00
|
|
|
static void FETCH_FUNC_NAME(memory, string_size)(struct pt_regs *regs,
|
|
|
|
void *addr, void *dest)
|
2013-11-25 23:21:04 -07:00
|
|
|
{
|
|
|
|
mm_segment_t old_fs;
|
|
|
|
int ret, len = 0;
|
|
|
|
u8 c;
|
|
|
|
|
|
|
|
old_fs = get_fs();
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
pagefault_disable();
|
|
|
|
|
|
|
|
do {
|
|
|
|
ret = __copy_from_user_inatomic(&c, (u8 *)addr + len, 1);
|
|
|
|
len++;
|
|
|
|
} while (c && ret == 0 && len < MAX_STRING_SIZE);
|
|
|
|
|
|
|
|
pagefault_enable();
|
|
|
|
set_fs(old_fs);
|
|
|
|
|
|
|
|
if (ret < 0) /* Failed to check the length */
|
|
|
|
*(u32 *)dest = 0;
|
|
|
|
else
|
|
|
|
*(u32 *)dest = len;
|
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, string_size));
|
2013-11-25 23:21:04 -07:00
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
#define DEFINE_FETCH_symbol(type) \
|
2014-04-17 02:18:28 -06:00
|
|
|
void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs, void *data, void *dest)\
|
2013-11-25 23:21:04 -07:00
|
|
|
{ \
|
|
|
|
struct symbol_cache *sc = data; \
|
|
|
|
if (sc->addr) \
|
|
|
|
fetch_memory_##type(regs, (void *)sc->addr, dest); \
|
|
|
|
else \
|
|
|
|
*(type *)dest = 0; \
|
2014-04-17 02:18:28 -06:00
|
|
|
} \
|
|
|
|
NOKPROBE_SYMBOL(FETCH_FUNC_NAME(symbol, type));
|
|
|
|
|
2013-11-25 23:21:04 -07:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(symbol)
|
|
|
|
DEFINE_FETCH_symbol(string)
|
|
|
|
DEFINE_FETCH_symbol(string_size)
|
|
|
|
|
2013-11-24 21:42:47 -07:00
|
|
|
/* kprobes don't support file_offset fetch methods */
|
|
|
|
#define fetch_file_offset_u8 NULL
|
|
|
|
#define fetch_file_offset_u16 NULL
|
|
|
|
#define fetch_file_offset_u32 NULL
|
|
|
|
#define fetch_file_offset_u64 NULL
|
|
|
|
#define fetch_file_offset_string NULL
|
|
|
|
#define fetch_file_offset_string_size NULL
|
|
|
|
|
2013-11-25 22:56:28 -07:00
|
|
|
/* Fetch type information table */
|
2015-03-11 23:58:34 -06:00
|
|
|
static const struct fetch_type kprobes_fetch_type_table[] = {
|
2013-11-25 22:56:28 -07:00
|
|
|
/* Special types */
|
|
|
|
[FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
|
|
|
|
sizeof(u32), 1, "__data_loc char[]"),
|
|
|
|
[FETCH_TYPE_STRSIZE] = __ASSIGN_FETCH_TYPE("string_size", u32,
|
|
|
|
string_size, sizeof(u32), 0, "u32"),
|
|
|
|
/* Basic types */
|
|
|
|
ASSIGN_FETCH_TYPE(u8, u8, 0),
|
|
|
|
ASSIGN_FETCH_TYPE(u16, u16, 0),
|
|
|
|
ASSIGN_FETCH_TYPE(u32, u32, 0),
|
|
|
|
ASSIGN_FETCH_TYPE(u64, u64, 0),
|
|
|
|
ASSIGN_FETCH_TYPE(s8, u8, 1),
|
|
|
|
ASSIGN_FETCH_TYPE(s16, u16, 1),
|
|
|
|
ASSIGN_FETCH_TYPE(s32, u32, 1),
|
|
|
|
ASSIGN_FETCH_TYPE(s64, u64, 1),
|
|
|
|
|
|
|
|
ASSIGN_FETCH_TYPE_END
|
|
|
|
};
|
|
|
|
|
2009-09-10 21:31:21 -06:00
|
|
|
/*
|
|
|
|
* Allocate new trace_probe and initialize it (including kprobes).
|
|
|
|
*/
|
2013-07-02 22:50:51 -06:00
|
|
|
static struct trace_kprobe *alloc_trace_kprobe(const char *group,
|
2009-09-10 17:53:53 -06:00
|
|
|
const char *event,
|
2009-09-10 21:31:21 -06:00
|
|
|
void *addr,
|
|
|
|
const char *symbol,
|
|
|
|
unsigned long offs,
|
2012-04-09 03:11:33 -06:00
|
|
|
int nargs, bool is_return)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2009-12-16 15:24:08 -07:00
|
|
|
int ret = -ENOMEM;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = kzalloc(SIZEOF_TRACE_KPROBE(nargs), GFP_KERNEL);
|
|
|
|
if (!tk)
|
2009-12-16 15:24:08 -07:00
|
|
|
return ERR_PTR(ret);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2016-02-03 13:28:28 -07:00
|
|
|
tk->nhit = alloc_percpu(unsigned long);
|
|
|
|
if (!tk->nhit)
|
|
|
|
goto error;
|
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
if (symbol) {
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->symbol = kstrdup(symbol, GFP_KERNEL);
|
|
|
|
if (!tk->symbol)
|
2009-08-13 14:35:11 -06:00
|
|
|
goto error;
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.kp.symbol_name = tk->symbol;
|
|
|
|
tk->rp.kp.offset = offs;
|
2009-09-10 21:31:21 -06:00
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.kp.addr = addr;
|
2009-09-10 21:31:21 -06:00
|
|
|
|
|
|
|
if (is_return)
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.handler = kretprobe_dispatcher;
|
2009-09-10 21:31:21 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.kp.pre_handler = kprobe_dispatcher;
|
2009-09-10 21:31:21 -06:00
|
|
|
|
2010-08-27 05:39:12 -06:00
|
|
|
if (!event || !is_good_name(event)) {
|
2009-12-16 15:24:08 -07:00
|
|
|
ret = -EINVAL;
|
2009-08-13 14:35:26 -06:00
|
|
|
goto error;
|
2009-12-16 15:24:08 -07:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.call.class = &tk->tp.class;
|
|
|
|
tk->tp.call.name = kstrdup(event, GFP_KERNEL);
|
|
|
|
if (!tk->tp.call.name)
|
2009-08-13 14:35:26 -06:00
|
|
|
goto error;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2010-08-27 05:39:12 -06:00
|
|
|
if (!group || !is_good_name(group)) {
|
2009-12-16 15:24:08 -07:00
|
|
|
ret = -EINVAL;
|
2009-09-10 17:53:53 -06:00
|
|
|
goto error;
|
2009-12-16 15:24:08 -07:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.class.system = kstrdup(group, GFP_KERNEL);
|
|
|
|
if (!tk->tp.class.system)
|
2009-09-10 17:53:53 -06:00
|
|
|
goto error;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
INIT_LIST_HEAD(&tk->list);
|
|
|
|
INIT_LIST_HEAD(&tk->tp.files);
|
|
|
|
return tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
error:
|
2013-07-02 22:50:51 -06:00
|
|
|
kfree(tk->tp.call.name);
|
|
|
|
kfree(tk->symbol);
|
2016-02-03 13:28:28 -07:00
|
|
|
free_percpu(tk->nhit);
|
2013-07-02 22:50:51 -06:00
|
|
|
kfree(tk);
|
2009-12-16 15:24:08 -07:00
|
|
|
return ERR_PTR(ret);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static void free_trace_kprobe(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
for (i = 0; i < tk->tp.nr_args; i++)
|
|
|
|
traceprobe_free_probe_arg(&tk->tp.args[i]);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
kfree(tk->tp.call.class->system);
|
|
|
|
kfree(tk->tp.call.name);
|
|
|
|
kfree(tk->symbol);
|
2016-02-03 13:28:28 -07:00
|
|
|
free_percpu(tk->nhit);
|
2013-07-02 22:50:51 -06:00
|
|
|
kfree(tk);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static struct trace_kprobe *find_trace_kprobe(const char *event,
|
|
|
|
const char *group)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
list_for_each_entry(tk, &probe_list, list)
|
2015-05-13 12:20:14 -06:00
|
|
|
if (strcmp(trace_event_name(&tk->tp.call), event) == 0 &&
|
2013-07-02 22:50:51 -06:00
|
|
|
strcmp(tk->tp.call.class->system, group) == 0)
|
|
|
|
return tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-05-08 23:44:49 -06:00
|
|
|
/*
|
|
|
|
* Enable trace_probe
|
|
|
|
* if the file is NULL, enable "perf" handler, or enable "trace" handler.
|
|
|
|
*/
|
|
|
|
static int
|
2015-05-05 08:09:53 -06:00
|
|
|
enable_trace_kprobe(struct trace_kprobe *tk, struct trace_event_file *file)
|
2011-06-27 01:26:44 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2013-05-08 23:44:49 -06:00
|
|
|
if (file) {
|
2013-06-20 11:38:14 -06:00
|
|
|
struct event_file_link *link;
|
|
|
|
|
|
|
|
link = kmalloc(sizeof(*link), GFP_KERNEL);
|
|
|
|
if (!link) {
|
2013-05-08 23:44:49 -06:00
|
|
|
ret = -ENOMEM;
|
2013-06-20 11:38:09 -06:00
|
|
|
goto out;
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
|
|
|
|
2013-06-20 11:38:14 -06:00
|
|
|
link->file = file;
|
2013-07-02 22:50:51 -06:00
|
|
|
list_add_tail_rcu(&link->list, &tk->tp.files);
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.flags |= TP_FLAG_TRACE;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.flags |= TP_FLAG_PROFILE;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_probe_is_registered(&tk->tp) && !trace_kprobe_has_gone(tk)) {
|
|
|
|
if (trace_kprobe_is_return(tk))
|
|
|
|
ret = enable_kretprobe(&tk->rp);
|
2011-06-27 01:26:44 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = enable_kprobe(&tk->rp.kp);
|
2011-06-27 01:26:44 -06:00
|
|
|
}
|
2013-06-20 11:38:09 -06:00
|
|
|
out:
|
2011-06-27 01:26:44 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-05-08 23:44:49 -06:00
|
|
|
/*
|
|
|
|
* Disable trace_probe
|
|
|
|
* if the file is NULL, disable "perf" handler, or disable "trace" handler.
|
|
|
|
*/
|
|
|
|
static int
|
2015-05-05 08:09:53 -06:00
|
|
|
disable_trace_kprobe(struct trace_kprobe *tk, struct trace_event_file *file)
|
2011-06-27 01:26:44 -06:00
|
|
|
{
|
2013-07-09 03:35:26 -06:00
|
|
|
struct event_file_link *link = NULL;
|
|
|
|
int wait = 0;
|
2013-05-08 23:44:49 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (file) {
|
2013-07-02 22:50:51 -06:00
|
|
|
link = find_event_file_link(&tk->tp, file);
|
2013-06-20 11:38:14 -06:00
|
|
|
if (!link) {
|
2013-05-08 23:44:49 -06:00
|
|
|
ret = -EINVAL;
|
2013-06-20 11:38:09 -06:00
|
|
|
goto out;
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
|
|
|
|
2013-06-20 11:38:14 -06:00
|
|
|
list_del_rcu(&link->list);
|
2013-07-09 03:35:26 -06:00
|
|
|
wait = 1;
|
2013-07-02 22:50:51 -06:00
|
|
|
if (!list_empty(&tk->tp.files))
|
2013-06-20 11:38:14 -06:00
|
|
|
goto out;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.flags &= ~TP_FLAG_TRACE;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.flags &= ~TP_FLAG_PROFILE;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (!trace_probe_is_enabled(&tk->tp) && trace_probe_is_registered(&tk->tp)) {
|
|
|
|
if (trace_kprobe_is_return(tk))
|
|
|
|
disable_kretprobe(&tk->rp);
|
2011-06-27 01:26:44 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
disable_kprobe(&tk->rp.kp);
|
2013-07-09 03:35:26 -06:00
|
|
|
wait = 1;
|
2011-06-27 01:26:44 -06:00
|
|
|
}
|
2013-06-20 11:38:09 -06:00
|
|
|
out:
|
2013-07-09 03:35:26 -06:00
|
|
|
if (wait) {
|
|
|
|
/*
|
|
|
|
* Synchronize with kprobe_trace_func/kretprobe_trace_func
|
|
|
|
* to ensure disabled (all running handlers are finished).
|
|
|
|
* This is not only for kfree(), but also the caller,
|
|
|
|
* trace_remove_event_call() supposes it for releasing
|
|
|
|
* event_call related objects, which will be accessed in
|
|
|
|
* the kprobe_trace_func/kretprobe_trace_func.
|
|
|
|
*/
|
|
|
|
synchronize_sched();
|
|
|
|
kfree(link); /* Ignored if link == NULL */
|
|
|
|
}
|
|
|
|
|
2013-05-08 23:44:49 -06:00
|
|
|
return ret;
|
2011-06-27 01:26:44 -06:00
|
|
|
}
|
|
|
|
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Internal register function - just handle k*probes and flags */
|
2013-07-02 22:50:51 -06:00
|
|
|
static int __register_trace_kprobe(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2011-06-27 01:27:03 -06:00
|
|
|
int i, ret;
|
2011-06-27 01:26:56 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_probe_is_registered(&tk->tp))
|
2011-06-27 01:26:56 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
for (i = 0; i < tk->tp.nr_args; i++)
|
|
|
|
traceprobe_update_arg(&tk->tp.args[i]);
|
2011-06-27 01:27:03 -06:00
|
|
|
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Set/clear disabled flag according to tp->flag */
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_probe_is_enabled(&tk->tp))
|
|
|
|
tk->rp.kp.flags &= ~KPROBE_FLAG_DISABLED;
|
2011-06-27 01:26:56 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.kp.flags |= KPROBE_FLAG_DISABLED;
|
2011-06-27 01:26:56 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_kprobe_is_return(tk))
|
|
|
|
ret = register_kretprobe(&tk->rp);
|
2009-08-13 14:35:11 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = register_kprobe(&tk->rp.kp);
|
2011-06-27 01:26:56 -06:00
|
|
|
|
|
|
|
if (ret == 0)
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.flags |= TP_FLAG_REGISTERED;
|
2011-06-27 01:26:56 -06:00
|
|
|
else {
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Could not insert probe at %s+%lu: %d\n",
|
|
|
|
trace_kprobe_symbol(tk), trace_kprobe_offset(tk), ret);
|
2013-07-02 22:50:51 -06:00
|
|
|
if (ret == -ENOENT && trace_kprobe_is_on_module(tk)) {
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("This probe might be able to register after target module is loaded. Continue.\n");
|
2011-06-27 01:26:56 -06:00
|
|
|
ret = 0;
|
|
|
|
} else if (ret == -EILSEQ) {
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Probing address(0x%p) is not an instruction boundary.\n",
|
|
|
|
tk->rp.kp.addr);
|
2011-06-27 01:26:56 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Internal unregister function - just handle k*probes and flags */
|
2013-07-02 22:50:51 -06:00
|
|
|
static void __unregister_trace_kprobe(struct trace_kprobe *tk)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_probe_is_registered(&tk->tp)) {
|
|
|
|
if (trace_kprobe_is_return(tk))
|
|
|
|
unregister_kretprobe(&tk->rp);
|
2011-06-27 01:26:56 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
unregister_kprobe(&tk->rp.kp);
|
|
|
|
tk->tp.flags &= ~TP_FLAG_REGISTERED;
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Cleanup kprobe for reuse */
|
2013-07-02 22:50:51 -06:00
|
|
|
if (tk->rp.kp.symbol_name)
|
|
|
|
tk->rp.kp.addr = NULL;
|
2011-06-27 01:26:56 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unregister a trace_probe and probe_event: call with locking probe_lock */
|
2013-07-02 22:50:51 -06:00
|
|
|
static int unregister_trace_kprobe(struct trace_kprobe *tk)
|
2011-06-27 01:26:56 -06:00
|
|
|
{
|
2011-10-04 04:44:38 -06:00
|
|
|
/* Enabled event can not be unregistered */
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_probe_is_enabled(&tk->tp))
|
2011-10-04 04:44:38 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
2013-07-03 21:33:50 -06:00
|
|
|
/* Will fail if probe is being used by ftrace or perf */
|
2013-07-02 22:50:51 -06:00
|
|
|
if (unregister_kprobe_event(tk))
|
2013-07-03 21:33:50 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
__unregister_trace_kprobe(tk);
|
|
|
|
list_del(&tk->list);
|
2011-10-04 04:44:38 -06:00
|
|
|
|
|
|
|
return 0;
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Register a trace_probe and probe_event */
|
2013-07-02 22:50:51 -06:00
|
|
|
static int register_trace_kprobe(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *old_tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&probe_lock);
|
|
|
|
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Delete old (same name) event if exist */
|
2015-05-13 12:20:14 -06:00
|
|
|
old_tk = find_trace_kprobe(trace_event_name(&tk->tp.call),
|
2014-04-08 15:26:21 -06:00
|
|
|
tk->tp.call.class->system);
|
2013-07-02 22:50:51 -06:00
|
|
|
if (old_tk) {
|
|
|
|
ret = unregister_trace_kprobe(old_tk);
|
2011-10-04 04:44:38 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto end;
|
2013-07-02 22:50:51 -06:00
|
|
|
free_trace_kprobe(old_tk);
|
2009-09-14 14:48:56 -06:00
|
|
|
}
|
2011-06-27 01:26:56 -06:00
|
|
|
|
|
|
|
/* Register new event */
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = register_kprobe_event(tk);
|
2009-09-14 14:48:56 -06:00
|
|
|
if (ret) {
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Failed to register probe event(%d)\n", ret);
|
2009-09-14 14:48:56 -06:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Register k*probe */
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = __register_trace_kprobe(tk);
|
2011-06-27 01:26:56 -06:00
|
|
|
if (ret < 0)
|
2013-07-02 22:50:51 -06:00
|
|
|
unregister_kprobe_event(tk);
|
2011-06-27 01:26:56 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
list_add_tail(&tk->list, &probe_list);
|
2011-06-27 01:26:56 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
end:
|
|
|
|
mutex_unlock(&probe_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-27 01:26:56 -06:00
|
|
|
/* Module notifier call back, checking event on the module */
|
2013-07-02 22:50:51 -06:00
|
|
|
static int trace_kprobe_module_callback(struct notifier_block *nb,
|
2011-06-27 01:26:56 -06:00
|
|
|
unsigned long val, void *data)
|
|
|
|
{
|
|
|
|
struct module *mod = data;
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2011-06-27 01:26:56 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (val != MODULE_STATE_COMING)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
/* Update probes on coming module */
|
|
|
|
mutex_lock(&probe_lock);
|
2013-07-02 22:50:51 -06:00
|
|
|
list_for_each_entry(tk, &probe_list, list) {
|
|
|
|
if (trace_kprobe_within_module(tk, mod)) {
|
2011-10-04 04:44:38 -06:00
|
|
|
/* Don't need to check busy - this should have gone. */
|
2013-07-02 22:50:51 -06:00
|
|
|
__unregister_trace_kprobe(tk);
|
|
|
|
ret = __register_trace_kprobe(tk);
|
2011-06-27 01:26:56 -06:00
|
|
|
if (ret)
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Failed to re-register probe %s on %s: %d\n",
|
|
|
|
trace_event_name(&tk->tp.call),
|
|
|
|
mod->name, ret);
|
2011-06-27 01:26:56 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&probe_lock);
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static struct notifier_block trace_kprobe_module_nb = {
|
|
|
|
.notifier_call = trace_kprobe_module_callback,
|
2011-06-27 01:26:56 -06:00
|
|
|
.priority = 1 /* Invoked after kprobe module callback */
|
|
|
|
};
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static int create_trace_kprobe(int argc, char **argv)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Argument syntax:
|
2011-06-27 01:26:56 -06:00
|
|
|
* - Add kprobe: p[:[GRP/]EVENT] [MOD:]KSYM[+OFFS]|KADDR [FETCHARGS]
|
|
|
|
* - Add kretprobe: r[:[GRP/]EVENT] [MOD:]KSYM[+0] [FETCHARGS]
|
2009-08-13 14:35:11 -06:00
|
|
|
* Fetch args:
|
2009-10-07 16:27:59 -06:00
|
|
|
* $retval : fetch return value
|
|
|
|
* $stack : fetch stack address
|
|
|
|
* $stackN : fetch Nth of stack (N:0-)
|
2009-08-13 14:35:11 -06:00
|
|
|
* @ADDR : fetch memory at ADDR (ADDR should be in kernel)
|
|
|
|
* @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol)
|
|
|
|
* %REG : fetch register REG
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
* Dereferencing memory fetch:
|
2009-08-13 14:35:11 -06:00
|
|
|
* +|-offs(ARG) : fetch memory at ARG +|- offs address.
|
2009-09-10 17:53:38 -06:00
|
|
|
* Alias name of args:
|
|
|
|
* NAME=FETCHARG : set NAME as alias of FETCHARG.
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
* Type of args:
|
|
|
|
* FETCHARG:TYPE : use TYPE instead of unsigned long.
|
2009-08-13 14:35:11 -06:00
|
|
|
*/
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
int i, ret = 0;
|
2012-04-09 03:11:33 -06:00
|
|
|
bool is_return = false, is_delete = false;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
char *symbol = NULL, *event = NULL, *group = NULL;
|
2010-08-27 05:39:12 -06:00
|
|
|
char *arg;
|
2009-09-10 17:53:14 -06:00
|
|
|
unsigned long offset = 0;
|
2009-08-13 14:35:11 -06:00
|
|
|
void *addr = NULL;
|
2009-09-10 21:31:21 -06:00
|
|
|
char buf[MAX_EVENT_NAME_LEN];
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2009-12-08 15:03:16 -07:00
|
|
|
/* argc must be >= 1 */
|
2009-08-13 14:35:11 -06:00
|
|
|
if (argv[0][0] == 'p')
|
2012-04-09 03:11:33 -06:00
|
|
|
is_return = false;
|
2009-08-13 14:35:11 -06:00
|
|
|
else if (argv[0][0] == 'r')
|
2012-04-09 03:11:33 -06:00
|
|
|
is_return = true;
|
2009-12-08 15:03:16 -07:00
|
|
|
else if (argv[0][0] == '-')
|
2012-04-09 03:11:33 -06:00
|
|
|
is_delete = true;
|
2009-10-16 18:07:28 -06:00
|
|
|
else {
|
2009-12-08 15:03:16 -07:00
|
|
|
pr_info("Probe definition must be started with 'p', 'r' or"
|
|
|
|
" '-'.\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return -EINVAL;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
if (argv[0][1] == ':') {
|
|
|
|
event = &argv[0][2];
|
2009-09-10 17:53:53 -06:00
|
|
|
if (strchr(event, '/')) {
|
|
|
|
group = event;
|
|
|
|
event = strchr(group, '/') + 1;
|
|
|
|
event[-1] = '\0';
|
|
|
|
if (strlen(group) == 0) {
|
2010-02-24 00:40:23 -07:00
|
|
|
pr_info("Group name is not specified\n");
|
2009-09-10 17:53:53 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
if (strlen(event) == 0) {
|
2010-02-24 00:40:23 -07:00
|
|
|
pr_info("Event name is not specified\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2009-12-08 15:03:16 -07:00
|
|
|
if (!group)
|
|
|
|
group = KPROBE_EVENT_SYSTEM;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2009-12-08 15:03:16 -07:00
|
|
|
if (is_delete) {
|
|
|
|
if (!event) {
|
|
|
|
pr_info("Delete command needs an event name.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-06-30 02:45:48 -06:00
|
|
|
mutex_lock(&probe_lock);
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = find_trace_kprobe(event, group);
|
|
|
|
if (!tk) {
|
2010-06-30 02:45:48 -06:00
|
|
|
mutex_unlock(&probe_lock);
|
2009-12-08 15:03:16 -07:00
|
|
|
pr_info("Event %s/%s doesn't exist.\n", group, event);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
/* delete an event */
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = unregister_trace_kprobe(tk);
|
2011-10-04 04:44:38 -06:00
|
|
|
if (ret == 0)
|
2013-07-02 22:50:51 -06:00
|
|
|
free_trace_kprobe(tk);
|
2010-06-30 02:45:48 -06:00
|
|
|
mutex_unlock(&probe_lock);
|
2011-10-04 04:44:38 -06:00
|
|
|
return ret;
|
2009-12-08 15:03:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (argc < 2) {
|
|
|
|
pr_info("Probe point is not specified.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
if (isdigit(argv[1][0])) {
|
2009-10-16 18:07:28 -06:00
|
|
|
if (is_return) {
|
|
|
|
pr_info("Return probe point must be a symbol.\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return -EINVAL;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
/* an address specified */
|
2012-09-26 14:08:38 -06:00
|
|
|
ret = kstrtoul(&argv[1][0], 0, (unsigned long *)&addr);
|
2009-10-16 18:07:28 -06:00
|
|
|
if (ret) {
|
|
|
|
pr_info("Failed to parse address.\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return ret;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
} else {
|
|
|
|
/* a symbol specified */
|
|
|
|
symbol = argv[1];
|
|
|
|
/* TODO: support .init module functions */
|
2012-04-09 03:11:44 -06:00
|
|
|
ret = traceprobe_split_symbol_offset(symbol, &offset);
|
2009-10-16 18:07:28 -06:00
|
|
|
if (ret) {
|
|
|
|
pr_info("Failed to parse symbol.\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return ret;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
|
|
|
if (offset && is_return) {
|
|
|
|
pr_info("Return probe must be used without offset.\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return -EINVAL;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
2009-08-13 14:35:18 -06:00
|
|
|
argc -= 2; argv += 2;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
/* setup a probe */
|
2009-08-13 14:35:26 -06:00
|
|
|
if (!event) {
|
|
|
|
/* Make a new event name */
|
|
|
|
if (symbol)
|
2009-12-16 15:24:08 -07:00
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
|
2009-08-13 14:35:26 -06:00
|
|
|
is_return ? 'r' : 'p', symbol, offset);
|
|
|
|
else
|
2009-12-16 15:24:08 -07:00
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
|
2009-08-13 14:35:26 -06:00
|
|
|
is_return ? 'r' : 'p', addr);
|
2009-09-10 21:31:21 -06:00
|
|
|
event = buf;
|
|
|
|
}
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = alloc_trace_kprobe(group, event, addr, symbol, offset, argc,
|
2009-09-10 17:53:53 -06:00
|
|
|
is_return);
|
2013-07-02 22:50:51 -06:00
|
|
|
if (IS_ERR(tk)) {
|
2009-10-16 18:07:28 -06:00
|
|
|
pr_info("Failed to allocate trace_probe.(%d)\n",
|
2013-07-02 22:50:51 -06:00
|
|
|
(int)PTR_ERR(tk));
|
|
|
|
return PTR_ERR(tk);
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
/* parse arguments */
|
2009-08-13 14:35:18 -06:00
|
|
|
ret = 0;
|
|
|
|
for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
|
2013-07-02 22:50:51 -06:00
|
|
|
struct probe_arg *parg = &tk->tp.args[i];
|
|
|
|
|
2010-08-27 05:38:46 -06:00
|
|
|
/* Increment count for freeing args in error case */
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->tp.nr_args++;
|
2010-08-27 05:38:46 -06:00
|
|
|
|
2009-09-10 17:53:38 -06:00
|
|
|
/* Parse argument name */
|
|
|
|
arg = strchr(argv[i], '=');
|
2010-08-27 05:39:06 -06:00
|
|
|
if (arg) {
|
2009-09-10 17:53:38 -06:00
|
|
|
*arg++ = '\0';
|
2013-07-02 22:50:51 -06:00
|
|
|
parg->name = kstrdup(argv[i], GFP_KERNEL);
|
2010-08-27 05:39:06 -06:00
|
|
|
} else {
|
2009-09-10 17:53:38 -06:00
|
|
|
arg = argv[i];
|
2010-08-27 05:39:06 -06:00
|
|
|
/* If argument name is omitted, set "argN" */
|
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1);
|
2013-07-02 22:50:51 -06:00
|
|
|
parg->name = kstrdup(buf, GFP_KERNEL);
|
2010-08-27 05:39:06 -06:00
|
|
|
}
|
2009-10-07 16:28:07 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (!parg->name) {
|
2010-08-27 05:39:06 -06:00
|
|
|
pr_info("Failed to allocate argument[%d] name.\n", i);
|
2009-11-30 17:19:20 -07:00
|
|
|
ret = -ENOMEM;
|
2009-08-13 14:35:11 -06:00
|
|
|
goto error;
|
|
|
|
}
|
2010-08-27 05:39:12 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (!is_good_name(parg->name)) {
|
2010-08-27 05:39:12 -06:00
|
|
|
pr_info("Invalid argument[%d] name: %s\n",
|
2013-07-02 22:50:51 -06:00
|
|
|
i, parg->name);
|
2010-08-27 05:39:12 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (traceprobe_conflict_field_name(parg->name,
|
|
|
|
tk->tp.args, i)) {
|
2010-08-27 05:39:06 -06:00
|
|
|
pr_info("Argument[%d] name '%s' conflicts with "
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
"another field.\n", i, argv[i]);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2009-11-30 17:19:20 -07:00
|
|
|
|
|
|
|
/* Parse fetch argument */
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = traceprobe_parse_probe_arg(arg, &tk->tp.size, parg,
|
2015-03-11 23:58:34 -06:00
|
|
|
is_return, true,
|
|
|
|
kprobes_fetch_type_table);
|
2009-10-16 18:07:28 -06:00
|
|
|
if (ret) {
|
2010-08-27 05:39:06 -06:00
|
|
|
pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
|
2009-08-13 14:35:11 -06:00
|
|
|
goto error;
|
2009-10-16 18:07:28 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = register_trace_kprobe(tk);
|
2009-08-13 14:35:11 -06:00
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2013-07-02 22:50:51 -06:00
|
|
|
free_trace_kprobe(tk);
|
2009-08-13 14:35:11 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static int release_all_trace_kprobes(void)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2011-10-04 04:44:38 -06:00
|
|
|
int ret = 0;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
mutex_lock(&probe_lock);
|
2011-10-04 04:44:38 -06:00
|
|
|
/* Ensure no probe is in use. */
|
2013-07-02 22:50:51 -06:00
|
|
|
list_for_each_entry(tk, &probe_list, list)
|
|
|
|
if (trace_probe_is_enabled(&tk->tp)) {
|
2011-10-04 04:44:38 -06:00
|
|
|
ret = -EBUSY;
|
|
|
|
goto end;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
/* TODO: Use batch unregistration */
|
|
|
|
while (!list_empty(&probe_list)) {
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = list_entry(probe_list.next, struct trace_kprobe, list);
|
|
|
|
ret = unregister_trace_kprobe(tk);
|
2013-07-03 21:33:50 -06:00
|
|
|
if (ret)
|
|
|
|
goto end;
|
2013-07-02 22:50:51 -06:00
|
|
|
free_trace_kprobe(tk);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
2011-10-04 04:44:38 -06:00
|
|
|
|
|
|
|
end:
|
2009-08-13 14:35:11 -06:00
|
|
|
mutex_unlock(&probe_lock);
|
2011-10-04 04:44:38 -06:00
|
|
|
|
|
|
|
return ret;
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Probes listing interfaces */
|
|
|
|
static void *probes_seq_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
mutex_lock(&probe_lock);
|
|
|
|
return seq_list_start(&probe_list, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
return seq_list_next(v, &probe_list, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void probes_seq_stop(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
mutex_unlock(&probe_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int probes_seq_show(struct seq_file *m, void *v)
|
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = v;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
int i;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-08 13:42:10 -07:00
|
|
|
seq_putc(m, trace_kprobe_is_return(tk) ? 'r' : 'p');
|
2014-04-08 15:26:21 -06:00
|
|
|
seq_printf(m, ":%s/%s", tk->tp.call.class->system,
|
2015-05-13 12:20:14 -06:00
|
|
|
trace_event_name(&tk->tp.call));
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (!tk->symbol)
|
|
|
|
seq_printf(m, " 0x%p", tk->rp.kp.addr);
|
|
|
|
else if (tk->rp.kp.offset)
|
|
|
|
seq_printf(m, " %s+%u", trace_kprobe_symbol(tk),
|
|
|
|
tk->rp.kp.offset);
|
2009-08-13 14:35:11 -06:00
|
|
|
else
|
2013-07-02 22:50:51 -06:00
|
|
|
seq_printf(m, " %s", trace_kprobe_symbol(tk));
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
for (i = 0; i < tk->tp.nr_args; i++)
|
|
|
|
seq_printf(m, " %s=%s", tk->tp.args[i].name, tk->tp.args[i].comm);
|
2014-11-08 13:42:10 -07:00
|
|
|
seq_putc(m, '\n');
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations probes_seq_op = {
|
|
|
|
.start = probes_seq_start,
|
|
|
|
.next = probes_seq_next,
|
|
|
|
.stop = probes_seq_stop,
|
|
|
|
.show = probes_seq_show
|
|
|
|
};
|
|
|
|
|
|
|
|
static int probes_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2011-10-04 04:44:38 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = release_all_trace_kprobes();
|
2011-10-04 04:44:38 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
return seq_open(file, &probes_seq_op);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t probes_write(struct file *file, const char __user *buffer,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2012-04-09 03:11:44 -06:00
|
|
|
return traceprobe_probes_write(file, buffer, count, ppos,
|
2013-07-02 22:50:51 -06:00
|
|
|
create_trace_kprobe);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations kprobe_events_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = probes_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
.write = probes_write,
|
|
|
|
};
|
|
|
|
|
2009-08-13 14:35:42 -06:00
|
|
|
/* Probes profiling interfaces */
|
|
|
|
static int probes_profile_seq_show(struct seq_file *m, void *v)
|
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = v;
|
2016-02-03 13:28:28 -07:00
|
|
|
unsigned long nhit = 0;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu)
|
|
|
|
nhit += *per_cpu_ptr(tk->nhit, cpu);
|
2009-08-13 14:35:42 -06:00
|
|
|
|
2014-04-08 15:26:21 -06:00
|
|
|
seq_printf(m, " %-44s %15lu %15lu\n",
|
2016-02-03 13:28:28 -07:00
|
|
|
trace_event_name(&tk->tp.call), nhit,
|
2013-07-02 22:50:51 -06:00
|
|
|
tk->rp.kp.nmissed);
|
2009-08-13 14:35:42 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations profile_seq_op = {
|
|
|
|
.start = probes_seq_start,
|
|
|
|
.next = probes_seq_next,
|
|
|
|
.stop = probes_seq_stop,
|
|
|
|
.show = probes_profile_seq_show
|
|
|
|
};
|
|
|
|
|
|
|
|
static int profile_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return seq_open(file, &profile_seq_op);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations kprobe_profile_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = profile_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
/* Kprobe handler */
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline void
|
2013-07-02 22:50:51 -06:00
|
|
|
__kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs,
|
2015-05-05 08:09:53 -06:00
|
|
|
struct trace_event_file *trace_file)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kprobe_trace_entry_head *entry;
|
2009-08-13 14:35:11 -06:00
|
|
|
struct ring_buffer_event *event;
|
2009-09-10 17:09:23 -06:00
|
|
|
struct ring_buffer *buffer;
|
2010-07-05 12:54:45 -06:00
|
|
|
int size, dsize, pc;
|
2009-08-13 14:35:11 -06:00
|
|
|
unsigned long irq_flags;
|
2015-05-05 09:45:27 -06:00
|
|
|
struct trace_event_call *call = &tk->tp.call;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
WARN_ON(call != trace_file->event_call);
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2015-05-13 13:21:25 -06:00
|
|
|
if (trace_trigger_soft_disabled(trace_file))
|
2014-01-06 19:32:10 -07:00
|
|
|
return;
|
2013-05-08 23:44:54 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
local_save_flags(irq_flags);
|
|
|
|
pc = preempt_count();
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
dsize = __get_data_size(&tk->tp, regs);
|
|
|
|
size = sizeof(*entry) + tk->tp.size + dsize;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
event = trace_event_buffer_lock_reserve(&buffer, trace_file,
|
2013-05-08 23:44:49 -06:00
|
|
|
call->event.type,
|
|
|
|
size, irq_flags, pc);
|
2009-08-13 14:35:11 -06:00
|
|
|
if (!event)
|
2010-01-27 18:34:27 -07:00
|
|
|
return;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
entry = ring_buffer_event_data(event);
|
2013-07-02 22:50:51 -06:00
|
|
|
entry->ip = (unsigned long)tk->rp.kp.addr;
|
|
|
|
store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
event_trigger_unlock_commit_regs(trace_file, buffer, event,
|
2014-01-06 19:32:10 -07:00
|
|
|
entry, irq_flags, pc, regs);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static void
|
2013-07-02 22:50:51 -06:00
|
|
|
kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs)
|
2013-05-08 23:44:49 -06:00
|
|
|
{
|
2013-06-20 11:38:14 -06:00
|
|
|
struct event_file_link *link;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
list_for_each_entry_rcu(link, &tk->tp.files, list)
|
|
|
|
__kprobe_trace_func(tk, regs, link->file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kprobe_trace_func);
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
/* Kretprobe handler */
|
2014-04-17 02:18:28 -06:00
|
|
|
static nokprobe_inline void
|
2013-07-02 22:50:51 -06:00
|
|
|
__kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
|
2013-05-08 23:44:49 -06:00
|
|
|
struct pt_regs *regs,
|
2015-05-05 08:09:53 -06:00
|
|
|
struct trace_event_file *trace_file)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kretprobe_trace_entry_head *entry;
|
2009-08-13 14:35:11 -06:00
|
|
|
struct ring_buffer_event *event;
|
2009-09-10 17:09:23 -06:00
|
|
|
struct ring_buffer *buffer;
|
2010-07-05 12:54:45 -06:00
|
|
|
int size, pc, dsize;
|
2009-08-13 14:35:11 -06:00
|
|
|
unsigned long irq_flags;
|
2015-05-05 09:45:27 -06:00
|
|
|
struct trace_event_call *call = &tk->tp.call;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
WARN_ON(call != trace_file->event_call);
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2015-05-13 13:21:25 -06:00
|
|
|
if (trace_trigger_soft_disabled(trace_file))
|
2014-01-06 19:32:10 -07:00
|
|
|
return;
|
2013-05-08 23:44:54 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
local_save_flags(irq_flags);
|
|
|
|
pc = preempt_count();
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
dsize = __get_data_size(&tk->tp, regs);
|
|
|
|
size = sizeof(*entry) + tk->tp.size + dsize;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
event = trace_event_buffer_lock_reserve(&buffer, trace_file,
|
2013-05-08 23:44:49 -06:00
|
|
|
call->event.type,
|
|
|
|
size, irq_flags, pc);
|
2009-08-13 14:35:11 -06:00
|
|
|
if (!event)
|
2010-01-27 18:34:27 -07:00
|
|
|
return;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
entry = ring_buffer_event_data(event);
|
2013-07-02 22:50:51 -06:00
|
|
|
entry->func = (unsigned long)tk->rp.kp.addr;
|
2009-08-13 14:35:11 -06:00
|
|
|
entry->ret_ip = (unsigned long)ri->ret_addr;
|
2013-07-02 22:50:51 -06:00
|
|
|
store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
event_trigger_unlock_commit_regs(trace_file, buffer, event,
|
2014-01-06 19:32:10 -07:00
|
|
|
entry, irq_flags, pc, regs);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static void
|
2013-07-02 22:50:51 -06:00
|
|
|
kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
|
2013-05-08 23:44:49 -06:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
2013-06-20 11:38:14 -06:00
|
|
|
struct event_file_link *link;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
list_for_each_entry_rcu(link, &tk->tp.files, list)
|
|
|
|
__kretprobe_trace_func(tk, ri, regs, link->file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_trace_func);
|
2013-05-08 23:44:49 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
/* Event entry printers */
|
2013-05-13 05:58:39 -06:00
|
|
|
static enum print_line_t
|
2010-04-22 16:46:14 -06:00
|
|
|
print_kprobe_event(struct trace_iterator *iter, int flags,
|
|
|
|
struct trace_event *event)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kprobe_trace_entry_head *field;
|
2009-08-13 14:35:11 -06:00
|
|
|
struct trace_seq *s = &iter->seq;
|
2009-09-10 17:53:38 -06:00
|
|
|
struct trace_probe *tp;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
u8 *data;
|
2009-08-13 14:35:11 -06:00
|
|
|
int i;
|
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
field = (struct kprobe_trace_entry_head *)iter->ent;
|
2010-04-23 08:00:22 -06:00
|
|
|
tp = container_of(event, struct trace_probe, call.event);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-13 12:20:14 -06:00
|
|
|
trace_seq_printf(s, "%s: (", trace_event_name(&tp->call));
|
2009-09-10 17:53:45 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
|
2014-11-12 13:18:16 -07:00
|
|
|
goto out;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
trace_seq_putc(s, ')');
|
2009-08-13 14:35:11 -06:00
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
data = (u8 *)&field[1];
|
|
|
|
for (i = 0; i < tp->nr_args; i++)
|
|
|
|
if (!tp->args[i].type->print(s, tp->args[i].name,
|
2010-07-05 12:54:45 -06:00
|
|
|
data + tp->args[i].offset, field))
|
2014-11-12 13:18:16 -07:00
|
|
|
goto out;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
trace_seq_putc(s, '\n');
|
|
|
|
out:
|
|
|
|
return trace_handle_return(s);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2013-05-13 05:58:39 -06:00
|
|
|
static enum print_line_t
|
2010-04-22 16:46:14 -06:00
|
|
|
print_kretprobe_event(struct trace_iterator *iter, int flags,
|
|
|
|
struct trace_event *event)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kretprobe_trace_entry_head *field;
|
2009-08-13 14:35:11 -06:00
|
|
|
struct trace_seq *s = &iter->seq;
|
2009-09-10 17:53:38 -06:00
|
|
|
struct trace_probe *tp;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
u8 *data;
|
2009-08-13 14:35:11 -06:00
|
|
|
int i;
|
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
field = (struct kretprobe_trace_entry_head *)iter->ent;
|
2010-04-23 08:00:22 -06:00
|
|
|
tp = container_of(event, struct trace_probe, call.event);
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2015-05-13 12:20:14 -06:00
|
|
|
trace_seq_printf(s, "%s: (", trace_event_name(&tp->call));
|
2009-09-10 17:53:45 -06:00
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
|
2014-11-12 13:18:16 -07:00
|
|
|
goto out;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
trace_seq_puts(s, " <- ");
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
|
2014-11-12 13:18:16 -07:00
|
|
|
goto out;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
trace_seq_putc(s, ')');
|
2009-08-13 14:35:11 -06:00
|
|
|
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
data = (u8 *)&field[1];
|
|
|
|
for (i = 0; i < tp->nr_args; i++)
|
|
|
|
if (!tp->args[i].type->print(s, tp->args[i].name,
|
2010-07-05 12:54:45 -06:00
|
|
|
data + tp->args[i].offset, field))
|
2014-11-12 13:18:16 -07:00
|
|
|
goto out;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
trace_seq_putc(s, '\n');
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-11-12 13:18:16 -07:00
|
|
|
out:
|
|
|
|
return trace_handle_return(s);
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-05 09:45:27 -06:00
|
|
|
static int kprobe_event_define_fields(struct trace_event_call *event_call)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
|
|
|
int ret, i;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kprobe_trace_entry_head field;
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = (struct trace_kprobe *)event_call->data;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2009-10-07 16:28:07 -06:00
|
|
|
DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
|
2009-09-10 17:53:38 -06:00
|
|
|
/* Set argument names as fields */
|
2013-07-02 22:50:51 -06:00
|
|
|
for (i = 0; i < tk->tp.nr_args; i++) {
|
|
|
|
struct probe_arg *parg = &tk->tp.args[i];
|
|
|
|
|
|
|
|
ret = trace_define_field(event_call, parg->type->fmttype,
|
|
|
|
parg->name,
|
|
|
|
sizeof(field) + parg->offset,
|
|
|
|
parg->type->size,
|
|
|
|
parg->type->is_signed,
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
FILTER_OTHER);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-05 09:45:27 -06:00
|
|
|
static int kretprobe_event_define_fields(struct trace_event_call *event_call)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
|
|
|
int ret, i;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kretprobe_trace_entry_head field;
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = (struct trace_kprobe *)event_call->data;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2009-10-07 16:28:07 -06:00
|
|
|
DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
|
|
|
|
DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
|
2009-09-10 17:53:38 -06:00
|
|
|
/* Set argument names as fields */
|
2013-07-02 22:50:51 -06:00
|
|
|
for (i = 0; i < tk->tp.nr_args; i++) {
|
|
|
|
struct probe_arg *parg = &tk->tp.args[i];
|
|
|
|
|
|
|
|
ret = trace_define_field(event_call, parg->type->fmttype,
|
|
|
|
parg->name,
|
|
|
|
sizeof(field) + parg->offset,
|
|
|
|
parg->type->size,
|
|
|
|
parg->type->is_signed,
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
FILTER_OTHER);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-20 23:27:35 -07:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2009-09-10 17:53:30 -06:00
|
|
|
|
|
|
|
/* Kprobe profile handler */
|
2014-04-17 02:18:28 -06:00
|
|
|
static void
|
2013-07-02 22:50:51 -06:00
|
|
|
kprobe_perf_func(struct trace_kprobe *tk, struct pt_regs *regs)
|
2009-09-10 17:53:30 -06:00
|
|
|
{
|
2015-05-05 09:45:27 -06:00
|
|
|
struct trace_event_call *call = &tk->tp.call;
|
tracing, perf: Implement BPF programs attached to kprobes
BPF programs, attached to kprobes, provide a safe way to execute
user-defined BPF byte-code programs without being able to crash or
hang the kernel in any way. The BPF engine makes sure that such
programs have a finite execution time and that they cannot break
out of their sandbox.
The user interface is to attach to a kprobe via the perf syscall:
struct perf_event_attr attr = {
.type = PERF_TYPE_TRACEPOINT,
.config = event_id,
...
};
event_fd = perf_event_open(&attr,...);
ioctl(event_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
'prog_fd' is a file descriptor associated with BPF program
previously loaded.
'event_id' is an ID of the kprobe created.
Closing 'event_fd':
close(event_fd);
... automatically detaches BPF program from it.
BPF programs can call in-kernel helper functions to:
- lookup/update/delete elements in maps
- probe_read - wraper of probe_kernel_read() used to access any
kernel data structures
BPF programs receive 'struct pt_regs *' as an input ('struct pt_regs' is
architecture dependent) and return 0 to ignore the event and 1 to store
kprobe event into the ring buffer.
Note, kprobes are a fundamentally _not_ a stable kernel ABI,
so BPF programs attached to kprobes must be recompiled for
every kernel version and user must supply correct LINUX_VERSION_CODE
in attr.kern_version during bpf_prog_load() call.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Reviewed-by: Steven Rostedt <rostedt@goodmis.org>
Reviewed-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1427312966-8434-4-git-send-email-ast@plumgrid.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-25 13:49:20 -06:00
|
|
|
struct bpf_prog *prog = call->prog;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kprobe_trace_entry_head *entry;
|
2010-05-19 06:02:22 -06:00
|
|
|
struct hlist_head *head;
|
2010-07-05 12:54:45 -06:00
|
|
|
int size, __size, dsize;
|
2009-11-23 03:37:29 -07:00
|
|
|
int rctx;
|
2009-09-10 17:53:30 -06:00
|
|
|
|
tracing, perf: Implement BPF programs attached to kprobes
BPF programs, attached to kprobes, provide a safe way to execute
user-defined BPF byte-code programs without being able to crash or
hang the kernel in any way. The BPF engine makes sure that such
programs have a finite execution time and that they cannot break
out of their sandbox.
The user interface is to attach to a kprobe via the perf syscall:
struct perf_event_attr attr = {
.type = PERF_TYPE_TRACEPOINT,
.config = event_id,
...
};
event_fd = perf_event_open(&attr,...);
ioctl(event_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
'prog_fd' is a file descriptor associated with BPF program
previously loaded.
'event_id' is an ID of the kprobe created.
Closing 'event_fd':
close(event_fd);
... automatically detaches BPF program from it.
BPF programs can call in-kernel helper functions to:
- lookup/update/delete elements in maps
- probe_read - wraper of probe_kernel_read() used to access any
kernel data structures
BPF programs receive 'struct pt_regs *' as an input ('struct pt_regs' is
architecture dependent) and return 0 to ignore the event and 1 to store
kprobe event into the ring buffer.
Note, kprobes are a fundamentally _not_ a stable kernel ABI,
so BPF programs attached to kprobes must be recompiled for
every kernel version and user must supply correct LINUX_VERSION_CODE
in attr.kern_version during bpf_prog_load() call.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Reviewed-by: Steven Rostedt <rostedt@goodmis.org>
Reviewed-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1427312966-8434-4-git-send-email-ast@plumgrid.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-25 13:49:20 -06:00
|
|
|
if (prog && !trace_call_bpf(prog, regs))
|
|
|
|
return;
|
|
|
|
|
2013-06-20 11:38:06 -06:00
|
|
|
head = this_cpu_ptr(call->perf_events);
|
|
|
|
if (hlist_empty(head))
|
|
|
|
return;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
dsize = __get_data_size(&tk->tp, regs);
|
|
|
|
__size = sizeof(*entry) + tk->tp.size + dsize;
|
2009-09-14 14:49:28 -06:00
|
|
|
size = ALIGN(__size + sizeof(u32), sizeof(u64));
|
|
|
|
size -= sizeof(u32);
|
2009-11-21 21:26:55 -07:00
|
|
|
|
2014-12-16 04:47:34 -07:00
|
|
|
entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx);
|
2010-01-27 18:32:29 -07:00
|
|
|
if (!entry)
|
2010-01-27 18:34:27 -07:00
|
|
|
return;
|
2009-09-25 12:20:12 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
entry->ip = (unsigned long)tk->rp.kp.addr;
|
2010-07-05 12:54:45 -06:00
|
|
|
memset(&entry[1], 0, dsize);
|
2013-07-02 22:50:51 -06:00
|
|
|
store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize);
|
2013-06-20 11:38:11 -06:00
|
|
|
perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL);
|
2009-09-10 17:53:30 -06:00
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kprobe_perf_func);
|
2009-09-10 17:53:30 -06:00
|
|
|
|
|
|
|
/* Kretprobe profile handler */
|
2014-04-17 02:18:28 -06:00
|
|
|
static void
|
2013-07-02 22:50:51 -06:00
|
|
|
kretprobe_perf_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
|
2013-05-08 23:44:41 -06:00
|
|
|
struct pt_regs *regs)
|
2009-09-10 17:53:30 -06:00
|
|
|
{
|
2015-05-05 09:45:27 -06:00
|
|
|
struct trace_event_call *call = &tk->tp.call;
|
tracing, perf: Implement BPF programs attached to kprobes
BPF programs, attached to kprobes, provide a safe way to execute
user-defined BPF byte-code programs without being able to crash or
hang the kernel in any way. The BPF engine makes sure that such
programs have a finite execution time and that they cannot break
out of their sandbox.
The user interface is to attach to a kprobe via the perf syscall:
struct perf_event_attr attr = {
.type = PERF_TYPE_TRACEPOINT,
.config = event_id,
...
};
event_fd = perf_event_open(&attr,...);
ioctl(event_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
'prog_fd' is a file descriptor associated with BPF program
previously loaded.
'event_id' is an ID of the kprobe created.
Closing 'event_fd':
close(event_fd);
... automatically detaches BPF program from it.
BPF programs can call in-kernel helper functions to:
- lookup/update/delete elements in maps
- probe_read - wraper of probe_kernel_read() used to access any
kernel data structures
BPF programs receive 'struct pt_regs *' as an input ('struct pt_regs' is
architecture dependent) and return 0 to ignore the event and 1 to store
kprobe event into the ring buffer.
Note, kprobes are a fundamentally _not_ a stable kernel ABI,
so BPF programs attached to kprobes must be recompiled for
every kernel version and user must supply correct LINUX_VERSION_CODE
in attr.kern_version during bpf_prog_load() call.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Reviewed-by: Steven Rostedt <rostedt@goodmis.org>
Reviewed-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1427312966-8434-4-git-send-email-ast@plumgrid.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-25 13:49:20 -06:00
|
|
|
struct bpf_prog *prog = call->prog;
|
tracing/kprobes: Support basic types on dynamic events
Support basic types of integer (u8, u16, u32, u64, s8, s16, s32, s64) in
kprobe tracer. With this patch, users can specify above basic types on
each arguments after ':'. If omitted, the argument type is set as
unsigned long (u32 or u64, arch-dependent).
e.g.
echo 'p account_system_time+0 hardirq_offset=%si:s32' > kprobe_events
adds a probe recording hardirq_offset in signed-32bits value on the
entry of account_system_time.
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20100412171708.3790.18599.stgit@localhost6.localdomain6>
Signed-off-by: Masami Hiramatsu <mhiramat@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-04-12 11:17:08 -06:00
|
|
|
struct kretprobe_trace_entry_head *entry;
|
2010-05-19 06:02:22 -06:00
|
|
|
struct hlist_head *head;
|
2010-07-05 12:54:45 -06:00
|
|
|
int size, __size, dsize;
|
2009-11-23 03:37:29 -07:00
|
|
|
int rctx;
|
2009-09-10 17:53:30 -06:00
|
|
|
|
tracing, perf: Implement BPF programs attached to kprobes
BPF programs, attached to kprobes, provide a safe way to execute
user-defined BPF byte-code programs without being able to crash or
hang the kernel in any way. The BPF engine makes sure that such
programs have a finite execution time and that they cannot break
out of their sandbox.
The user interface is to attach to a kprobe via the perf syscall:
struct perf_event_attr attr = {
.type = PERF_TYPE_TRACEPOINT,
.config = event_id,
...
};
event_fd = perf_event_open(&attr,...);
ioctl(event_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
'prog_fd' is a file descriptor associated with BPF program
previously loaded.
'event_id' is an ID of the kprobe created.
Closing 'event_fd':
close(event_fd);
... automatically detaches BPF program from it.
BPF programs can call in-kernel helper functions to:
- lookup/update/delete elements in maps
- probe_read - wraper of probe_kernel_read() used to access any
kernel data structures
BPF programs receive 'struct pt_regs *' as an input ('struct pt_regs' is
architecture dependent) and return 0 to ignore the event and 1 to store
kprobe event into the ring buffer.
Note, kprobes are a fundamentally _not_ a stable kernel ABI,
so BPF programs attached to kprobes must be recompiled for
every kernel version and user must supply correct LINUX_VERSION_CODE
in attr.kern_version during bpf_prog_load() call.
Signed-off-by: Alexei Starovoitov <ast@plumgrid.com>
Reviewed-by: Steven Rostedt <rostedt@goodmis.org>
Reviewed-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1427312966-8434-4-git-send-email-ast@plumgrid.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-25 13:49:20 -06:00
|
|
|
if (prog && !trace_call_bpf(prog, regs))
|
|
|
|
return;
|
|
|
|
|
2013-06-20 11:38:06 -06:00
|
|
|
head = this_cpu_ptr(call->perf_events);
|
|
|
|
if (hlist_empty(head))
|
|
|
|
return;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
dsize = __get_data_size(&tk->tp, regs);
|
|
|
|
__size = sizeof(*entry) + tk->tp.size + dsize;
|
2009-09-14 14:49:28 -06:00
|
|
|
size = ALIGN(__size + sizeof(u32), sizeof(u64));
|
|
|
|
size -= sizeof(u32);
|
tracing, perf_events: Protect the buffer from recursion in perf
While tracing using events with perf, if one enables the
lockdep:lock_acquire event, it will infect every other perf
trace events.
Basically, you can enable whatever set of trace events through
perf but if this event is part of the set, the only result we
can get is a long list of lock_acquire events of rcu read lock,
and only that.
This is because of a recursion inside perf.
1) When a trace event is triggered, it will fill a per cpu
buffer and submit it to perf.
2) Perf will commit this event but will also protect some data
using rcu_read_lock
3) A recursion appears: rcu_read_lock triggers a lock_acquire
event that will fill the per cpu event and then submit the
buffer to perf.
4) Perf detects a recursion and ignores it
5) Perf continues its work on the previous event, but its buffer
has been overwritten by the lock_acquire event, it has then
been turned into a lock_acquire event of rcu read lock
Such scenario also happens with lock_release with
rcu_read_unlock().
We could turn the rcu_read_lock() into __rcu_read_lock() to drop
the lock debugging from perf fast path, but that would make us
lose the rcu debugging and that doesn't prevent from other
possible kind of recursion from perf in the future.
This patch adds a recursion protection based on a counter on the
perf trace per cpu buffers to solve the problem.
-v2: Fixed lost whitespace, added reviewed-by tag
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Reviewed-by: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Jason Baron <jbaron@redhat.com>
LKML-Reference: <1257477185-7838-1-git-send-email-fweisbec@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-05 20:13:05 -07:00
|
|
|
|
2014-12-16 04:47:34 -07:00
|
|
|
entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx);
|
2010-01-27 18:32:29 -07:00
|
|
|
if (!entry)
|
2010-01-27 18:34:27 -07:00
|
|
|
return;
|
2009-09-10 17:53:30 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
entry->func = (unsigned long)tk->rp.kp.addr;
|
2009-09-25 12:20:12 -06:00
|
|
|
entry->ret_ip = (unsigned long)ri->ret_addr;
|
2013-07-02 22:50:51 -06:00
|
|
|
store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize);
|
2013-06-20 11:38:11 -06:00
|
|
|
perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL);
|
2009-09-10 17:53:30 -06:00
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_perf_func);
|
2009-12-20 23:27:35 -07:00
|
|
|
#endif /* CONFIG_PERF_EVENTS */
|
2009-09-14 14:49:20 -06:00
|
|
|
|
2013-06-20 11:38:09 -06:00
|
|
|
/*
|
|
|
|
* called by perf_trace_init() or __ftrace_set_clr_event() under event_mutex.
|
|
|
|
*
|
|
|
|
* kprobe_trace_self_tests_init() does enable_trace_probe/disable_trace_probe
|
|
|
|
* lockless, but we can't race with this __init function.
|
|
|
|
*/
|
2015-05-05 09:45:27 -06:00
|
|
|
static int kprobe_register(struct trace_event_call *event,
|
2014-04-17 02:18:00 -06:00
|
|
|
enum trace_reg type, void *data)
|
2010-04-21 10:27:06 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = (struct trace_kprobe *)event->data;
|
2015-05-05 08:09:53 -06:00
|
|
|
struct trace_event_file *file = data;
|
2011-06-27 01:26:44 -06:00
|
|
|
|
2010-04-21 10:27:06 -06:00
|
|
|
switch (type) {
|
|
|
|
case TRACE_REG_REGISTER:
|
2013-07-02 22:50:51 -06:00
|
|
|
return enable_trace_kprobe(tk, file);
|
2010-04-21 10:27:06 -06:00
|
|
|
case TRACE_REG_UNREGISTER:
|
2013-07-02 22:50:51 -06:00
|
|
|
return disable_trace_kprobe(tk, file);
|
2010-04-21 10:27:06 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
|
|
case TRACE_REG_PERF_REGISTER:
|
2013-07-02 22:50:51 -06:00
|
|
|
return enable_trace_kprobe(tk, NULL);
|
2010-04-21 10:27:06 -06:00
|
|
|
case TRACE_REG_PERF_UNREGISTER:
|
2013-07-02 22:50:51 -06:00
|
|
|
return disable_trace_kprobe(tk, NULL);
|
2012-02-15 07:51:49 -07:00
|
|
|
case TRACE_REG_PERF_OPEN:
|
|
|
|
case TRACE_REG_PERF_CLOSE:
|
2012-02-15 07:51:50 -07:00
|
|
|
case TRACE_REG_PERF_ADD:
|
|
|
|
case TRACE_REG_PERF_DEL:
|
2012-02-15 07:51:49 -07:00
|
|
|
return 0;
|
2010-04-21 10:27:06 -06:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2009-09-14 14:49:20 -06:00
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
|
2009-09-14 14:49:20 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = container_of(kp, struct trace_kprobe, rp.kp);
|
2009-09-10 17:53:30 -06:00
|
|
|
|
2016-02-03 13:28:28 -07:00
|
|
|
raw_cpu_inc(*tk->nhit);
|
2013-05-08 23:44:36 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (tk->tp.flags & TP_FLAG_TRACE)
|
|
|
|
kprobe_trace_func(tk, regs);
|
2009-12-20 23:27:35 -07:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2013-07-02 22:50:51 -06:00
|
|
|
if (tk->tp.flags & TP_FLAG_PROFILE)
|
|
|
|
kprobe_perf_func(tk, regs);
|
2009-12-20 23:27:35 -07:00
|
|
|
#endif
|
2009-09-14 14:49:20 -06:00
|
|
|
return 0; /* We don't tweek kernel, so just return 0 */
|
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kprobe_dispatcher);
|
2009-09-14 14:49:20 -06:00
|
|
|
|
2014-04-17 02:18:28 -06:00
|
|
|
static int
|
|
|
|
kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
|
2009-09-14 14:49:20 -06:00
|
|
|
{
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk = container_of(ri->rp, struct trace_kprobe, rp);
|
2009-09-14 14:49:20 -06:00
|
|
|
|
2016-02-03 13:28:28 -07:00
|
|
|
raw_cpu_inc(*tk->nhit);
|
2013-05-08 23:44:36 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (tk->tp.flags & TP_FLAG_TRACE)
|
|
|
|
kretprobe_trace_func(tk, ri, regs);
|
2009-12-20 23:27:35 -07:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2013-07-02 22:50:51 -06:00
|
|
|
if (tk->tp.flags & TP_FLAG_PROFILE)
|
|
|
|
kretprobe_perf_func(tk, ri, regs);
|
2009-12-20 23:27:35 -07:00
|
|
|
#endif
|
2009-09-14 14:49:20 -06:00
|
|
|
return 0; /* We don't tweek kernel, so just return 0 */
|
|
|
|
}
|
2014-04-17 02:18:28 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_dispatcher);
|
2009-09-10 17:53:30 -06:00
|
|
|
|
2010-04-22 16:46:14 -06:00
|
|
|
static struct trace_event_functions kretprobe_funcs = {
|
|
|
|
.trace = print_kretprobe_event
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct trace_event_functions kprobe_funcs = {
|
|
|
|
.trace = print_kprobe_event
|
|
|
|
};
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static int register_kprobe_event(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2015-05-05 09:45:27 -06:00
|
|
|
struct trace_event_call *call = &tk->tp.call;
|
2009-08-13 14:35:11 -06:00
|
|
|
int ret;
|
|
|
|
|
2015-05-05 09:45:27 -06:00
|
|
|
/* Initialize trace_event_call */
|
2010-05-24 02:24:52 -06:00
|
|
|
INIT_LIST_HEAD(&call->class->fields);
|
2013-07-02 22:50:51 -06:00
|
|
|
if (trace_kprobe_is_return(tk)) {
|
2010-04-23 08:00:22 -06:00
|
|
|
call->event.funcs = &kretprobe_funcs;
|
2010-04-22 08:35:55 -06:00
|
|
|
call->class->define_fields = kretprobe_event_define_fields;
|
2009-08-13 14:35:11 -06:00
|
|
|
} else {
|
2010-04-23 08:00:22 -06:00
|
|
|
call->event.funcs = &kprobe_funcs;
|
2010-04-22 08:35:55 -06:00
|
|
|
call->class->define_fields = kprobe_event_define_fields;
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
2013-07-03 01:09:02 -06:00
|
|
|
if (set_print_fmt(&tk->tp, trace_kprobe_is_return(tk)) < 0)
|
2009-12-15 00:39:49 -07:00
|
|
|
return -ENOMEM;
|
2015-05-05 07:39:12 -06:00
|
|
|
ret = register_trace_event(&call->event);
|
2010-04-23 08:38:03 -06:00
|
|
|
if (!ret) {
|
2009-12-15 00:39:49 -07:00
|
|
|
kfree(call->print_fmt);
|
2009-08-13 14:35:34 -06:00
|
|
|
return -ENODEV;
|
2009-12-15 00:39:49 -07:00
|
|
|
}
|
2015-03-25 13:49:19 -06:00
|
|
|
call->flags = TRACE_EVENT_FL_KPROBE;
|
2010-04-21 10:27:06 -06:00
|
|
|
call->class->reg = kprobe_register;
|
2013-07-02 22:50:51 -06:00
|
|
|
call->data = tk;
|
2009-08-13 14:35:11 -06:00
|
|
|
ret = trace_add_event_call(call);
|
2009-08-13 14:35:34 -06:00
|
|
|
if (ret) {
|
2014-04-08 15:26:21 -06:00
|
|
|
pr_info("Failed to register kprobe event: %s\n",
|
2015-05-13 12:20:14 -06:00
|
|
|
trace_event_name(call));
|
2009-12-15 00:39:49 -07:00
|
|
|
kfree(call->print_fmt);
|
2015-05-05 07:39:12 -06:00
|
|
|
unregister_trace_event(&call->event);
|
2009-08-13 14:35:34 -06:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
static int unregister_kprobe_event(struct trace_kprobe *tk)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
2013-07-03 21:33:50 -06:00
|
|
|
int ret;
|
|
|
|
|
2009-08-13 14:35:34 -06:00
|
|
|
/* tp->event is unregistered in trace_remove_event_call() */
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = trace_remove_event_call(&tk->tp.call);
|
2013-07-03 21:33:50 -06:00
|
|
|
if (!ret)
|
2013-07-02 22:50:51 -06:00
|
|
|
kfree(tk->tp.call.print_fmt);
|
2013-07-03 21:33:50 -06:00
|
|
|
return ret;
|
2009-08-13 14:35:11 -06:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:13:40 -07:00
|
|
|
/* Make a tracefs interface for controlling probe points */
|
2009-08-13 14:35:11 -06:00
|
|
|
static __init int init_kprobe_trace(void)
|
|
|
|
{
|
|
|
|
struct dentry *d_tracer;
|
|
|
|
struct dentry *entry;
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
if (register_module_notifier(&trace_kprobe_module_nb))
|
2011-06-27 01:26:56 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
d_tracer = tracing_init_dentry();
|
2015-01-20 09:14:16 -07:00
|
|
|
if (IS_ERR(d_tracer))
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
|
2015-01-20 10:13:40 -07:00
|
|
|
entry = tracefs_create_file("kprobe_events", 0644, d_tracer,
|
2009-08-13 14:35:11 -06:00
|
|
|
NULL, &kprobe_events_ops);
|
|
|
|
|
2009-08-13 14:35:42 -06:00
|
|
|
/* Event list interface */
|
2009-08-13 14:35:11 -06:00
|
|
|
if (!entry)
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Could not create tracefs 'kprobe_events' entry\n");
|
2009-08-13 14:35:42 -06:00
|
|
|
|
|
|
|
/* Profile interface */
|
2015-01-20 10:13:40 -07:00
|
|
|
entry = tracefs_create_file("kprobe_profile", 0444, d_tracer,
|
2009-08-13 14:35:42 -06:00
|
|
|
NULL, &kprobe_profile_ops);
|
|
|
|
|
|
|
|
if (!entry)
|
2016-03-22 15:28:09 -06:00
|
|
|
pr_warn("Could not create tracefs 'kprobe_profile' entry\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(init_kprobe_trace);
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
|
2011-06-06 20:35:13 -06:00
|
|
|
/*
|
|
|
|
* The "__used" keeps gcc from removing the function symbol
|
|
|
|
* from the kallsyms table.
|
|
|
|
*/
|
|
|
|
static __used int kprobe_trace_selftest_target(int a1, int a2, int a3,
|
|
|
|
int a4, int a5, int a6)
|
2009-08-13 14:35:11 -06:00
|
|
|
{
|
|
|
|
return a1 + a2 + a3 + a4 + a5 + a6;
|
|
|
|
}
|
|
|
|
|
2015-05-05 08:09:53 -06:00
|
|
|
static struct trace_event_file *
|
2013-07-02 22:50:51 -06:00
|
|
|
find_trace_probe_file(struct trace_kprobe *tk, struct trace_array *tr)
|
2013-05-08 23:44:49 -06:00
|
|
|
{
|
2015-05-05 08:09:53 -06:00
|
|
|
struct trace_event_file *file;
|
2013-05-08 23:44:49 -06:00
|
|
|
|
|
|
|
list_for_each_entry(file, &tr->events, list)
|
2013-07-02 22:50:51 -06:00
|
|
|
if (file->event_call == &tk->tp.call)
|
2013-05-08 23:44:49 -06:00
|
|
|
return file;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-06-20 11:38:09 -06:00
|
|
|
/*
|
2013-07-02 22:50:51 -06:00
|
|
|
* Nobody but us can call enable_trace_kprobe/disable_trace_kprobe at this
|
2013-06-20 11:38:09 -06:00
|
|
|
* stage, we can do this lockless.
|
|
|
|
*/
|
2009-08-13 14:35:11 -06:00
|
|
|
static __init int kprobe_trace_self_tests_init(void)
|
|
|
|
{
|
2010-01-13 22:12:12 -07:00
|
|
|
int ret, warn = 0;
|
2009-08-13 14:35:11 -06:00
|
|
|
int (*target)(int, int, int, int, int, int);
|
2013-07-02 22:50:51 -06:00
|
|
|
struct trace_kprobe *tk;
|
2015-05-05 08:09:53 -06:00
|
|
|
struct trace_event_file *file;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2014-06-05 16:35:20 -06:00
|
|
|
if (tracing_is_disabled())
|
|
|
|
return -ENODEV;
|
|
|
|
|
2009-08-13 14:35:11 -06:00
|
|
|
target = kprobe_trace_selftest_target;
|
|
|
|
|
|
|
|
pr_info("Testing kprobe tracing: ");
|
|
|
|
|
2012-04-09 03:11:44 -06:00
|
|
|
ret = traceprobe_command("p:testprobe kprobe_trace_selftest_target "
|
|
|
|
"$stack $stack0 +0($stack)",
|
2013-07-02 22:50:51 -06:00
|
|
|
create_trace_kprobe);
|
2010-01-13 22:12:12 -07:00
|
|
|
if (WARN_ON_ONCE(ret)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on probing function entry.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
|
|
|
} else {
|
|
|
|
/* Enable trace point */
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tk == NULL)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on getting new probe.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else {
|
2013-07-02 22:50:51 -06:00
|
|
|
file = find_trace_probe_file(tk, top_trace_array());
|
2013-05-08 23:44:49 -06:00
|
|
|
if (WARN_ON_ONCE(file == NULL)) {
|
|
|
|
pr_warn("error on getting probe file.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
enable_trace_kprobe(tk, file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2010-01-13 22:12:12 -07:00
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2012-04-09 03:11:44 -06:00
|
|
|
ret = traceprobe_command("r:testprobe2 kprobe_trace_selftest_target "
|
2013-07-02 22:50:51 -06:00
|
|
|
"$retval", create_trace_kprobe);
|
2010-01-13 22:12:12 -07:00
|
|
|
if (WARN_ON_ONCE(ret)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on probing function return.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
|
|
|
} else {
|
|
|
|
/* Enable trace point */
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tk == NULL)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on getting 2nd new probe.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else {
|
2013-07-02 22:50:51 -06:00
|
|
|
file = find_trace_probe_file(tk, top_trace_array());
|
2013-05-08 23:44:49 -06:00
|
|
|
if (WARN_ON_ONCE(file == NULL)) {
|
|
|
|
pr_warn("error on getting probe file.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
enable_trace_kprobe(tk, file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2010-01-13 22:12:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (warn)
|
|
|
|
goto end;
|
2009-08-13 14:35:11 -06:00
|
|
|
|
|
|
|
ret = target(1, 2, 3, 4, 5, 6);
|
|
|
|
|
2011-10-04 04:44:38 -06:00
|
|
|
/* Disable trace points before removing it */
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tk == NULL)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on getting test probe.\n");
|
2011-10-04 04:44:38 -06:00
|
|
|
warn++;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else {
|
2013-07-02 22:50:51 -06:00
|
|
|
file = find_trace_probe_file(tk, top_trace_array());
|
2013-05-08 23:44:49 -06:00
|
|
|
if (WARN_ON_ONCE(file == NULL)) {
|
|
|
|
pr_warn("error on getting probe file.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
disable_trace_kprobe(tk, file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2011-10-04 04:44:38 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tk == NULL)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on getting 2nd test probe.\n");
|
2011-10-04 04:44:38 -06:00
|
|
|
warn++;
|
2013-05-08 23:44:49 -06:00
|
|
|
} else {
|
2013-07-02 22:50:51 -06:00
|
|
|
file = find_trace_probe_file(tk, top_trace_array());
|
2013-05-08 23:44:49 -06:00
|
|
|
if (WARN_ON_ONCE(file == NULL)) {
|
|
|
|
pr_warn("error on getting probe file.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
2013-07-02 22:50:51 -06:00
|
|
|
disable_trace_kprobe(tk, file);
|
2013-05-08 23:44:49 -06:00
|
|
|
}
|
2011-10-04 04:44:38 -06:00
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = traceprobe_command("-:testprobe", create_trace_kprobe);
|
2010-01-13 22:12:12 -07:00
|
|
|
if (WARN_ON_ONCE(ret)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on deleting a probe.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
|
|
|
}
|
|
|
|
|
2013-07-02 22:50:51 -06:00
|
|
|
ret = traceprobe_command("-:testprobe2", create_trace_kprobe);
|
2010-01-13 22:12:12 -07:00
|
|
|
if (WARN_ON_ONCE(ret)) {
|
2013-05-08 23:44:49 -06:00
|
|
|
pr_warn("error on deleting a probe.\n");
|
2010-01-13 22:12:12 -07:00
|
|
|
warn++;
|
|
|
|
}
|
2009-08-13 14:35:11 -06:00
|
|
|
|
2010-01-13 22:12:12 -07:00
|
|
|
end:
|
2013-07-02 22:50:51 -06:00
|
|
|
release_all_trace_kprobes();
|
2010-01-13 22:12:12 -07:00
|
|
|
if (warn)
|
|
|
|
pr_cont("NG: Some tests are failed. Please check them.\n");
|
|
|
|
else
|
|
|
|
pr_cont("OK\n");
|
2009-08-13 14:35:11 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(kprobe_trace_self_tests_init);
|
|
|
|
|
|
|
|
#endif
|