2009-08-13 20:35:11 +00:00
|
|
|
/*
|
2009-11-04 00:12:47 +00:00
|
|
|
* Kprobes-based tracing events
|
2009-08-13 20:35:11 +00: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>
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/ptrace.h>
|
2009-09-23 21:08:43 +00:00
|
|
|
#include <linux/perf_event.h>
|
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 17:17:08 +00:00
|
|
|
#include <linux/stringify.h>
|
2010-07-05 18:54:45 +00:00
|
|
|
#include <linux/limits.h>
|
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 17:17:08 +00:00
|
|
|
#include <asm/bitsperlong.h>
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
#include "trace.h"
|
|
|
|
#include "trace_output.h"
|
|
|
|
|
2009-08-13 20:35:18 +00:00
|
|
|
#define MAX_TRACE_ARGS 128
|
2009-08-13 20:35:11 +00:00
|
|
|
#define MAX_ARGSTR_LEN 63
|
2009-08-13 20:35:26 +00:00
|
|
|
#define MAX_EVENT_NAME_LEN 64
|
2010-07-05 18:54:45 +00:00
|
|
|
#define MAX_STRING_SIZE PATH_MAX
|
2009-09-10 23:53:53 +00:00
|
|
|
#define KPROBE_EVENT_SYSTEM "kprobes"
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-10-07 22:28:07 +00:00
|
|
|
/* Reserved field names */
|
2009-10-07 22:28:14 +00:00
|
|
|
#define FIELD_STRING_IP "__probe_ip"
|
|
|
|
#define FIELD_STRING_RETIP "__probe_ret_ip"
|
|
|
|
#define FIELD_STRING_FUNC "__probe_func"
|
2009-10-07 22:28:07 +00:00
|
|
|
|
|
|
|
const char *reserved_field_names[] = {
|
|
|
|
"common_type",
|
|
|
|
"common_flags",
|
|
|
|
"common_preempt_count",
|
|
|
|
"common_pid",
|
|
|
|
"common_tgid",
|
|
|
|
"common_lock_depth",
|
|
|
|
FIELD_STRING_IP,
|
|
|
|
FIELD_STRING_RETIP,
|
|
|
|
FIELD_STRING_FUNC,
|
|
|
|
};
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
/* Printing function type */
|
2010-07-05 18:54:45 +00:00
|
|
|
typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *,
|
|
|
|
void *);
|
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 17:17:08 +00:00
|
|
|
#define PRINT_TYPE_FUNC_NAME(type) print_type_##type
|
|
|
|
#define PRINT_TYPE_FMT_NAME(type) print_type_format_##type
|
|
|
|
|
|
|
|
/* Printing in basic type function template */
|
|
|
|
#define DEFINE_BASIC_PRINT_TYPE_FUNC(type, fmt, cast) \
|
|
|
|
static __kprobes int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, \
|
2010-07-05 18:54:45 +00:00
|
|
|
const char *name, \
|
|
|
|
void *data, void *ent)\
|
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 17:17:08 +00:00
|
|
|
{ \
|
|
|
|
return trace_seq_printf(s, " %s=" fmt, name, (cast)*(type *)data);\
|
|
|
|
} \
|
|
|
|
static const char PRINT_TYPE_FMT_NAME(type)[] = fmt;
|
|
|
|
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(u8, "%x", unsigned int)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(u16, "%x", unsigned int)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(u32, "%lx", unsigned long)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(u64, "%llx", unsigned long long)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(s8, "%d", int)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(s16, "%d", int)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(s32, "%ld", long)
|
|
|
|
DEFINE_BASIC_PRINT_TYPE_FUNC(s64, "%lld", long long)
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
/* data_rloc: data relative location, compatible with u32 */
|
|
|
|
#define make_data_rloc(len, roffs) \
|
|
|
|
(((u32)(len) << 16) | ((u32)(roffs) & 0xffff))
|
|
|
|
#define get_rloc_len(dl) ((u32)(dl) >> 16)
|
|
|
|
#define get_rloc_offs(dl) ((u32)(dl) & 0xffff)
|
|
|
|
|
|
|
|
static inline void *get_rloc_data(u32 *dl)
|
|
|
|
{
|
|
|
|
return (u8 *)dl + get_rloc_offs(*dl);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For data_loc conversion */
|
|
|
|
static inline void *get_loc_data(u32 *dl, void *ent)
|
|
|
|
{
|
|
|
|
return (u8 *)ent + get_rloc_offs(*dl);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert data_rloc to data_loc:
|
|
|
|
* data_rloc stores the offset from data_rloc itself, but data_loc
|
|
|
|
* stores the offset from event entry.
|
|
|
|
*/
|
|
|
|
#define convert_rloc_to_loc(dl, offs) ((u32)(dl) + (offs))
|
|
|
|
|
|
|
|
/* For defining macros, define string/string_size types */
|
|
|
|
typedef u32 string;
|
|
|
|
typedef u32 string_size;
|
|
|
|
|
|
|
|
/* Print type function for string type */
|
|
|
|
static __kprobes int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s,
|
|
|
|
const char *name,
|
|
|
|
void *data, void *ent)
|
|
|
|
{
|
|
|
|
int len = *(u32 *)data >> 16;
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
return trace_seq_printf(s, " %s=(fault)", name);
|
|
|
|
else
|
|
|
|
return trace_seq_printf(s, " %s=\"%s\"", name,
|
|
|
|
(const char *)get_loc_data(data, ent));
|
|
|
|
}
|
|
|
|
static const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
/* Data fetch function type */
|
|
|
|
typedef void (*fetch_func_t)(struct pt_regs *, void *, void *);
|
|
|
|
|
|
|
|
struct fetch_param {
|
|
|
|
fetch_func_t fn;
|
2009-08-13 20:35:11 +00:00
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
static __kprobes void call_fetch(struct fetch_param *fprm,
|
|
|
|
struct pt_regs *regs, void *dest)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
return fprm->fn(regs, fprm->data, dest);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
#define FETCH_FUNC_NAME(method, type) fetch_##method##_##type
|
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 17:17:08 +00:00
|
|
|
/*
|
|
|
|
* Define macro for basic types - we don't need to define s* types, because
|
|
|
|
* we have to care only about bitwidth at recording time.
|
|
|
|
*/
|
2010-07-05 18:54:45 +00:00
|
|
|
#define DEFINE_BASIC_FETCH_FUNCS(method) \
|
|
|
|
DEFINE_FETCH_##method(u8) \
|
|
|
|
DEFINE_FETCH_##method(u16) \
|
|
|
|
DEFINE_FETCH_##method(u32) \
|
|
|
|
DEFINE_FETCH_##method(u64)
|
|
|
|
|
|
|
|
#define CHECK_FETCH_FUNCS(method, fn) \
|
|
|
|
(((FETCH_FUNC_NAME(method, u8) == fn) || \
|
|
|
|
(FETCH_FUNC_NAME(method, u16) == fn) || \
|
|
|
|
(FETCH_FUNC_NAME(method, u32) == fn) || \
|
|
|
|
(FETCH_FUNC_NAME(method, u64) == fn) || \
|
|
|
|
(FETCH_FUNC_NAME(method, string) == fn) || \
|
|
|
|
(FETCH_FUNC_NAME(method, string_size) == fn)) \
|
|
|
|
&& (fn != NULL))
|
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 17:17:08 +00:00
|
|
|
|
|
|
|
/* Data fetch function templates */
|
|
|
|
#define DEFINE_FETCH_reg(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(reg, type)(struct pt_regs *regs, \
|
2010-07-05 18:54:45 +00:00
|
|
|
void *offset, void *dest) \
|
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 17:17:08 +00:00
|
|
|
{ \
|
|
|
|
*(type *)dest = (type)regs_get_register(regs, \
|
|
|
|
(unsigned int)((unsigned long)offset)); \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(reg)
|
2010-07-05 18:54:45 +00:00
|
|
|
/* No string on the register */
|
|
|
|
#define fetch_reg_string NULL
|
|
|
|
#define fetch_reg_string_size NULL
|
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 17:17:08 +00:00
|
|
|
|
|
|
|
#define DEFINE_FETCH_stack(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs,\
|
|
|
|
void *offset, void *dest) \
|
|
|
|
{ \
|
|
|
|
*(type *)dest = (type)regs_get_kernel_stack_nth(regs, \
|
|
|
|
(unsigned int)((unsigned long)offset)); \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(stack)
|
2010-07-05 18:54:45 +00:00
|
|
|
/* No string on the stack entry */
|
|
|
|
#define fetch_stack_string NULL
|
|
|
|
#define fetch_stack_string_size NULL
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
#define DEFINE_FETCH_retval(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs,\
|
|
|
|
void *dummy, void *dest) \
|
|
|
|
{ \
|
|
|
|
*(type *)dest = (type)regs_return_value(regs); \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(retval)
|
2010-07-05 18:54:45 +00:00
|
|
|
/* No string on the retval */
|
|
|
|
#define fetch_retval_string NULL
|
|
|
|
#define fetch_retval_string_size NULL
|
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 17:17:08 +00:00
|
|
|
|
|
|
|
#define DEFINE_FETCH_memory(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs,\
|
|
|
|
void *addr, void *dest) \
|
|
|
|
{ \
|
|
|
|
type retval; \
|
|
|
|
if (probe_kernel_address(addr, retval)) \
|
|
|
|
*(type *)dest = 0; \
|
|
|
|
else \
|
|
|
|
*(type *)dest = retval; \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(memory)
|
2010-07-05 18:54:45 +00:00
|
|
|
/*
|
|
|
|
* Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max
|
|
|
|
* length and relative data location.
|
|
|
|
*/
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs,
|
|
|
|
void *addr, void *dest)
|
|
|
|
{
|
|
|
|
long ret;
|
|
|
|
int maxlen = get_rloc_len(*(u32 *)dest);
|
|
|
|
u8 *dst = get_rloc_data(dest);
|
|
|
|
u8 *src = addr;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
|
|
|
if (!maxlen)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Try to get string again, since the string can be changed while
|
|
|
|
* probing.
|
|
|
|
*/
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
pagefault_disable();
|
|
|
|
do
|
|
|
|
ret = __copy_from_user_inatomic(dst++, src++, 1);
|
|
|
|
while (dst[-1] && ret == 0 && src - (u8 *)addr < maxlen);
|
|
|
|
dst[-1] = '\0';
|
|
|
|
pagefault_enable();
|
|
|
|
set_fs(old_fs);
|
|
|
|
|
|
|
|
if (ret < 0) { /* Failed to fetch string */
|
|
|
|
((u8 *)get_rloc_data(dest))[0] = '\0';
|
|
|
|
*(u32 *)dest = make_data_rloc(0, get_rloc_offs(*(u32 *)dest));
|
|
|
|
} else
|
|
|
|
*(u32 *)dest = make_data_rloc(src - (u8 *)addr,
|
|
|
|
get_rloc_offs(*(u32 *)dest));
|
|
|
|
}
|
|
|
|
/* Return the length of string -- including null terminal byte */
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(memory, string_size)(struct pt_regs *regs,
|
|
|
|
void *addr, void *dest)
|
|
|
|
{
|
|
|
|
int ret, len = 0;
|
|
|
|
u8 c;
|
|
|
|
mm_segment_t 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;
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
/* Memory fetching by symbol */
|
|
|
|
struct symbol_cache {
|
|
|
|
char *symbol;
|
|
|
|
long offset;
|
|
|
|
unsigned long addr;
|
|
|
|
};
|
|
|
|
|
|
|
|
static 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_symbol_cache(struct symbol_cache *sc)
|
|
|
|
{
|
|
|
|
kfree(sc->symbol);
|
|
|
|
kfree(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static 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;
|
|
|
|
}
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
#define DEFINE_FETCH_symbol(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs,\
|
|
|
|
void *data, void *dest) \
|
|
|
|
{ \
|
|
|
|
struct symbol_cache *sc = data; \
|
|
|
|
if (sc->addr) \
|
|
|
|
fetch_memory_##type(regs, (void *)sc->addr, dest); \
|
|
|
|
else \
|
|
|
|
*(type *)dest = 0; \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(symbol)
|
2010-07-05 18:54:45 +00:00
|
|
|
DEFINE_FETCH_symbol(string)
|
|
|
|
DEFINE_FETCH_symbol(string_size)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
/* Dereference memory access function */
|
|
|
|
struct deref_fetch_param {
|
|
|
|
struct fetch_param orig;
|
2009-08-13 20:35:11 +00:00
|
|
|
long offset;
|
|
|
|
};
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
#define DEFINE_FETCH_deref(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs,\
|
|
|
|
void *data, void *dest) \
|
|
|
|
{ \
|
|
|
|
struct deref_fetch_param *dprm = data; \
|
|
|
|
unsigned long addr; \
|
|
|
|
call_fetch(&dprm->orig, regs, &addr); \
|
|
|
|
if (addr) { \
|
|
|
|
addr += dprm->offset; \
|
|
|
|
fetch_memory_##type(regs, (void *)addr, dest); \
|
|
|
|
} else \
|
|
|
|
*(type *)dest = 0; \
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
DEFINE_BASIC_FETCH_FUNCS(deref)
|
2010-07-05 18:54:45 +00:00
|
|
|
DEFINE_FETCH_deref(string)
|
|
|
|
DEFINE_FETCH_deref(string_size)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
static __kprobes void free_deref_fetch_param(struct deref_fetch_param *data)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
2010-07-05 18:54:45 +00:00
|
|
|
if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
|
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 17:17:08 +00:00
|
|
|
free_deref_fetch_param(data->orig.data);
|
2010-07-05 18:54:45 +00:00
|
|
|
else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
|
2009-08-13 20:35:11 +00:00
|
|
|
free_symbol_cache(data->orig.data);
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
2011-02-04 12:52:05 +00:00
|
|
|
/* Bitfield fetch function */
|
|
|
|
struct bitfield_fetch_param {
|
|
|
|
struct fetch_param orig;
|
|
|
|
unsigned char hi_shift;
|
|
|
|
unsigned char low_shift;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DEFINE_FETCH_bitfield(type) \
|
|
|
|
static __kprobes void FETCH_FUNC_NAME(bitfield, type)(struct pt_regs *regs,\
|
|
|
|
void *data, void *dest) \
|
|
|
|
{ \
|
|
|
|
struct bitfield_fetch_param *bprm = data; \
|
|
|
|
type buf = 0; \
|
|
|
|
call_fetch(&bprm->orig, regs, &buf); \
|
|
|
|
if (buf) { \
|
|
|
|
buf <<= bprm->hi_shift; \
|
|
|
|
buf >>= bprm->low_shift; \
|
|
|
|
} \
|
|
|
|
*(type *)dest = buf; \
|
|
|
|
}
|
|
|
|
DEFINE_BASIC_FETCH_FUNCS(bitfield)
|
|
|
|
#define fetch_bitfield_string NULL
|
|
|
|
#define fetch_bitfield_string_size NULL
|
|
|
|
|
|
|
|
static __kprobes void
|
|
|
|
free_bitfield_fetch_param(struct bitfield_fetch_param *data)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Don't check the bitfield itself, because this must be the
|
|
|
|
* last fetch function.
|
|
|
|
*/
|
|
|
|
if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
|
|
|
|
free_deref_fetch_param(data->orig.data);
|
|
|
|
else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
|
|
|
|
free_symbol_cache(data->orig.data);
|
|
|
|
kfree(data);
|
|
|
|
}
|
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 17:17:08 +00:00
|
|
|
/* Default (unsigned long) fetch type */
|
|
|
|
#define __DEFAULT_FETCH_TYPE(t) u##t
|
|
|
|
#define _DEFAULT_FETCH_TYPE(t) __DEFAULT_FETCH_TYPE(t)
|
|
|
|
#define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
|
|
|
|
#define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
/* Fetch types */
|
|
|
|
enum {
|
|
|
|
FETCH_MTD_reg = 0,
|
|
|
|
FETCH_MTD_stack,
|
|
|
|
FETCH_MTD_retval,
|
|
|
|
FETCH_MTD_memory,
|
|
|
|
FETCH_MTD_symbol,
|
|
|
|
FETCH_MTD_deref,
|
2011-02-04 12:52:05 +00:00
|
|
|
FETCH_MTD_bitfield,
|
2010-07-05 18:54:45 +00:00
|
|
|
FETCH_MTD_END,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ASSIGN_FETCH_FUNC(method, type) \
|
|
|
|
[FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
|
|
|
|
|
|
|
|
#define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype) \
|
|
|
|
{.name = _name, \
|
|
|
|
.size = _size, \
|
|
|
|
.is_signed = sign, \
|
|
|
|
.print = PRINT_TYPE_FUNC_NAME(ptype), \
|
|
|
|
.fmt = PRINT_TYPE_FMT_NAME(ptype), \
|
|
|
|
.fmttype = _fmttype, \
|
|
|
|
.fetch = { \
|
|
|
|
ASSIGN_FETCH_FUNC(reg, ftype), \
|
|
|
|
ASSIGN_FETCH_FUNC(stack, ftype), \
|
|
|
|
ASSIGN_FETCH_FUNC(retval, ftype), \
|
|
|
|
ASSIGN_FETCH_FUNC(memory, ftype), \
|
|
|
|
ASSIGN_FETCH_FUNC(symbol, ftype), \
|
|
|
|
ASSIGN_FETCH_FUNC(deref, ftype), \
|
2011-02-04 12:52:05 +00:00
|
|
|
ASSIGN_FETCH_FUNC(bitfield, ftype), \
|
2010-07-05 18:54:45 +00: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 17:17:08 +00:00
|
|
|
}
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
#define ASSIGN_FETCH_TYPE(ptype, ftype, sign) \
|
|
|
|
__ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
|
|
|
|
|
|
|
|
#define FETCH_TYPE_STRING 0
|
|
|
|
#define FETCH_TYPE_STRSIZE 1
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
/* Fetch type information table */
|
|
|
|
static const struct fetch_type {
|
|
|
|
const char *name; /* Name of type */
|
|
|
|
size_t size; /* Byte size of type */
|
|
|
|
int is_signed; /* Signed flag */
|
|
|
|
print_type_func_t print; /* Print functions */
|
|
|
|
const char *fmt; /* Fromat string */
|
2010-07-05 18:54:45 +00:00
|
|
|
const char *fmttype; /* Name in format file */
|
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 17:17:08 +00:00
|
|
|
/* Fetch functions */
|
2010-07-05 18:54:45 +00:00
|
|
|
fetch_func_t fetch[FETCH_MTD_END];
|
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 17:17:08 +00:00
|
|
|
} fetch_type_table[] = {
|
2010-07-05 18:54:45 +00: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 */
|
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 17:17:08 +00:00
|
|
|
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),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct fetch_type *find_fetch_type(const char *type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!type)
|
|
|
|
type = DEFAULT_FETCH_TYPE_STR;
|
|
|
|
|
2011-02-04 12:52:05 +00:00
|
|
|
/* Special case: bitfield */
|
|
|
|
if (*type == 'b') {
|
|
|
|
unsigned long bs;
|
|
|
|
type = strchr(type, '/');
|
|
|
|
if (!type)
|
|
|
|
goto fail;
|
|
|
|
type++;
|
|
|
|
if (strict_strtoul(type, 0, &bs))
|
|
|
|
goto fail;
|
|
|
|
switch (bs) {
|
|
|
|
case 8:
|
|
|
|
return find_fetch_type("u8");
|
|
|
|
case 16:
|
|
|
|
return find_fetch_type("u16");
|
|
|
|
case 32:
|
|
|
|
return find_fetch_type("u32");
|
|
|
|
case 64:
|
|
|
|
return find_fetch_type("u64");
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(fetch_type_table); i++)
|
|
|
|
if (strcmp(type, fetch_type_table[i].name) == 0)
|
|
|
|
return &fetch_type_table[i];
|
2011-02-04 12:52:05 +00:00
|
|
|
fail:
|
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 17:17:08 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Special function : only accept unsigned long */
|
|
|
|
static __kprobes void fetch_stack_address(struct pt_regs *regs,
|
|
|
|
void *dummy, void *dest)
|
|
|
|
{
|
|
|
|
*(unsigned long *)dest = kernel_stack_pointer(regs);
|
|
|
|
}
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
static fetch_func_t get_fetch_size_function(const struct fetch_type *type,
|
|
|
|
fetch_func_t orig_fn)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (type != &fetch_type_table[FETCH_TYPE_STRING])
|
|
|
|
return NULL; /* Only string type needs size function */
|
|
|
|
for (i = 0; i < FETCH_MTD_END; i++)
|
|
|
|
if (type->fetch[i] == orig_fn)
|
|
|
|
return fetch_type_table[FETCH_TYPE_STRSIZE].fetch[i];
|
|
|
|
|
|
|
|
WARN_ON(1); /* This should not happen */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
/**
|
2009-11-04 00:12:47 +00:00
|
|
|
* Kprobe event core functions
|
2009-08-13 20:35:11 +00:00
|
|
|
*/
|
|
|
|
|
2009-09-10 23:53:38 +00:00
|
|
|
struct probe_arg {
|
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 17:17:08 +00:00
|
|
|
struct fetch_param fetch;
|
2010-07-05 18:54:45 +00:00
|
|
|
struct fetch_param fetch_size;
|
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 17:17:08 +00:00
|
|
|
unsigned int offset; /* Offset from argument entry */
|
|
|
|
const char *name; /* Name of this argument */
|
|
|
|
const char *comm; /* Command of this argument */
|
|
|
|
const struct fetch_type *type; /* Type of this argument */
|
2009-09-10 23:53:38 +00:00
|
|
|
};
|
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
/* Flags for trace_probe */
|
|
|
|
#define TP_FLAG_TRACE 1
|
|
|
|
#define TP_FLAG_PROFILE 2
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
struct trace_probe {
|
|
|
|
struct list_head list;
|
2009-09-11 03:31:21 +00:00
|
|
|
struct kretprobe rp; /* Use rp.kp for kprobe use */
|
2009-08-13 20:35:42 +00:00
|
|
|
unsigned long nhit;
|
2009-09-14 20:49:20 +00:00
|
|
|
unsigned int flags; /* For TP_FLAG_* */
|
2009-08-13 20:35:11 +00:00
|
|
|
const char *symbol; /* symbol name */
|
2010-04-21 16:27:06 +00:00
|
|
|
struct ftrace_event_class class;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct ftrace_event_call call;
|
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 17:17:08 +00:00
|
|
|
ssize_t size; /* trace entry size */
|
2009-08-13 20:35:18 +00:00
|
|
|
unsigned int nr_args;
|
2009-09-10 23:53:38 +00:00
|
|
|
struct probe_arg args[];
|
2009-08-13 20:35:11 +00:00
|
|
|
};
|
|
|
|
|
2009-08-13 20:35:18 +00:00
|
|
|
#define SIZEOF_TRACE_PROBE(n) \
|
|
|
|
(offsetof(struct trace_probe, args) + \
|
2009-09-10 23:53:38 +00:00
|
|
|
(sizeof(struct probe_arg) * (n)))
|
2009-08-13 20:35:18 +00: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 17:17:08 +00:00
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
static __kprobes int probe_is_return(struct trace_probe *tp)
|
|
|
|
{
|
2009-09-11 03:31:21 +00:00
|
|
|
return tp->rp.handler != NULL;
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __kprobes const char *probe_symbol(struct trace_probe *tp)
|
|
|
|
{
|
|
|
|
return tp->symbol ? tp->symbol : "unknown";
|
|
|
|
}
|
|
|
|
|
|
|
|
static int register_probe_event(struct trace_probe *tp);
|
|
|
|
static void unregister_probe_event(struct trace_probe *tp);
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(probe_lock);
|
|
|
|
static LIST_HEAD(probe_list);
|
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
|
|
|
|
static int kretprobe_dispatcher(struct kretprobe_instance *ri,
|
|
|
|
struct pt_regs *regs);
|
|
|
|
|
2010-08-27 11:39:12 +00:00
|
|
|
/* Check the name is good for event/group/fields */
|
|
|
|
static int is_good_name(const char *name)
|
2009-12-16 22:24:08 +00:00
|
|
|
{
|
|
|
|
if (!isalpha(*name) && *name != '_')
|
|
|
|
return 0;
|
|
|
|
while (*++name != '\0') {
|
|
|
|
if (!isalpha(*name) && !isdigit(*name) && *name != '_')
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-09-11 03:31:21 +00:00
|
|
|
/*
|
|
|
|
* Allocate new trace_probe and initialize it (including kprobes).
|
|
|
|
*/
|
2009-09-10 23:53:53 +00:00
|
|
|
static struct trace_probe *alloc_trace_probe(const char *group,
|
|
|
|
const char *event,
|
2009-09-11 03:31:21 +00:00
|
|
|
void *addr,
|
|
|
|
const char *symbol,
|
|
|
|
unsigned long offs,
|
|
|
|
int nargs, int is_return)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
|
|
|
struct trace_probe *tp;
|
2009-12-16 22:24:08 +00:00
|
|
|
int ret = -ENOMEM;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-08-13 20:35:18 +00:00
|
|
|
tp = kzalloc(SIZEOF_TRACE_PROBE(nargs), GFP_KERNEL);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!tp)
|
2009-12-16 22:24:08 +00:00
|
|
|
return ERR_PTR(ret);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
if (symbol) {
|
|
|
|
tp->symbol = kstrdup(symbol, GFP_KERNEL);
|
|
|
|
if (!tp->symbol)
|
|
|
|
goto error;
|
2009-09-11 03:31:21 +00:00
|
|
|
tp->rp.kp.symbol_name = tp->symbol;
|
|
|
|
tp->rp.kp.offset = offs;
|
|
|
|
} else
|
|
|
|
tp->rp.kp.addr = addr;
|
|
|
|
|
|
|
|
if (is_return)
|
2009-09-14 20:49:20 +00:00
|
|
|
tp->rp.handler = kretprobe_dispatcher;
|
2009-09-11 03:31:21 +00:00
|
|
|
else
|
2009-09-14 20:49:20 +00:00
|
|
|
tp->rp.kp.pre_handler = kprobe_dispatcher;
|
2009-09-11 03:31:21 +00:00
|
|
|
|
2010-08-27 11:39:12 +00:00
|
|
|
if (!event || !is_good_name(event)) {
|
2009-12-16 22:24:08 +00:00
|
|
|
ret = -EINVAL;
|
2009-08-13 20:35:26 +00:00
|
|
|
goto error;
|
2009-12-16 22:24:08 +00:00
|
|
|
}
|
|
|
|
|
2010-04-21 16:27:06 +00:00
|
|
|
tp->call.class = &tp->class;
|
2009-08-13 20:35:26 +00:00
|
|
|
tp->call.name = kstrdup(event, GFP_KERNEL);
|
|
|
|
if (!tp->call.name)
|
|
|
|
goto error;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2010-08-27 11:39:12 +00:00
|
|
|
if (!group || !is_good_name(group)) {
|
2009-12-16 22:24:08 +00:00
|
|
|
ret = -EINVAL;
|
2009-09-10 23:53:53 +00:00
|
|
|
goto error;
|
2009-12-16 22:24:08 +00:00
|
|
|
}
|
|
|
|
|
2010-04-21 16:27:06 +00:00
|
|
|
tp->class.system = kstrdup(group, GFP_KERNEL);
|
|
|
|
if (!tp->class.system)
|
2009-09-10 23:53:53 +00:00
|
|
|
goto error;
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
INIT_LIST_HEAD(&tp->list);
|
|
|
|
return tp;
|
|
|
|
error:
|
2009-09-10 23:53:53 +00:00
|
|
|
kfree(tp->call.name);
|
2009-08-13 20:35:11 +00:00
|
|
|
kfree(tp->symbol);
|
|
|
|
kfree(tp);
|
2009-12-16 22:24:08 +00:00
|
|
|
return ERR_PTR(ret);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
2009-09-10 23:53:38 +00:00
|
|
|
static void free_probe_arg(struct probe_arg *arg)
|
|
|
|
{
|
2011-02-04 12:52:05 +00:00
|
|
|
if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
|
|
|
|
free_bitfield_fetch_param(arg->fetch.data);
|
|
|
|
else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
|
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 17:17:08 +00:00
|
|
|
free_deref_fetch_param(arg->fetch.data);
|
2010-07-05 18:54:45 +00:00
|
|
|
else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
|
2009-09-10 23:53:38 +00:00
|
|
|
free_symbol_cache(arg->fetch.data);
|
|
|
|
kfree(arg->name);
|
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 17:17:08 +00:00
|
|
|
kfree(arg->comm);
|
2009-09-10 23:53:38 +00:00
|
|
|
}
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
static void free_trace_probe(struct trace_probe *tp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < tp->nr_args; i++)
|
2009-09-10 23:53:38 +00:00
|
|
|
free_probe_arg(&tp->args[i]);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2010-04-20 14:47:33 +00:00
|
|
|
kfree(tp->call.class->system);
|
2009-08-13 20:35:11 +00:00
|
|
|
kfree(tp->call.name);
|
|
|
|
kfree(tp->symbol);
|
|
|
|
kfree(tp);
|
|
|
|
}
|
|
|
|
|
2009-10-27 20:42:44 +00:00
|
|
|
static struct trace_probe *find_probe_event(const char *event,
|
|
|
|
const char *group)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
|
|
|
struct trace_probe *tp;
|
|
|
|
|
|
|
|
list_for_each_entry(tp, &probe_list, list)
|
2009-10-27 20:42:44 +00:00
|
|
|
if (strcmp(tp->call.name, event) == 0 &&
|
2010-04-20 14:47:33 +00:00
|
|
|
strcmp(tp->call.class->system, group) == 0)
|
2009-08-13 20:35:11 +00:00
|
|
|
return tp;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-09-14 20:48:56 +00:00
|
|
|
/* Unregister a trace_probe and probe_event: call with locking probe_lock */
|
|
|
|
static void unregister_trace_probe(struct trace_probe *tp)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
|
|
|
if (probe_is_return(tp))
|
|
|
|
unregister_kretprobe(&tp->rp);
|
|
|
|
else
|
2009-09-11 03:31:21 +00:00
|
|
|
unregister_kprobe(&tp->rp.kp);
|
2009-08-13 20:35:11 +00:00
|
|
|
list_del(&tp->list);
|
2009-09-14 20:48:56 +00:00
|
|
|
unregister_probe_event(tp);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Register a trace_probe and probe_event */
|
|
|
|
static int register_trace_probe(struct trace_probe *tp)
|
|
|
|
{
|
|
|
|
struct trace_probe *old_tp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&probe_lock);
|
|
|
|
|
2009-09-14 20:48:56 +00:00
|
|
|
/* register as an event */
|
2010-04-20 14:47:33 +00:00
|
|
|
old_tp = find_probe_event(tp->call.name, tp->call.class->system);
|
2009-09-14 20:48:56 +00:00
|
|
|
if (old_tp) {
|
|
|
|
/* delete old event */
|
|
|
|
unregister_trace_probe(old_tp);
|
|
|
|
free_trace_probe(old_tp);
|
|
|
|
}
|
|
|
|
ret = register_probe_event(tp);
|
|
|
|
if (ret) {
|
2010-08-07 10:30:03 +00:00
|
|
|
pr_warning("Failed to register probe event(%d)\n", ret);
|
2009-09-14 20:48:56 +00:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2009-09-14 20:49:37 +00:00
|
|
|
tp->rp.kp.flags |= KPROBE_FLAG_DISABLED;
|
2009-08-13 20:35:11 +00:00
|
|
|
if (probe_is_return(tp))
|
|
|
|
ret = register_kretprobe(&tp->rp);
|
|
|
|
else
|
2009-09-11 03:31:21 +00:00
|
|
|
ret = register_kprobe(&tp->rp.kp);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
pr_warning("Could not insert probe(%d)\n", ret);
|
|
|
|
if (ret == -EILSEQ) {
|
|
|
|
pr_warning("Probing address(0x%p) is not an "
|
|
|
|
"instruction boundary.\n",
|
2009-09-11 03:31:21 +00:00
|
|
|
tp->rp.kp.addr);
|
2009-08-13 20:35:11 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2009-09-14 20:48:56 +00:00
|
|
|
unregister_probe_event(tp);
|
|
|
|
} else
|
|
|
|
list_add_tail(&tp->list, &probe_list);
|
2009-08-13 20:35:11 +00:00
|
|
|
end:
|
|
|
|
mutex_unlock(&probe_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Split symbol and offset. */
|
2009-09-10 23:53:14 +00:00
|
|
|
static int split_symbol_offset(char *symbol, unsigned long *offset)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
|
|
|
char *tmp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!offset)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
tmp = strchr(symbol, '+');
|
|
|
|
if (tmp) {
|
|
|
|
/* skip sign because strict_strtol doesn't accept '+' */
|
2009-09-10 23:53:14 +00:00
|
|
|
ret = strict_strtoul(tmp + 1, 0, offset);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
*tmp = '\0';
|
|
|
|
} else
|
|
|
|
*offset = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PARAM_MAX_ARGS 16
|
|
|
|
#define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
|
|
|
|
|
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 17:17:08 +00:00
|
|
|
static int parse_probe_vars(char *arg, const struct fetch_type *t,
|
|
|
|
struct fetch_param *f, int is_return)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
unsigned long param;
|
|
|
|
|
2009-10-07 22:27:59 +00:00
|
|
|
if (strcmp(arg, "retval") == 0) {
|
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 17:17:08 +00:00
|
|
|
if (is_return)
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_retval];
|
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 17:17:08 +00:00
|
|
|
else
|
2009-08-13 20:35:11 +00:00
|
|
|
ret = -EINVAL;
|
2009-10-07 22:27:59 +00:00
|
|
|
} else if (strncmp(arg, "stack", 5) == 0) {
|
|
|
|
if (arg[5] == '\0') {
|
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 17:17:08 +00:00
|
|
|
if (strcmp(t->name, DEFAULT_FETCH_TYPE_STR) == 0)
|
|
|
|
f->fn = fetch_stack_address;
|
|
|
|
else
|
|
|
|
ret = -EINVAL;
|
2009-10-07 22:27:59 +00:00
|
|
|
} else if (isdigit(arg[5])) {
|
|
|
|
ret = strict_strtoul(arg + 5, 10, ¶m);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (ret || param > PARAM_MAX_STACK)
|
|
|
|
ret = -EINVAL;
|
|
|
|
else {
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_stack];
|
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 17:17:08 +00:00
|
|
|
f->data = (void *)param;
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
2009-10-07 22:27:59 +00:00
|
|
|
} else
|
|
|
|
ret = -EINVAL;
|
|
|
|
} else
|
2009-10-07 22:27:40 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-01 00:19:20 +00:00
|
|
|
/* Recursive argument parser */
|
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 17:17:08 +00:00
|
|
|
static int __parse_probe_arg(char *arg, const struct fetch_type *t,
|
|
|
|
struct fetch_param *f, int is_return)
|
2009-10-07 22:27:40 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
unsigned long param;
|
|
|
|
long offset;
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
switch (arg[0]) {
|
|
|
|
case '$':
|
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 17:17:08 +00:00
|
|
|
ret = parse_probe_vars(arg + 1, t, f, is_return);
|
2009-10-07 22:27:40 +00:00
|
|
|
break;
|
|
|
|
case '%': /* named register */
|
|
|
|
ret = regs_query_register_offset(arg + 1);
|
|
|
|
if (ret >= 0) {
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_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 17:17:08 +00:00
|
|
|
f->data = (void *)(unsigned long)ret;
|
2009-10-07 22:27:40 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
break;
|
2009-08-13 20:35:11 +00:00
|
|
|
case '@': /* memory or symbol */
|
|
|
|
if (isdigit(arg[1])) {
|
|
|
|
ret = strict_strtoul(arg + 1, 0, ¶m);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_memory];
|
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 17:17:08 +00:00
|
|
|
f->data = (void *)param;
|
2009-08-13 20:35:11 +00:00
|
|
|
} else {
|
|
|
|
ret = split_symbol_offset(arg + 1, &offset);
|
|
|
|
if (ret)
|
|
|
|
break;
|
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 17:17:08 +00:00
|
|
|
f->data = alloc_symbol_cache(arg + 1, offset);
|
|
|
|
if (f->data)
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_symbol];
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
break;
|
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 17:17:08 +00:00
|
|
|
case '+': /* deref memory */
|
2011-02-04 12:51:53 +00:00
|
|
|
arg++; /* Skip '+', because strict_strtol() rejects it. */
|
2009-08-13 20:35:11 +00:00
|
|
|
case '-':
|
|
|
|
tmp = strchr(arg, '(');
|
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 17:17:08 +00:00
|
|
|
if (!tmp)
|
2009-08-13 20:35:11 +00:00
|
|
|
break;
|
|
|
|
*tmp = '\0';
|
2011-02-04 12:51:53 +00:00
|
|
|
ret = strict_strtol(arg, 0, &offset);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
arg = tmp + 1;
|
|
|
|
tmp = strrchr(arg, ')');
|
|
|
|
if (tmp) {
|
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 17:17:08 +00:00
|
|
|
struct deref_fetch_param *dprm;
|
|
|
|
const struct fetch_type *t2 = find_fetch_type(NULL);
|
2009-08-13 20:35:11 +00:00
|
|
|
*tmp = '\0';
|
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 17:17:08 +00:00
|
|
|
dprm = kzalloc(sizeof(struct deref_fetch_param),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!dprm)
|
2009-08-13 20:35:11 +00:00
|
|
|
return -ENOMEM;
|
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 17:17:08 +00:00
|
|
|
dprm->offset = offset;
|
|
|
|
ret = __parse_probe_arg(arg, t2, &dprm->orig,
|
|
|
|
is_return);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (ret)
|
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 17:17:08 +00:00
|
|
|
kfree(dprm);
|
2009-08-13 20:35:11 +00:00
|
|
|
else {
|
2010-07-05 18:54:45 +00:00
|
|
|
f->fn = t->fetch[FETCH_MTD_deref];
|
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 17:17:08 +00:00
|
|
|
f->data = (void *)dprm;
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-07-05 18:54:45 +00:00
|
|
|
if (!ret && !f->fn) { /* Parsed, but do not find fetch method */
|
|
|
|
pr_info("%s type has no corresponding fetch method.\n",
|
|
|
|
t->name);
|
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 17:17:08 +00:00
|
|
|
ret = -EINVAL;
|
2010-07-05 18:54:45 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-04 12:52:05 +00:00
|
|
|
#define BYTES_TO_BITS(nb) ((BITS_PER_LONG * (nb)) / sizeof(long))
|
|
|
|
|
|
|
|
/* Bitfield type needs to be parsed into a fetch function */
|
|
|
|
static int __parse_bitfield_probe_arg(const char *bf,
|
|
|
|
const struct fetch_type *t,
|
|
|
|
struct fetch_param *f)
|
|
|
|
{
|
|
|
|
struct bitfield_fetch_param *bprm;
|
|
|
|
unsigned long bw, bo;
|
|
|
|
char *tail;
|
|
|
|
|
|
|
|
if (*bf != 'b')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
|
|
|
|
if (!bprm)
|
|
|
|
return -ENOMEM;
|
|
|
|
bprm->orig = *f;
|
|
|
|
f->fn = t->fetch[FETCH_MTD_bitfield];
|
|
|
|
f->data = (void *)bprm;
|
|
|
|
|
|
|
|
bw = simple_strtoul(bf + 1, &tail, 0); /* Use simple one */
|
|
|
|
if (bw == 0 || *tail != '@')
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
bf = tail + 1;
|
|
|
|
bo = simple_strtoul(bf, &tail, 0);
|
|
|
|
if (tail == bf || *tail != '/')
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
bprm->hi_shift = BYTES_TO_BITS(t->size) - (bw + bo);
|
|
|
|
bprm->low_shift = bprm->hi_shift + bo;
|
|
|
|
return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0;
|
|
|
|
}
|
|
|
|
|
2009-12-01 00:19:20 +00:00
|
|
|
/* String length checking wrapper */
|
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 17:17:08 +00:00
|
|
|
static int parse_probe_arg(char *arg, struct trace_probe *tp,
|
|
|
|
struct probe_arg *parg, int is_return)
|
2009-12-01 00:19:20 +00: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 17:17:08 +00:00
|
|
|
const char *t;
|
2010-07-05 18:54:45 +00:00
|
|
|
int ret;
|
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 17:17:08 +00:00
|
|
|
|
2009-12-01 00:19:20 +00:00
|
|
|
if (strlen(arg) > MAX_ARGSTR_LEN) {
|
|
|
|
pr_info("Argument is too long.: %s\n", arg);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
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 17:17:08 +00:00
|
|
|
parg->comm = kstrdup(arg, GFP_KERNEL);
|
|
|
|
if (!parg->comm) {
|
|
|
|
pr_info("Failed to allocate memory for command '%s'.\n", arg);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
t = strchr(parg->comm, ':');
|
|
|
|
if (t) {
|
|
|
|
arg[t - parg->comm] = '\0';
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
parg->type = find_fetch_type(t);
|
|
|
|
if (!parg->type) {
|
|
|
|
pr_info("Unsupported type: %s\n", t);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
parg->offset = tp->size;
|
|
|
|
tp->size += parg->type->size;
|
2010-07-05 18:54:45 +00:00
|
|
|
ret = __parse_probe_arg(arg, parg->type, &parg->fetch, is_return);
|
2011-02-04 12:52:05 +00:00
|
|
|
if (ret >= 0)
|
|
|
|
ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
|
2010-07-05 18:54:45 +00:00
|
|
|
if (ret >= 0) {
|
|
|
|
parg->fetch_size.fn = get_fetch_size_function(parg->type,
|
|
|
|
parg->fetch.fn);
|
|
|
|
parg->fetch_size.data = parg->fetch.data;
|
|
|
|
}
|
|
|
|
return ret;
|
2009-12-01 00:19:20 +00:00
|
|
|
}
|
|
|
|
|
2009-10-07 22:28:07 +00:00
|
|
|
/* Return 1 if name is reserved or already used by another argument */
|
|
|
|
static int conflict_field_name(const char *name,
|
|
|
|
struct probe_arg *args, int narg)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
|
|
|
|
if (strcmp(reserved_field_names[i], name) == 0)
|
|
|
|
return 1;
|
|
|
|
for (i = 0; i < narg; i++)
|
|
|
|
if (strcmp(args[i].name, name) == 0)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
static int create_trace_probe(int argc, char **argv)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Argument syntax:
|
2009-09-10 23:53:53 +00:00
|
|
|
* - Add kprobe: p[:[GRP/]EVENT] KSYM[+OFFS]|KADDR [FETCHARGS]
|
|
|
|
* - Add kretprobe: r[:[GRP/]EVENT] KSYM[+0] [FETCHARGS]
|
2009-08-13 20:35:11 +00:00
|
|
|
* Fetch args:
|
2009-10-07 22:27:59 +00:00
|
|
|
* $retval : fetch return value
|
|
|
|
* $stack : fetch stack address
|
|
|
|
* $stackN : fetch Nth of stack (N:0-)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
* Dereferencing memory fetch:
|
2009-08-13 20:35:11 +00:00
|
|
|
* +|-offs(ARG) : fetch memory at ARG +|- offs address.
|
2009-09-10 23:53:38 +00: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 17:17:08 +00:00
|
|
|
* Type of args:
|
|
|
|
* FETCHARG:TYPE : use TYPE instead of unsigned long.
|
2009-08-13 20:35:11 +00:00
|
|
|
*/
|
|
|
|
struct trace_probe *tp;
|
|
|
|
int i, ret = 0;
|
2009-12-08 22:03:16 +00:00
|
|
|
int is_return = 0, is_delete = 0;
|
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 17:17:08 +00:00
|
|
|
char *symbol = NULL, *event = NULL, *group = NULL;
|
2010-08-27 11:39:12 +00:00
|
|
|
char *arg;
|
2009-09-10 23:53:14 +00:00
|
|
|
unsigned long offset = 0;
|
2009-08-13 20:35:11 +00:00
|
|
|
void *addr = NULL;
|
2009-09-11 03:31:21 +00:00
|
|
|
char buf[MAX_EVENT_NAME_LEN];
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-12-08 22:03:16 +00:00
|
|
|
/* argc must be >= 1 */
|
2009-08-13 20:35:11 +00:00
|
|
|
if (argv[0][0] == 'p')
|
|
|
|
is_return = 0;
|
|
|
|
else if (argv[0][0] == 'r')
|
|
|
|
is_return = 1;
|
2009-12-08 22:03:16 +00:00
|
|
|
else if (argv[0][0] == '-')
|
|
|
|
is_delete = 1;
|
2009-10-17 00:07:28 +00:00
|
|
|
else {
|
2009-12-08 22:03:16 +00:00
|
|
|
pr_info("Probe definition must be started with 'p', 'r' or"
|
|
|
|
" '-'.\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return -EINVAL;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
if (argv[0][1] == ':') {
|
|
|
|
event = &argv[0][2];
|
2009-09-10 23:53:53 +00:00
|
|
|
if (strchr(event, '/')) {
|
|
|
|
group = event;
|
|
|
|
event = strchr(group, '/') + 1;
|
|
|
|
event[-1] = '\0';
|
|
|
|
if (strlen(group) == 0) {
|
2010-02-24 07:40:23 +00:00
|
|
|
pr_info("Group name is not specified\n");
|
2009-09-10 23:53:53 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
if (strlen(event) == 0) {
|
2010-02-24 07:40:23 +00:00
|
|
|
pr_info("Event name is not specified\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2009-12-08 22:03:16 +00:00
|
|
|
if (!group)
|
|
|
|
group = KPROBE_EVENT_SYSTEM;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-12-08 22:03:16 +00:00
|
|
|
if (is_delete) {
|
|
|
|
if (!event) {
|
|
|
|
pr_info("Delete command needs an event name.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-06-30 08:45:48 +00:00
|
|
|
mutex_lock(&probe_lock);
|
2009-12-08 22:03:16 +00:00
|
|
|
tp = find_probe_event(event, group);
|
|
|
|
if (!tp) {
|
2010-06-30 08:45:48 +00:00
|
|
|
mutex_unlock(&probe_lock);
|
2009-12-08 22:03:16 +00:00
|
|
|
pr_info("Event %s/%s doesn't exist.\n", group, event);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
/* delete an event */
|
|
|
|
unregister_trace_probe(tp);
|
|
|
|
free_trace_probe(tp);
|
2010-06-30 08:45:48 +00:00
|
|
|
mutex_unlock(&probe_lock);
|
2009-12-08 22:03:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argc < 2) {
|
|
|
|
pr_info("Probe point is not specified.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
if (isdigit(argv[1][0])) {
|
2009-10-17 00:07:28 +00:00
|
|
|
if (is_return) {
|
|
|
|
pr_info("Return probe point must be a symbol.\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return -EINVAL;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
/* an address specified */
|
2010-02-10 16:23:47 +00:00
|
|
|
ret = strict_strtoul(&argv[1][0], 0, (unsigned long *)&addr);
|
2009-10-17 00:07:28 +00:00
|
|
|
if (ret) {
|
|
|
|
pr_info("Failed to parse address.\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return ret;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
} else {
|
|
|
|
/* a symbol specified */
|
|
|
|
symbol = argv[1];
|
|
|
|
/* TODO: support .init module functions */
|
|
|
|
ret = split_symbol_offset(symbol, &offset);
|
2009-10-17 00:07:28 +00:00
|
|
|
if (ret) {
|
|
|
|
pr_info("Failed to parse symbol.\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return ret;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
|
|
|
if (offset && is_return) {
|
|
|
|
pr_info("Return probe must be used without offset.\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return -EINVAL;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
2009-08-13 20:35:18 +00:00
|
|
|
argc -= 2; argv += 2;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
/* setup a probe */
|
2009-08-13 20:35:26 +00:00
|
|
|
if (!event) {
|
|
|
|
/* Make a new event name */
|
|
|
|
if (symbol)
|
2009-12-16 22:24:08 +00:00
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
|
2009-08-13 20:35:26 +00:00
|
|
|
is_return ? 'r' : 'p', symbol, offset);
|
|
|
|
else
|
2009-12-16 22:24:08 +00:00
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
|
2009-08-13 20:35:26 +00:00
|
|
|
is_return ? 'r' : 'p', addr);
|
2009-09-11 03:31:21 +00:00
|
|
|
event = buf;
|
|
|
|
}
|
2009-09-10 23:53:53 +00:00
|
|
|
tp = alloc_trace_probe(group, event, addr, symbol, offset, argc,
|
|
|
|
is_return);
|
2009-10-17 00:07:28 +00:00
|
|
|
if (IS_ERR(tp)) {
|
|
|
|
pr_info("Failed to allocate trace_probe.(%d)\n",
|
|
|
|
(int)PTR_ERR(tp));
|
2009-08-13 20:35:11 +00:00
|
|
|
return PTR_ERR(tp);
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
/* parse arguments */
|
2009-08-13 20:35:18 +00:00
|
|
|
ret = 0;
|
|
|
|
for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
|
2010-08-27 11:38:46 +00:00
|
|
|
/* Increment count for freeing args in error case */
|
|
|
|
tp->nr_args++;
|
|
|
|
|
2009-09-10 23:53:38 +00:00
|
|
|
/* Parse argument name */
|
|
|
|
arg = strchr(argv[i], '=');
|
2010-08-27 11:39:06 +00:00
|
|
|
if (arg) {
|
2009-09-10 23:53:38 +00:00
|
|
|
*arg++ = '\0';
|
2010-08-27 11:39:06 +00:00
|
|
|
tp->args[i].name = kstrdup(argv[i], GFP_KERNEL);
|
|
|
|
} else {
|
2009-09-10 23:53:38 +00:00
|
|
|
arg = argv[i];
|
2010-08-27 11:39:06 +00:00
|
|
|
/* If argument name is omitted, set "argN" */
|
|
|
|
snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1);
|
|
|
|
tp->args[i].name = kstrdup(buf, GFP_KERNEL);
|
|
|
|
}
|
2009-10-07 22:28:07 +00:00
|
|
|
|
2009-12-01 00:19:20 +00:00
|
|
|
if (!tp->args[i].name) {
|
2010-08-27 11:39:06 +00:00
|
|
|
pr_info("Failed to allocate argument[%d] name.\n", i);
|
2009-12-01 00:19:20 +00:00
|
|
|
ret = -ENOMEM;
|
2009-08-13 20:35:11 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2010-08-27 11:39:12 +00:00
|
|
|
|
|
|
|
if (!is_good_name(tp->args[i].name)) {
|
|
|
|
pr_info("Invalid argument[%d] name: %s\n",
|
|
|
|
i, tp->args[i].name);
|
|
|
|
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 17:17:08 +00:00
|
|
|
|
|
|
|
if (conflict_field_name(tp->args[i].name, tp->args, i)) {
|
2010-08-27 11:39:06 +00: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 17:17:08 +00:00
|
|
|
"another field.\n", i, argv[i]);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2009-12-01 00:19:20 +00:00
|
|
|
|
|
|
|
/* Parse fetch argument */
|
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 17:17:08 +00:00
|
|
|
ret = parse_probe_arg(arg, tp, &tp->args[i], is_return);
|
2009-10-17 00:07:28 +00:00
|
|
|
if (ret) {
|
2010-08-27 11:39:06 +00:00
|
|
|
pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
|
2009-08-13 20:35:11 +00:00
|
|
|
goto error;
|
2009-10-17 00:07:28 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = register_trace_probe(tp);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
free_trace_probe(tp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cleanup_all_probes(void)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp;
|
|
|
|
|
|
|
|
mutex_lock(&probe_lock);
|
|
|
|
/* TODO: Use batch unregistration */
|
|
|
|
while (!list_empty(&probe_list)) {
|
|
|
|
tp = list_entry(probe_list.next, struct trace_probe, list);
|
|
|
|
unregister_trace_probe(tp);
|
|
|
|
free_trace_probe(tp);
|
|
|
|
}
|
|
|
|
mutex_unlock(&probe_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = 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 17:17:08 +00:00
|
|
|
int i;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
seq_printf(m, "%c", probe_is_return(tp) ? 'r' : 'p');
|
2010-04-20 14:47:33 +00:00
|
|
|
seq_printf(m, ":%s/%s", tp->call.class->system, tp->call.name);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-11-25 08:33:15 +00:00
|
|
|
if (!tp->symbol)
|
|
|
|
seq_printf(m, " 0x%p", tp->rp.kp.addr);
|
|
|
|
else if (tp->rp.kp.offset)
|
2009-09-11 03:31:21 +00:00
|
|
|
seq_printf(m, " %s+%u", probe_symbol(tp), tp->rp.kp.offset);
|
2009-08-13 20:35:11 +00:00
|
|
|
else
|
2009-11-25 08:33:15 +00:00
|
|
|
seq_printf(m, " %s", probe_symbol(tp));
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
for (i = 0; i < tp->nr_args; i++)
|
|
|
|
seq_printf(m, " %s=%s", tp->args[i].name, tp->args[i].comm);
|
2009-08-13 20:35:11 +00:00
|
|
|
seq_printf(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 17:17:08 +00:00
|
|
|
|
2009-08-13 20:35:11 +00: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)
|
|
|
|
{
|
|
|
|
if ((file->f_mode & FMODE_WRITE) &&
|
|
|
|
(file->f_flags & O_TRUNC))
|
|
|
|
cleanup_all_probes();
|
|
|
|
|
|
|
|
return seq_open(file, &probes_seq_op);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int command_trace_probe(const char *buf)
|
|
|
|
{
|
|
|
|
char **argv;
|
|
|
|
int argc = 0, ret = 0;
|
|
|
|
|
|
|
|
argv = argv_split(GFP_KERNEL, buf, &argc);
|
|
|
|
if (!argv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (argc)
|
|
|
|
ret = create_trace_probe(argc, argv);
|
|
|
|
|
|
|
|
argv_free(argv);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-04 12:51:59 +00:00
|
|
|
#define WRITE_BUFSIZE 4096
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
static ssize_t probes_write(struct file *file, const char __user *buffer,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char *kbuf, *tmp;
|
|
|
|
int ret;
|
|
|
|
size_t done;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
kbuf = kmalloc(WRITE_BUFSIZE, GFP_KERNEL);
|
|
|
|
if (!kbuf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = done = 0;
|
|
|
|
while (done < count) {
|
|
|
|
size = count - done;
|
|
|
|
if (size >= WRITE_BUFSIZE)
|
|
|
|
size = WRITE_BUFSIZE - 1;
|
|
|
|
if (copy_from_user(kbuf, buffer + done, size)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
kbuf[size] = '\0';
|
|
|
|
tmp = strchr(kbuf, '\n');
|
|
|
|
if (tmp) {
|
|
|
|
*tmp = '\0';
|
|
|
|
size = tmp - kbuf + 1;
|
|
|
|
} else if (done + size < count) {
|
|
|
|
pr_warning("Line length is too long: "
|
|
|
|
"Should be less than %d.", WRITE_BUFSIZE);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
done += size;
|
|
|
|
/* Remove comments */
|
|
|
|
tmp = strchr(kbuf, '#');
|
|
|
|
if (tmp)
|
|
|
|
*tmp = '\0';
|
|
|
|
|
|
|
|
ret = command_trace_probe(kbuf);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = done;
|
|
|
|
out:
|
|
|
|
kfree(kbuf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 20:35:42 +00:00
|
|
|
/* Probes profiling interfaces */
|
|
|
|
static int probes_profile_seq_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = v;
|
|
|
|
|
|
|
|
seq_printf(m, " %-44s %15lu %15lu\n", tp->call.name, tp->nhit,
|
2009-09-11 03:31:21 +00:00
|
|
|
tp->rp.kp.nmissed);
|
2009-08-13 20:35:42 +00: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,
|
|
|
|
};
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
/* Sum up total data length for dynamic arraies (strings) */
|
|
|
|
static __kprobes int __get_data_size(struct trace_probe *tp,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
u32 len;
|
|
|
|
|
|
|
|
for (i = 0; i < tp->nr_args; i++)
|
|
|
|
if (unlikely(tp->args[i].fetch_size.fn)) {
|
|
|
|
call_fetch(&tp->args[i].fetch_size, regs, &len);
|
|
|
|
ret += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Store the value of each argument */
|
|
|
|
static __kprobes void store_trace_args(int ent_size, struct trace_probe *tp,
|
|
|
|
struct pt_regs *regs,
|
|
|
|
u8 *data, int maxlen)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u32 end = tp->size;
|
|
|
|
u32 *dl; /* Data (relative) location */
|
|
|
|
|
|
|
|
for (i = 0; i < tp->nr_args; i++) {
|
|
|
|
if (unlikely(tp->args[i].fetch_size.fn)) {
|
|
|
|
/*
|
|
|
|
* First, we set the relative location and
|
|
|
|
* maximum data length to *dl
|
|
|
|
*/
|
|
|
|
dl = (u32 *)(data + tp->args[i].offset);
|
|
|
|
*dl = make_data_rloc(maxlen, end - tp->args[i].offset);
|
|
|
|
/* Then try to fetch string or dynamic array data */
|
|
|
|
call_fetch(&tp->args[i].fetch, regs, dl);
|
|
|
|
/* Reduce maximum length */
|
|
|
|
end += get_rloc_len(*dl);
|
|
|
|
maxlen -= get_rloc_len(*dl);
|
|
|
|
/* Trick here, convert data_rloc to data_loc */
|
|
|
|
*dl = convert_rloc_to_loc(*dl,
|
|
|
|
ent_size + tp->args[i].offset);
|
|
|
|
} else
|
|
|
|
/* Just fetching data normally */
|
|
|
|
call_fetch(&tp->args[i].fetch, regs,
|
|
|
|
data + tp->args[i].offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
/* Kprobe handler */
|
2010-01-28 01:34:27 +00:00
|
|
|
static __kprobes void kprobe_trace_func(struct kprobe *kp, struct pt_regs *regs)
|
2009-08-13 20:35:11 +00:00
|
|
|
{
|
2009-09-11 03:31:21 +00:00
|
|
|
struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
|
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 17:17:08 +00:00
|
|
|
struct kprobe_trace_entry_head *entry;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct ring_buffer_event *event;
|
2009-09-10 23:09:23 +00:00
|
|
|
struct ring_buffer *buffer;
|
2010-07-05 18:54:45 +00:00
|
|
|
int size, dsize, pc;
|
2009-08-13 20:35:11 +00:00
|
|
|
unsigned long irq_flags;
|
2009-08-13 20:35:26 +00:00
|
|
|
struct ftrace_event_call *call = &tp->call;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-08-13 20:35:42 +00:00
|
|
|
tp->nhit++;
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
local_save_flags(irq_flags);
|
|
|
|
pc = preempt_count();
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
dsize = __get_data_size(tp, regs);
|
|
|
|
size = sizeof(*entry) + tp->size + dsize;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2010-04-23 14:38:03 +00:00
|
|
|
event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
|
|
|
|
size, irq_flags, pc);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!event)
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
entry = ring_buffer_event_data(event);
|
|
|
|
entry->ip = (unsigned long)kp->addr;
|
2010-07-05 18:54:45 +00:00
|
|
|
store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-09-10 23:09:23 +00:00
|
|
|
if (!filter_current_check_discard(buffer, call, entry, event))
|
|
|
|
trace_nowake_buffer_unlock_commit(buffer, event, irq_flags, pc);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Kretprobe handler */
|
2010-01-28 01:34:27 +00:00
|
|
|
static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri,
|
2009-08-13 20:35:11 +00:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
|
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 17:17:08 +00:00
|
|
|
struct kretprobe_trace_entry_head *entry;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct ring_buffer_event *event;
|
2009-09-10 23:09:23 +00:00
|
|
|
struct ring_buffer *buffer;
|
2010-07-05 18:54:45 +00:00
|
|
|
int size, pc, dsize;
|
2009-08-13 20:35:11 +00:00
|
|
|
unsigned long irq_flags;
|
2009-08-13 20:35:26 +00:00
|
|
|
struct ftrace_event_call *call = &tp->call;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
local_save_flags(irq_flags);
|
|
|
|
pc = preempt_count();
|
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
dsize = __get_data_size(tp, regs);
|
|
|
|
size = sizeof(*entry) + tp->size + dsize;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2010-04-23 14:38:03 +00:00
|
|
|
event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
|
|
|
|
size, irq_flags, pc);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!event)
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
entry = ring_buffer_event_data(event);
|
2009-09-11 03:31:21 +00:00
|
|
|
entry->func = (unsigned long)tp->rp.kp.addr;
|
2009-08-13 20:35:11 +00:00
|
|
|
entry->ret_ip = (unsigned long)ri->ret_addr;
|
2010-07-05 18:54:45 +00:00
|
|
|
store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-09-10 23:09:23 +00:00
|
|
|
if (!filter_current_check_discard(buffer, call, entry, event))
|
|
|
|
trace_nowake_buffer_unlock_commit(buffer, event, irq_flags, pc);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Event entry printers */
|
|
|
|
enum print_line_t
|
2010-04-22 22:46:14 +00:00
|
|
|
print_kprobe_event(struct trace_iterator *iter, int flags,
|
|
|
|
struct trace_event *event)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
struct kprobe_trace_entry_head *field;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct trace_seq *s = &iter->seq;
|
2009-09-10 23:53:38 +00: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 17:17:08 +00:00
|
|
|
u8 *data;
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
field = (struct kprobe_trace_entry_head *)iter->ent;
|
2010-04-23 14:00:22 +00:00
|
|
|
tp = container_of(event, struct trace_probe, call.event);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-09-10 23:53:45 +00:00
|
|
|
if (!trace_seq_printf(s, "%s: (", tp->call.name))
|
|
|
|
goto partial;
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
|
|
|
|
goto partial;
|
|
|
|
|
2009-09-10 23:53:45 +00:00
|
|
|
if (!trace_seq_puts(s, ")"))
|
2009-08-13 20:35:11 +00:00
|
|
|
goto partial;
|
|
|
|
|
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 17:17:08 +00: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 18:54:45 +00:00
|
|
|
data + tp->args[i].offset, field))
|
2009-08-13 20:35:11 +00:00
|
|
|
goto partial;
|
|
|
|
|
|
|
|
if (!trace_seq_puts(s, "\n"))
|
|
|
|
goto partial;
|
|
|
|
|
|
|
|
return TRACE_TYPE_HANDLED;
|
|
|
|
partial:
|
|
|
|
return TRACE_TYPE_PARTIAL_LINE;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum print_line_t
|
2010-04-22 22:46:14 +00:00
|
|
|
print_kretprobe_event(struct trace_iterator *iter, int flags,
|
|
|
|
struct trace_event *event)
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
struct kretprobe_trace_entry_head *field;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct trace_seq *s = &iter->seq;
|
2009-09-10 23:53:38 +00: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 17:17:08 +00:00
|
|
|
u8 *data;
|
2009-08-13 20:35:11 +00: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 17:17:08 +00:00
|
|
|
field = (struct kretprobe_trace_entry_head *)iter->ent;
|
2010-04-23 14:00:22 +00:00
|
|
|
tp = container_of(event, struct trace_probe, call.event);
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2009-09-10 23:53:45 +00:00
|
|
|
if (!trace_seq_printf(s, "%s: (", tp->call.name))
|
|
|
|
goto partial;
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
|
|
|
|
goto partial;
|
|
|
|
|
|
|
|
if (!trace_seq_puts(s, " <- "))
|
|
|
|
goto partial;
|
|
|
|
|
|
|
|
if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
|
|
|
|
goto partial;
|
|
|
|
|
2009-09-10 23:53:45 +00:00
|
|
|
if (!trace_seq_puts(s, ")"))
|
2009-08-13 20:35:11 +00:00
|
|
|
goto partial;
|
|
|
|
|
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 17:17:08 +00: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 18:54:45 +00:00
|
|
|
data + tp->args[i].offset, field))
|
2009-08-13 20:35:11 +00:00
|
|
|
goto partial;
|
|
|
|
|
|
|
|
if (!trace_seq_puts(s, "\n"))
|
|
|
|
goto partial;
|
|
|
|
|
|
|
|
return TRACE_TYPE_HANDLED;
|
|
|
|
partial:
|
|
|
|
return TRACE_TYPE_PARTIAL_LINE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int probe_event_enable(struct ftrace_event_call *call)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = (struct trace_probe *)call->data;
|
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
tp->flags |= TP_FLAG_TRACE;
|
|
|
|
if (probe_is_return(tp))
|
2009-08-13 20:35:11 +00:00
|
|
|
return enable_kretprobe(&tp->rp);
|
2009-09-14 20:49:20 +00:00
|
|
|
else
|
2009-09-11 03:31:21 +00:00
|
|
|
return enable_kprobe(&tp->rp.kp);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void probe_event_disable(struct ftrace_event_call *call)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = (struct trace_probe *)call->data;
|
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
tp->flags &= ~TP_FLAG_TRACE;
|
|
|
|
if (!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE))) {
|
|
|
|
if (probe_is_return(tp))
|
|
|
|
disable_kretprobe(&tp->rp);
|
|
|
|
else
|
|
|
|
disable_kprobe(&tp->rp.kp);
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef DEFINE_FIELD
|
|
|
|
#define DEFINE_FIELD(type, item, name, is_signed) \
|
|
|
|
do { \
|
|
|
|
ret = trace_define_field(event_call, #type, name, \
|
|
|
|
offsetof(typeof(field), item), \
|
|
|
|
sizeof(field.item), is_signed, \
|
|
|
|
FILTER_OTHER); \
|
|
|
|
if (ret) \
|
|
|
|
return ret; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static int kprobe_event_define_fields(struct ftrace_event_call *event_call)
|
|
|
|
{
|
|
|
|
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 17:17:08 +00:00
|
|
|
struct kprobe_trace_entry_head field;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct trace_probe *tp = (struct trace_probe *)event_call->data;
|
|
|
|
|
2009-10-07 22:28:07 +00:00
|
|
|
DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
|
2009-09-10 23:53:38 +00:00
|
|
|
/* Set argument names as fields */
|
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 17:17:08 +00:00
|
|
|
for (i = 0; i < tp->nr_args; i++) {
|
2010-07-05 18:54:45 +00:00
|
|
|
ret = trace_define_field(event_call, tp->args[i].type->fmttype,
|
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 17:17:08 +00:00
|
|
|
tp->args[i].name,
|
|
|
|
sizeof(field) + tp->args[i].offset,
|
|
|
|
tp->args[i].type->size,
|
|
|
|
tp->args[i].type->is_signed,
|
|
|
|
FILTER_OTHER);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int kretprobe_event_define_fields(struct ftrace_event_call *event_call)
|
|
|
|
{
|
|
|
|
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 17:17:08 +00:00
|
|
|
struct kretprobe_trace_entry_head field;
|
2009-08-13 20:35:11 +00:00
|
|
|
struct trace_probe *tp = (struct trace_probe *)event_call->data;
|
|
|
|
|
2009-10-07 22:28:07 +00:00
|
|
|
DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
|
|
|
|
DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
|
2009-09-10 23:53:38 +00:00
|
|
|
/* Set argument names as fields */
|
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 17:17:08 +00:00
|
|
|
for (i = 0; i < tp->nr_args; i++) {
|
2010-07-05 18:54:45 +00:00
|
|
|
ret = trace_define_field(event_call, tp->args[i].type->fmttype,
|
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 17:17:08 +00:00
|
|
|
tp->args[i].name,
|
|
|
|
sizeof(field) + tp->args[i].offset,
|
|
|
|
tp->args[i].type->size,
|
|
|
|
tp->args[i].type->is_signed,
|
|
|
|
FILTER_OTHER);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-15 07:39:49 +00:00
|
|
|
static int __set_print_fmt(struct trace_probe *tp, char *buf, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int pos = 0;
|
|
|
|
|
|
|
|
const char *fmt, *arg;
|
|
|
|
|
|
|
|
if (!probe_is_return(tp)) {
|
|
|
|
fmt = "(%lx)";
|
|
|
|
arg = "REC->" FIELD_STRING_IP;
|
|
|
|
} else {
|
|
|
|
fmt = "(%lx <- %lx)";
|
|
|
|
arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* When len=0, we just calculate the needed length */
|
|
|
|
#define LEN_OR_ZERO (len ? len - pos : 0)
|
|
|
|
|
|
|
|
pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
|
|
|
|
|
|
|
|
for (i = 0; i < tp->nr_args; 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 17:17:08 +00:00
|
|
|
pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%s",
|
|
|
|
tp->args[i].name, tp->args[i].type->fmt);
|
2009-12-15 07:39:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg);
|
|
|
|
|
|
|
|
for (i = 0; i < tp->nr_args; i++) {
|
2010-07-05 18:54:45 +00:00
|
|
|
if (strcmp(tp->args[i].type->name, "string") == 0)
|
|
|
|
pos += snprintf(buf + pos, LEN_OR_ZERO,
|
|
|
|
", __get_str(%s)",
|
|
|
|
tp->args[i].name);
|
|
|
|
else
|
|
|
|
pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s",
|
|
|
|
tp->args[i].name);
|
2009-12-15 07:39:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef LEN_OR_ZERO
|
|
|
|
|
|
|
|
/* return the length of print_fmt */
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int set_print_fmt(struct trace_probe *tp)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
char *print_fmt;
|
|
|
|
|
|
|
|
/* First: called with 0 length to calculate the needed length */
|
|
|
|
len = __set_print_fmt(tp, NULL, 0);
|
|
|
|
print_fmt = kmalloc(len + 1, GFP_KERNEL);
|
|
|
|
if (!print_fmt)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Second: actually write the @print_fmt */
|
|
|
|
__set_print_fmt(tp, print_fmt, len + 1);
|
|
|
|
tp->call.print_fmt = print_fmt;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-21 06:27:35 +00:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2009-09-10 23:53:30 +00:00
|
|
|
|
|
|
|
/* Kprobe profile handler */
|
2010-03-05 04:35:37 +00:00
|
|
|
static __kprobes void kprobe_perf_func(struct kprobe *kp,
|
2009-09-10 23:53:30 +00:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
|
|
|
|
struct ftrace_event_call *call = &tp->call;
|
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 17:17:08 +00:00
|
|
|
struct kprobe_trace_entry_head *entry;
|
2010-05-19 12:02:22 +00:00
|
|
|
struct hlist_head *head;
|
2010-07-05 18:54:45 +00:00
|
|
|
int size, __size, dsize;
|
2009-11-23 10:37:29 +00:00
|
|
|
int rctx;
|
2009-09-10 23:53:30 +00:00
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
dsize = __get_data_size(tp, regs);
|
|
|
|
__size = sizeof(*entry) + tp->size + dsize;
|
2009-09-14 20:49:28 +00:00
|
|
|
size = ALIGN(__size + sizeof(u32), sizeof(u64));
|
|
|
|
size -= sizeof(u32);
|
2010-03-05 04:35:37 +00:00
|
|
|
if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
|
2009-09-25 18:20:12 +00:00
|
|
|
"profile buffer not large enough"))
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
2009-11-22 04:26:55 +00:00
|
|
|
|
2010-05-21 15:49:57 +00:00
|
|
|
entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
|
2010-01-28 01:32:29 +00:00
|
|
|
if (!entry)
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
2009-09-25 18:20:12 +00:00
|
|
|
|
|
|
|
entry->ip = (unsigned long)kp->addr;
|
2010-07-05 18:54:45 +00:00
|
|
|
memset(&entry[1], 0, dsize);
|
|
|
|
store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
|
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-06 03:13:05 +00:00
|
|
|
|
2010-05-21 10:31:09 +00:00
|
|
|
head = this_cpu_ptr(call->perf_events);
|
2010-05-19 12:02:22 +00:00
|
|
|
perf_trace_buf_submit(entry, size, rctx, entry->ip, 1, regs, head);
|
2009-09-10 23:53:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Kretprobe profile handler */
|
2010-03-05 04:35:37 +00:00
|
|
|
static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
|
2009-09-10 23:53:30 +00:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
|
|
|
|
struct ftrace_event_call *call = &tp->call;
|
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 17:17:08 +00:00
|
|
|
struct kretprobe_trace_entry_head *entry;
|
2010-05-19 12:02:22 +00:00
|
|
|
struct hlist_head *head;
|
2010-07-05 18:54:45 +00:00
|
|
|
int size, __size, dsize;
|
2009-11-23 10:37:29 +00:00
|
|
|
int rctx;
|
2009-09-10 23:53:30 +00:00
|
|
|
|
2010-07-05 18:54:45 +00:00
|
|
|
dsize = __get_data_size(tp, regs);
|
|
|
|
__size = sizeof(*entry) + tp->size + dsize;
|
2009-09-14 20:49:28 +00:00
|
|
|
size = ALIGN(__size + sizeof(u32), sizeof(u64));
|
|
|
|
size -= sizeof(u32);
|
2010-03-05 04:35:37 +00:00
|
|
|
if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
|
2009-09-25 18:20:12 +00:00
|
|
|
"profile buffer not large enough"))
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
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-06 03:13:05 +00:00
|
|
|
|
2010-05-21 15:49:57 +00:00
|
|
|
entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
|
2010-01-28 01:32:29 +00:00
|
|
|
if (!entry)
|
2010-01-28 01:34:27 +00:00
|
|
|
return;
|
2009-09-10 23:53:30 +00:00
|
|
|
|
2009-09-25 18:20:12 +00:00
|
|
|
entry->func = (unsigned long)tp->rp.kp.addr;
|
|
|
|
entry->ret_ip = (unsigned long)ri->ret_addr;
|
2010-07-05 18:54:45 +00:00
|
|
|
store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
|
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-06 03:13:05 +00:00
|
|
|
|
2010-05-21 10:31:09 +00:00
|
|
|
head = this_cpu_ptr(call->perf_events);
|
2010-05-19 12:02:22 +00:00
|
|
|
perf_trace_buf_submit(entry, size, rctx, entry->ret_ip, 1, regs, head);
|
2009-09-10 23:53:30 +00:00
|
|
|
}
|
|
|
|
|
2010-03-05 04:35:37 +00:00
|
|
|
static int probe_perf_enable(struct ftrace_event_call *call)
|
2009-09-10 23:53:30 +00:00
|
|
|
{
|
|
|
|
struct trace_probe *tp = (struct trace_probe *)call->data;
|
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
tp->flags |= TP_FLAG_PROFILE;
|
2009-09-23 21:08:43 +00:00
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
if (probe_is_return(tp))
|
2009-09-10 23:53:30 +00:00
|
|
|
return enable_kretprobe(&tp->rp);
|
2009-09-14 20:49:20 +00:00
|
|
|
else
|
2009-09-10 23:53:30 +00:00
|
|
|
return enable_kprobe(&tp->rp.kp);
|
|
|
|
}
|
|
|
|
|
2010-03-05 04:35:37 +00:00
|
|
|
static void probe_perf_disable(struct ftrace_event_call *call)
|
2009-09-10 23:53:30 +00:00
|
|
|
{
|
2009-09-14 20:49:20 +00:00
|
|
|
struct trace_probe *tp = (struct trace_probe *)call->data;
|
|
|
|
|
2009-09-23 21:08:43 +00:00
|
|
|
tp->flags &= ~TP_FLAG_PROFILE;
|
2009-09-14 20:49:20 +00:00
|
|
|
|
2009-09-23 21:08:43 +00:00
|
|
|
if (!(tp->flags & TP_FLAG_TRACE)) {
|
2009-09-14 20:49:20 +00:00
|
|
|
if (probe_is_return(tp))
|
|
|
|
disable_kretprobe(&tp->rp);
|
|
|
|
else
|
|
|
|
disable_kprobe(&tp->rp.kp);
|
|
|
|
}
|
2009-09-10 23:53:30 +00:00
|
|
|
}
|
2009-12-21 06:27:35 +00:00
|
|
|
#endif /* CONFIG_PERF_EVENTS */
|
2009-09-14 20:49:20 +00:00
|
|
|
|
2010-04-21 16:27:06 +00:00
|
|
|
static __kprobes
|
|
|
|
int kprobe_register(struct ftrace_event_call *event, enum trace_reg type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case TRACE_REG_REGISTER:
|
|
|
|
return probe_event_enable(event);
|
|
|
|
case TRACE_REG_UNREGISTER:
|
|
|
|
probe_event_disable(event);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
|
|
case TRACE_REG_PERF_REGISTER:
|
|
|
|
return probe_perf_enable(event);
|
|
|
|
case TRACE_REG_PERF_UNREGISTER:
|
|
|
|
probe_perf_disable(event);
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2009-09-14 20:49:20 +00:00
|
|
|
|
|
|
|
static __kprobes
|
|
|
|
int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
|
2009-09-10 23:53:30 +00:00
|
|
|
|
2009-09-14 20:49:20 +00:00
|
|
|
if (tp->flags & TP_FLAG_TRACE)
|
|
|
|
kprobe_trace_func(kp, regs);
|
2009-12-21 06:27:35 +00:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2009-09-14 20:49:20 +00:00
|
|
|
if (tp->flags & TP_FLAG_PROFILE)
|
2010-03-05 04:35:37 +00:00
|
|
|
kprobe_perf_func(kp, regs);
|
2009-12-21 06:27:35 +00:00
|
|
|
#endif
|
2009-09-14 20:49:20 +00:00
|
|
|
return 0; /* We don't tweek kernel, so just return 0 */
|
|
|
|
}
|
|
|
|
|
|
|
|
static __kprobes
|
|
|
|
int kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
|
|
|
|
|
|
|
|
if (tp->flags & TP_FLAG_TRACE)
|
|
|
|
kretprobe_trace_func(ri, regs);
|
2009-12-21 06:27:35 +00:00
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
2009-09-14 20:49:20 +00:00
|
|
|
if (tp->flags & TP_FLAG_PROFILE)
|
2010-03-05 04:35:37 +00:00
|
|
|
kretprobe_perf_func(ri, regs);
|
2009-12-21 06:27:35 +00:00
|
|
|
#endif
|
2009-09-14 20:49:20 +00:00
|
|
|
return 0; /* We don't tweek kernel, so just return 0 */
|
|
|
|
}
|
2009-09-10 23:53:30 +00:00
|
|
|
|
2010-04-22 22:46:14 +00:00
|
|
|
static struct trace_event_functions kretprobe_funcs = {
|
|
|
|
.trace = print_kretprobe_event
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct trace_event_functions kprobe_funcs = {
|
|
|
|
.trace = print_kprobe_event
|
|
|
|
};
|
|
|
|
|
2009-08-13 20:35:11 +00:00
|
|
|
static int register_probe_event(struct trace_probe *tp)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = &tp->call;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Initialize ftrace_event_call */
|
2010-05-24 08:24:52 +00:00
|
|
|
INIT_LIST_HEAD(&call->class->fields);
|
2009-08-13 20:35:11 +00:00
|
|
|
if (probe_is_return(tp)) {
|
2010-04-23 14:00:22 +00:00
|
|
|
call->event.funcs = &kretprobe_funcs;
|
2010-04-22 14:35:55 +00:00
|
|
|
call->class->define_fields = kretprobe_event_define_fields;
|
2009-08-13 20:35:11 +00:00
|
|
|
} else {
|
2010-04-23 14:00:22 +00:00
|
|
|
call->event.funcs = &kprobe_funcs;
|
2010-04-22 14:35:55 +00:00
|
|
|
call->class->define_fields = kprobe_event_define_fields;
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
2009-12-15 07:39:49 +00:00
|
|
|
if (set_print_fmt(tp) < 0)
|
|
|
|
return -ENOMEM;
|
2010-04-23 14:38:03 +00:00
|
|
|
ret = register_ftrace_event(&call->event);
|
|
|
|
if (!ret) {
|
2009-12-15 07:39:49 +00:00
|
|
|
kfree(call->print_fmt);
|
2009-08-13 20:35:34 +00:00
|
|
|
return -ENODEV;
|
2009-12-15 07:39:49 +00:00
|
|
|
}
|
2010-04-23 15:12:36 +00:00
|
|
|
call->flags = 0;
|
2010-04-21 16:27:06 +00:00
|
|
|
call->class->reg = kprobe_register;
|
2009-08-13 20:35:11 +00:00
|
|
|
call->data = tp;
|
|
|
|
ret = trace_add_event_call(call);
|
2009-08-13 20:35:34 +00:00
|
|
|
if (ret) {
|
2009-08-13 20:35:11 +00:00
|
|
|
pr_info("Failed to register kprobe event: %s\n", call->name);
|
2009-12-15 07:39:49 +00:00
|
|
|
kfree(call->print_fmt);
|
2010-04-23 14:00:22 +00:00
|
|
|
unregister_ftrace_event(&call->event);
|
2009-08-13 20:35:34 +00:00
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unregister_probe_event(struct trace_probe *tp)
|
|
|
|
{
|
2009-08-13 20:35:34 +00:00
|
|
|
/* tp->event is unregistered in trace_remove_event_call() */
|
2009-08-13 20:35:11 +00:00
|
|
|
trace_remove_event_call(&tp->call);
|
2009-12-15 07:39:49 +00:00
|
|
|
kfree(tp->call.print_fmt);
|
2009-08-13 20:35:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a debugfs interface for controling probe points */
|
|
|
|
static __init int init_kprobe_trace(void)
|
|
|
|
{
|
|
|
|
struct dentry *d_tracer;
|
|
|
|
struct dentry *entry;
|
|
|
|
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
|
|
if (!d_tracer)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
entry = debugfs_create_file("kprobe_events", 0644, d_tracer,
|
|
|
|
NULL, &kprobe_events_ops);
|
|
|
|
|
2009-08-13 20:35:42 +00:00
|
|
|
/* Event list interface */
|
2009-08-13 20:35:11 +00:00
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'kprobe_events' entry\n");
|
2009-08-13 20:35:42 +00:00
|
|
|
|
|
|
|
/* Profile interface */
|
|
|
|
entry = debugfs_create_file("kprobe_profile", 0444, d_tracer,
|
|
|
|
NULL, &kprobe_profile_ops);
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'kprobe_profile' entry\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(init_kprobe_trace);
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
|
|
|
|
static int kprobe_trace_selftest_target(int a1, int a2, int a3,
|
|
|
|
int a4, int a5, int a6)
|
|
|
|
{
|
|
|
|
return a1 + a2 + a3 + a4 + a5 + a6;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __init int kprobe_trace_self_tests_init(void)
|
|
|
|
{
|
2010-01-14 05:12:12 +00:00
|
|
|
int ret, warn = 0;
|
2009-08-13 20:35:11 +00:00
|
|
|
int (*target)(int, int, int, int, int, int);
|
2010-01-14 05:12:12 +00:00
|
|
|
struct trace_probe *tp;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
target = kprobe_trace_selftest_target;
|
|
|
|
|
|
|
|
pr_info("Testing kprobe tracing: ");
|
|
|
|
|
|
|
|
ret = command_trace_probe("p:testprobe kprobe_trace_selftest_target "
|
2010-01-14 05:12:12 +00:00
|
|
|
"$stack $stack0 +0($stack)");
|
|
|
|
if (WARN_ON_ONCE(ret)) {
|
|
|
|
pr_warning("error on probing function entry.\n");
|
|
|
|
warn++;
|
|
|
|
} else {
|
|
|
|
/* Enable trace point */
|
|
|
|
tp = find_probe_event("testprobe", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tp == NULL)) {
|
|
|
|
pr_warning("error on getting new probe.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
|
|
|
probe_event_enable(&tp->call);
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
ret = command_trace_probe("r:testprobe2 kprobe_trace_selftest_target "
|
2009-10-17 00:07:20 +00:00
|
|
|
"$retval");
|
2010-01-14 05:12:12 +00:00
|
|
|
if (WARN_ON_ONCE(ret)) {
|
|
|
|
pr_warning("error on probing function return.\n");
|
|
|
|
warn++;
|
|
|
|
} else {
|
|
|
|
/* Enable trace point */
|
|
|
|
tp = find_probe_event("testprobe2", KPROBE_EVENT_SYSTEM);
|
|
|
|
if (WARN_ON_ONCE(tp == NULL)) {
|
|
|
|
pr_warning("error on getting new probe.\n");
|
|
|
|
warn++;
|
|
|
|
} else
|
|
|
|
probe_event_enable(&tp->call);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (warn)
|
|
|
|
goto end;
|
2009-08-13 20:35:11 +00:00
|
|
|
|
|
|
|
ret = target(1, 2, 3, 4, 5, 6);
|
|
|
|
|
2010-01-14 05:12:12 +00:00
|
|
|
ret = command_trace_probe("-:testprobe");
|
|
|
|
if (WARN_ON_ONCE(ret)) {
|
|
|
|
pr_warning("error on deleting a probe.\n");
|
|
|
|
warn++;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = command_trace_probe("-:testprobe2");
|
|
|
|
if (WARN_ON_ONCE(ret)) {
|
|
|
|
pr_warning("error on deleting a probe.\n");
|
|
|
|
warn++;
|
|
|
|
}
|
2009-08-13 20:35:11 +00:00
|
|
|
|
2010-01-14 05:12:12 +00:00
|
|
|
end:
|
|
|
|
cleanup_all_probes();
|
|
|
|
if (warn)
|
|
|
|
pr_cont("NG: Some tests are failed. Please check them.\n");
|
|
|
|
else
|
|
|
|
pr_cont("OK\n");
|
2009-08-13 20:35:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(kprobe_trace_self_tests_init);
|
|
|
|
|
|
|
|
#endif
|