tracing/uprobes: Add support for more fetch methods
cover tracing/uprobes: Add support for more fetch methods
Hello,
This patchset implements memory (address), stack[N], deference, bitfield and retval (it needs uretprobe tho) fetch methods for uprobes. It's based on the previous work [1] done by Hyeoncheol Lee.
Now kprobes and uprobes have their own fetch_type_tables and, in turn, memory and stack access methods. Other fetch methods are shared.
For the dereference method, I added a new argument to fetch functions. It's because for uprobes it needs to know whether the given address is a file offset or a virtual address in an user process. For instance, in case of fetching from a memory directly (like @offset) it should convert the address (offset) to a virtual address of the process, but if it's a dereferencing, the given address already has the virtual address.
To determine this in a fetch function, I passed a pointer to trace_uprobe for direct fetch, and passed NULL for dereference.
[1] https://lkml.org/lkml/2012/11/14/84
Simple example:
# cat foo.c int glob = -1; char str[] = "hello uprobe.";
struct foo {
unsigned int unused: 2;
unsigned int foo: 20;
unsigned int bar: 10;
} foo = {
.foo = 5,
};
int main(int argc, char *argv[])
{
long local = 0x1234;return 127;
}
# gcc -o foo -g foo.c
# objdump -d foo | grep -A9 -F '<main>'
00000000004004b0 <main>:
4004b0: 55 push %rbp
4004b1: 48 89 e5 mov %rsp,%rbp
4004b4: 89 7d ec mov %edi,-0x14(%rbp)
4004b7: 48 89 75 e0 mov %rsi,-0x20(%rbp)
4004bb: 48 c7 45 f8 34 12 00 movq $0x1234,-0x8(%rbp)
4004c2: 00
4004c3: b8 7f 00 00 00 mov $0x7f,%eax
4004c8: 5d pop %rbp
4004c9: c3 retq # nm foo | grep -e glob$ -e str -e foo 00000000006008bc D foo 00000000006008a8 D glob 00000000006008ac D str
# perf probe -x /home/namhyung/tmp/foo -a 'foo=main+0x13 glob=@0x8a8:s32 \
Quoted 1 line
str=@0x8ac:string bit=@0x8bc:b10@2/32 argc=%di local=-0x8(%bp)'
Added new event:
probe_foo:foo (on 0x4c3 with glob=@0x8a8:s32 str=@0x8ac:string
bit=@0x8bc:b10@2/32 argc=%di local=-0x8(%bp))You can now use it in all perf tools, such as:
perf record -e probe_foo:foo -aR sleep 1
# perf record -e probe_foo:foo ./foo [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.001 MB perf.data (~33 samples) ]
# perf script | grep -v ^#
foo 2008 [002 2199.867154: probe_foo:foo (4004c3)
glob=4294967295 str="hello uprobe." bit=5 argc=1 local=1234Note that 4294967295 is 0xffffffff.
Obviously, the perf tools also need to be improved. I'll work on that later.
This patchset is based on the current tip/perf/core. I also put this on my 'uprobe/fetch-v1' branch in my tree:
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung/linux-perf.git
Any comments are welcome, thanks.
Namhyung
Hyeoncheol Lee (2):
tracing/kprobes: Move fetch functions to trace_kprobe.c tracing/kprobes: Add fetch{,_size} member into symbol and deref fetch
method
Namhyung Kim (10):
tracing/kprobes: Make stack and memory fetch functions static tracing/kprobes: Factor out struct trace_probe tracing/uprobes: Convert to struct trace_probe tracing/kprobes: Move common functions to trace_probe.c tracing/kprobes: Remove duplicate set_print_fmt() tracing/uprobes: Fetch args before reserving a ring buffer tracing/uprobes: Fix a comment for uprobe registration syntax tracing/kprobes: Add priv argument to fetch functions tracing/uprobes: Add more fetch functions tracing/uprobes: Add support for full argument access methods
kernel/trace/trace_kprobe.c | 529 ++++++++++++++++++++++---------------------- kernel/trace/trace_probe.c | 451 ++++++++++++++++++------------------- kernel/trace/trace_probe.h | 154 ++++++++++++- kernel/trace/trace_uprobe.c | 429 ++++++++++++++++++++++++----------- 4 files changed, 926 insertions(+), 637 deletions(-)
Signature · 1 line
1.7.11.7
PATCH 1/12 tracing/kprobes: Move fetch functions to trace_kprobe.c
From: Hyeoncheol Lee <[email protected]>
Move kprobes-specific fetch functions to the trace_kprobe.c file. Also define kprobes_fetch_type_table in the .c file. This table is shared with uprobes for now, but the uprobes will get its own table in the later patch.
This is a preparation for supporting more fetch functions to uprobes and no functional changes are intended.
--- kernel/trace/trace_kprobe.c | 110 ++++++++++++++++++++ kernel/trace/trace_probe.c | 242 +++++++------------------------------------- kernel/trace/trace_probe.h | 127 +++++++++++++++++++++++ 3 files changed, 272 insertions(+), 207 deletions(-)
kernel/trace/trace_kprobe.c +110 -0
@@ -796,6 +796,116 @@ static const struct file_operations kprobe_profile_ops = { .release = seq_release, }; +/* +* kprobes-specific fetch functions +*/ +#define DEFINE_FETCH_stack (type) \ +__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)); \ +} +DEFINE_BASIC_FETCH_FUNCS (stack) +/* No string on the stack entry */ +#define fetch_stack_string NULL +#define fetch_stack_string_size NULL + +#define DEFINE_FETCH_memory (type) \ +__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; \ +} +DEFINE_BASIC_FETCH_FUNCS (memory) +/* +* Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max +* length and relative data location. +*/ +__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 */ +__kprobes void FETCH_FUNC_NAME (memory ,string_size )(struct pt_regs *regs, +void *addr,void *dest) +{ +mm_segment_t old_fs; +int ret, len =0 ; +u8 c; + + old_fs =get_fs (); +set_fs (KERNEL_DS ); +pagefault_disable (); + +do { + ret =__copy_from_user_inatomic (&c, (u8 *)addr + len,1 ); + len++; + }while (c && ret ==0 && len <MAX_STRING_SIZE ); + +pagefault_enable (); +set_fs (old_fs); + +if (ret <0 )/* Failed to check the length */ + *(u32 *)dest =0 ; +else + *(u32 *)dest = len; +} + +/* Fetch type information table */ +const struct fetch_type kprobes_fetch_type_table[] = { +/* Special types */ + [FETCH_TYPE_STRING ] =__ASSIGN_FETCH_TYPE ("string" , string, string, +sizeof (u32),1 ,"__data_loc char[]" ), + [FETCH_TYPE_STRSIZE ] =__ASSIGN_FETCH_TYPE ("string_size" , u32, + string_size,sizeof (u32),0 ,"u32" ), +/* Basic types */ +ASSIGN_FETCH_TYPE (u8, u8,0 ), +ASSIGN_FETCH_TYPE (u16, u16,0 ), +ASSIGN_FETCH_TYPE (u32, u32,0 ), +ASSIGN_FETCH_TYPE (u64, u64,0 ), +ASSIGN_FETCH_TYPE (s8, u8,1 ), +ASSIGN_FETCH_TYPE (s16, u16,1 ), +ASSIGN_FETCH_TYPE (s32, u32,1 ), +ASSIGN_FETCH_TYPE (s64, u64,1 ), +}; +/* Sum up total data length for dynamic arraies (strings) */ static __kprobes int __get_data_size (struct trace_probe *tp,struct pt_regs *regs)
kernel/trace/trace_probe.c +35 -207
370 lines not on this page · raw message
kernel/trace/trace_probe.h +127 -0
144 lines not on this page · raw message
Signature · 1 line
1.7.11.7
PATCH 2/12 tracing/kprobes: Add fetch{,_size} member into symbol and deref fetch method
In reply to Namhyung KimFrom: Hyeoncheol Lee <[email protected]>
Those symbol and deref fetch methods access a memory region but they assume it's a kernel memory since uprobes does not support them.
Add ->fetch and ->fetch_size member in order to provide a proper access method for supporting uprobes.
--- kernel/trace/trace_probe.c | 48 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 42 insertions(+), 6 deletions(-)
kernel/trace/trace_probe.c +42 -6
@@ -93,6 +93,8 @@ struct symbol_cache {char *symbol;long offset;unsigned long addr; +fetch_func_t fetch; +fetch_func_t fetch_size; };static unsigned long update_symbol_cache (struct symbol_cache *sc)
@@ -139,18 +141,29 @@ __kprobes void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs, \ { \struct symbol_cache *sc = data; \if (sc->addr) \ - fetch_memory_##type(regs, (void *)sc->addr, dest); \ + sc->fetch (regs, (void *)sc->addr, dest); \else \ *(type *)dest =0 ; \ }DEFINE_BASIC_FETCH_FUNCS (symbol)DEFINE_FETCH_symbol (string ) -DEFINE_FETCH_symbol (string_size) + +__kprobes voidFETCH_FUNC_NAME (symbol, string_size)(struct pt_regs *regs, +void *data,void *dest) +{ +struct symbol_cache *sc = data; +if (sc->addr && sc->fetch_size) + sc->fetch_size (regs, (void *)sc->addr, dest); +else + *(string_size *)dest =0 ; +}/* Dereference memory access function */ struct deref_fetch_param {struct fetch_param orig;long offset; +fetch_func_t fetch; +fetch_func_t fetch_size; };#define DEFINE_FETCH_deref (type) \
@@ -162,13 +175,26 @@ __kprobes void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs, \call_fetch (&dprm->orig, regs, &addr); \if (addr) { \ addr += dprm->offset; \ - fetch_memory_##type(regs, (void *)addr, dest); \ + dprm->fetch (regs, (void *)addr, dest); \ }else \ *(type *)dest =0 ; \ }DEFINE_BASIC_FETCH_FUNCS (deref)DEFINE_FETCH_deref (string ) -DEFINE_FETCH_deref (string_size) + +__kprobes voidFETCH_FUNC_NAME (deref, string_size)(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 && dprm->fetch_size) { + addr += dprm->offset; + dprm->fetch_size (regs, (void *)addr, dest); + }else + *(string_size *)dest =0 ; +}static __kprobes void update_deref_fetch_param (struct deref_fetch_param *data) {
@@ -410,13 +436,20 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t, f->fn = t->fetch[FETCH_MTD_memory]; f->data = (void *)param; }else { +struct symbol_cache *sc; + ret =traceprobe_split_symbol_offset (arg +1 , &offset);if (ret)break ; - f->data =alloc_symbol_cache (arg +1 , offset); -if (f->data) + sc =alloc_symbol_cache (arg +1 , offset); +if (sc) { f->fn = t->fetch[FETCH_MTD_symbol]; + sc->fetch = t->fetch[FETCH_MTD_memory]; + sc->fetch_size =get_fetch_size_function (t, + sc->fetch, ttbl); + f->data = sc; + } }break ;
@@ -448,6 +481,9 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,return -ENOMEM ; dprm->offset = offset; + dprm->fetch = t->fetch[FETCH_MTD_memory]; + dprm->fetch_size =get_fetch_size_function (t, + dprm->fetch, ttbl); ret =parse_probe_arg (arg, t2, &dprm->orig, is_return, is_kprobe);if (ret)
Signature · 1 line
1.7.11.7
PATCH 3/12 tracing/kprobes: Make stack and memory fetch functions static
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
Those fetch functions need to be implemented differently for kprobes and uprobes. Since the symbol and deref fetch functions don't call those directly anymore, we can make them static and implement them separately.
--- kernel/trace/trace_kprobe.c | 8 ++++---- kernel/trace/trace_probe.h | 10 +--------- 2 files changed, 5 insertions(+), 13 deletions(-)
kernel/trace/trace_kprobe.c +4 -4
@@ -800,7 +800,7 @@ static const struct file_operations kprobe_profile_ops = {* kprobes-specific fetch functions */ #define DEFINE_FETCH_stack (type) \ -__kprobes void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs, \ +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, \
@@ -812,7 +812,7 @@ DEFINE_BASIC_FETCH_FUNCS(stack)#define fetch_stack_string_size NULL#define DEFINE_FETCH_memory (type) \ -__kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs, \ +static __kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs,\ void *addr, void *dest) \ { \ type retval; \
@@ -826,7 +826,7 @@ DEFINE_BASIC_FETCH_FUNCS(memory)* Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max * length and relative data location. */ -__kprobes void FETCH_FUNC_NAME (memory ,string )(struct pt_regs *regs, +static __kprobes void FETCH_FUNC_NAME (memory ,string )(struct pt_regs *regs,void *addr,void *dest) {long ret;
@@ -863,7 +863,7 @@ __kprobes void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs, }/* Return the length of string -- including null terminal byte */ -__kprobes void FETCH_FUNC_NAME (memory ,string_size )(struct pt_regs *regs, +static __kprobes void FETCH_FUNC_NAME (memory ,string_size )(struct pt_regs *regs,void *addr,void *dest) {mm_segment_t old_fs;
kernel/trace/trace_probe.h +1 -9
@@ -171,24 +171,16 @@ DECLARE_FETCH_FUNC(method, u32); \DECLARE_FETCH_FUNC (method, u64)/* -* Declare fetch functions +* Declare common fetch functions for both of kprobes and uprobes */DECLARE_BASIC_FETCH_FUNCS (reg);#define fetch_reg_string NULL#define fetch_reg_string_size NULL -DECLARE_BASIC_FETCH_FUNCS (stack); -#define fetch_stack_string NULL -#define fetch_stack_string_size NULL -DECLARE_BASIC_FETCH_FUNCS (retval);#define fetch_retval_string NULL#define fetch_retval_string_size NULL -DECLARE_BASIC_FETCH_FUNCS (memory); -DECLARE_FETCH_FUNC (memory, string); -DECLARE_FETCH_FUNC (memory, string_size); -DECLARE_BASIC_FETCH_FUNCS (symbol);DECLARE_FETCH_FUNC (symbol, string);DECLARE_FETCH_FUNC (symbol, string_size);
Signature · 1 line
1.7.11.7
PATCH 4/12 tracing/kprobes: Factor out struct trace_probe
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
There are functions that can be shared to both of kprobes and uprobes. Separate common data structure to struct trace_probe and use it from the shared functions.
--- kernel/trace/trace_kprobe.c | 340 +++++++++++++++++++++----------------------- kernel/trace/trace_probe.h | 20 +++ 2 files changed, 185 insertions(+), 175 deletions(-)
kernel/trace/trace_kprobe.c +165 -175
@@ -27,70 +27,54 @@/** * Kprobe event core functions */ -struct trace_probe { +struct trace_kprobe {struct list_head list;struct kretprobe rp;/* Use rp.kp for kprobe use */ unsigned long nhit; -unsigned int flags;/* For TP_FLAG_* */ const char *symbol;/* symbol name */ -struct ftrace_event_class class; -struct ftrace_event_call call; -struct ftrace_event_file *__rcu *files; -ssize_t size;/* trace entry size */ -unsigned int nr_args; -struct probe_arg args[]; +struct trace_probe p; }; -#define SIZEOF_TRACE_PROBE (n) \ - (offsetof(struct trace_probe, args) + \ +#define SIZEOF_TRACE_PROBE (n) \ + (offsetof(struct trace_kprobe, p.args) + \ (sizeof(struct probe_arg) * (n))) -static __kprobes bool trace_probe_is_return (struct trace_probe *tp) +static __kprobes bool trace_kprobe_is_return (struct trace_kprobe *tp) {return tp->rp.handler !=NULL ; } -static __kprobes const char *trace_probe_symbol (struct trace_probe *tp) +static __kprobes const char *trace_kprobe_symbol (struct trace_kprobe *tp) {return tp->symbol ? tp->symbol :"unknown" ; } -static __kprobes unsigned long trace_probe_offset (struct trace_probe *tp) +static __kprobes unsigned long trace_kprobe_offset (struct trace_kprobe *tp) {return tp->rp.kp.offset; } -static __kprobes bool trace_probe_is_enabled (struct trace_probe *tp) -{ -return !!(tp->flags & (TP_FLAG_TRACE |TP_FLAG_PROFILE )); -} - -static __kprobes bool trace_probe_is_registered (struct trace_probe *tp) -{ -return !!(tp->flags &TP_FLAG_REGISTERED ); -} - -static __kprobes bool trace_probe_has_gone (struct trace_probe *tp) +static __kprobes bool trace_kprobe_has_gone (struct trace_kprobe *tp) {return !!(kprobe_gone (&tp->rp.kp)); } -static __kprobes bool trace_probe_within_module (struct trace_probe *tp, -struct module *mod) +static __kprobes bool trace_kprobe_within_module (struct trace_kprobe *tp, +struct module *mod) {int len =strlen (mod->name); -const char *name =trace_probe_symbol (tp); +const char *name =trace_kprobe_symbol (tp);return strncmp (mod->name, name, len) ==0 && name[len] ==':' ; } -static __kprobes bool trace_probe_is_on_module (struct trace_probe *tp) +static __kprobes bool trace_kprobe_is_on_module (struct trace_kprobe *tp) { -return !!strchr (trace_probe_symbol (tp),':' ); +return !!strchr (trace_kprobe_symbol (tp),':' ); } -static int register_probe_event (struct trace_probe *tp); -static void unregister_probe_event (struct trace_probe *tp); +static int register_probe_event (struct trace_kprobe *tp); +static void unregister_probe_event (struct trace_kprobe *tp);static DEFINE_MUTEX (probe_lock);static LIST_HEAD (probe_list);
@@ -102,14 +86,14 @@ static int kretprobe_dispatcher(struct kretprobe_instance *ri,/* * Allocate new trace_probe and initialize it (including kprobes). */ -static struct trace_probe *alloc_trace_probe (const char *group, +static struct trace_kprobe *alloc_trace_probe (const char *group,const char *event,void *addr,const char *symbol,unsigned long offs,int nargs,bool is_return) { -struct trace_probe *tp; +struct trace_kprobe *tp;int ret = -ENOMEM ; tp =kzalloc (SIZEOF_TRACE_PROBE (nargs),GFP_KERNEL );
@@ -135,9 +119,9 @@ static struct trace_probe *alloc_trace_probe(const char *group, goto error; } - tp->call.class = &tp->class; - tp->call.name =kstrdup (event,GFP_KERNEL ); -if (!tp->call.name) + tp->p.call.class = &tp->p.class; + tp->p.call.name =kstrdup (event,GFP_KERNEL ); +if (!tp->p.call.name) goto error;if (!group || !is_good_name (group)) {
@@ -145,45 +129,45 @@ static struct trace_probe *alloc_trace_probe(const char *group, goto error; } - tp->class.system =kstrdup (group,GFP_KERNEL ); -if (!tp->class.system) + tp->p.class.system =kstrdup (group,GFP_KERNEL ); +if (!tp->p.class.system) goto error;INIT_LIST_HEAD (&tp->list);return tp; error: -kfree (tp->call.name); +kfree (tp->p.call.name);kfree (tp->symbol);kfree (tp);return ERR_PTR (ret); } -static void free_trace_probe (struct trace_probe *tp) +static void free_trace_probe (struct trace_kprobe *tp) {int i; -for (i =0 ; i < tp->nr_args; i++) -traceprobe_free_probe_arg (&tp->args[i]); +for (i =0 ; i < tp->p.nr_args; i++) +traceprobe_free_probe_arg (&tp->p.args[i]); -kfree (tp->call.class->system); -kfree (tp->call.name); +kfree (tp->p.call.class->system); +kfree (tp->p.call.name);kfree (tp->symbol);kfree (tp); } -static struct trace_probe *find_trace_probe (const char *event, -const char *group) +static struct trace_kprobe *find_trace_probe (const char *event, +const char *group) { -struct trace_probe *tp; +struct trace_kprobe *tp;list_for_each_entry (tp, &probe_list, list) -if (strcmp (tp->call.name, event) ==0 && -strcmp (tp->call.class->system, group) ==0 ) +if (strcmp (tp->p.call.name, event) ==0 && +strcmp (tp->p.call.class->system, group) ==0 )return tp;return NULL ; } -static int trace_probe_nr_files (struct trace_probe *tp) +static int trace_probe_nr_files (struct trace_kprobe *tp) {struct ftrace_event_file **file;int ret =0 ;
@@ -192,7 +176,7 @@ static int trace_probe_nr_files(struct trace_probe *tp)* Since all tp->files updater is protected by probe_enable_lock, * we don't need to lock an rcu_read_lock. */ - file =rcu_dereference_raw (tp->files); + file =rcu_dereference_raw (tp->p.files);if (file)while (*(file++)) ret++;
@@ -207,7 +191,7 @@ static DEFINE_MUTEX(probe_enable_lock);* if the file is NULL, enable "perf" handler, or enable "trace" handler. */ static int -enable_trace_probe (struct trace_probe *tp,struct ftrace_event_file *file) +enable_trace_probe (struct trace_kprobe *tp,struct ftrace_event_file *file) {int ret =0 ;
@@ -217,7 +201,7 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)struct ftrace_event_file **new, **old;int n =trace_probe_nr_files (tp); - old =rcu_dereference_raw (tp->files); + old =rcu_dereference_raw (tp->p.files);/* 1 is for new one and 1 is for stopper */ new =kzalloc ((n +2 ) *sizeof (struct ftrace_event_file *),GFP_KERNEL );
@@ -229,8 +213,8 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file) new[n] = file;/* The last one keeps a NULL */ -rcu_assign_pointer (tp->files, new); - tp->flags |=TP_FLAG_TRACE ; +rcu_assign_pointer (tp->p.files, new); + tp->p.flags |=TP_FLAG_TRACE ;if (old) {/* Make sure the probe is done with old files */
@@ -238,11 +222,11 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)kfree (old); } }else - tp->flags |=TP_FLAG_PROFILE ; + tp->p.flags |=TP_FLAG_PROFILE ; -if (trace_probe_is_enabled (tp) &&trace_probe_is_registered (tp) && - !trace_probe_has_gone (tp)) { -if (trace_probe_is_return (tp)) +if (trace_probe_is_enabled (&tp->p) &&trace_probe_is_registered (&tp->p) && + !trace_kprobe_has_gone (tp)) { +if (trace_kprobe_is_return (tp)) ret =enable_kretprobe (&tp->rp);else ret =enable_kprobe (&tp->rp.kp);
@@ -255,7 +239,7 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file) }static int -trace_probe_file_index (struct trace_probe *tp,struct ftrace_event_file *file) +trace_probe_file_index (struct trace_kprobe *tp,struct ftrace_event_file *file) {struct ftrace_event_file **files;int i;
@@ -264,7 +248,7 @@ trace_probe_file_index(struct trace_probe *tp, struct ftrace_event_file *file)* Since all tp->files updater is protected by probe_enable_lock, * we don't need to lock an rcu_read_lock. */ - files =rcu_dereference_raw (tp->files); + files =rcu_dereference_raw (tp->p.files);if (files) {for (i =0 ; files[i]; i++)if (files[i] == file)
@@ -279,7 +263,7 @@ trace_probe_file_index(struct trace_probe *tp, struct ftrace_event_file *file)* if the file is NULL, disable "perf" handler, or disable "trace" handler. */ static int -disable_trace_probe (struct trace_probe *tp,struct ftrace_event_file *file) +disable_trace_probe (struct trace_kprobe *tp,struct ftrace_event_file *file) {int ret =0 ;
@@ -290,14 +274,14 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)int n =trace_probe_nr_files (tp);int i, j; - old =rcu_dereference_raw (tp->files); + old =rcu_dereference_raw (tp->p.files);if (n ==0 ||trace_probe_file_index (tp, file) <0 ) { ret = -EINVAL ; goto out_unlock; }if (n ==1 ) {/* Remove the last file */ - tp->flags &= ~TP_FLAG_TRACE ; + tp->p.flags &= ~TP_FLAG_TRACE ; new =NULL ; }else { new = kzalloc(n * sizeof(struct ftrace_event_file *),
@@ -313,16 +297,16 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file) new[j++] = old[i]; } -rcu_assign_pointer (tp->files, new); +rcu_assign_pointer (tp->p.files, new);/* Make sure the probe is done with old files */ synchronize_sched ();kfree (old); }else - tp->flags &= ~TP_FLAG_PROFILE ; + tp->p.flags &= ~TP_FLAG_PROFILE ; -if (!trace_probe_is_enabled (tp) &&trace_probe_is_registered (tp)) { -if (trace_probe_is_return (tp)) +if (!trace_probe_is_enabled (&tp->p) &&trace_probe_is_registered (&tp->p)) { +if (trace_kprobe_is_return (tp))disable_kretprobe (&tp->rp);else disable_kprobe (&tp->rp.kp);
@@ -335,33 +319,33 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file) }/* Internal register function - just handle k*probes and flags */ -static int __register_trace_probe (struct trace_probe *tp) +static int __register_trace_probe (struct trace_kprobe *tp) {int i, ret; -if (trace_probe_is_registered (tp)) +if (trace_probe_is_registered (&tp->p))return -EINVAL ; -for (i =0 ; i < tp->nr_args; i++) -traceprobe_update_arg (&tp->args[i]); +for (i =0 ; i < tp->p.nr_args; i++) +traceprobe_update_arg (&tp->p.args[i]);/* Set/clear disabled flag according to tp->flag */ -if (trace_probe_is_enabled (tp)) +if (trace_probe_is_enabled (&tp->p)) tp->rp.kp.flags &= ~KPROBE_FLAG_DISABLED ;else tp->rp.kp.flags |=KPROBE_FLAG_DISABLED ; -if (trace_probe_is_return (tp)) +if (trace_kprobe_is_return (tp)) ret =register_kretprobe (&tp->rp);else ret =register_kprobe (&tp->rp.kp);if (ret ==0 ) - tp->flags |=TP_FLAG_REGISTERED ; + tp->p.flags |=TP_FLAG_REGISTERED ;else {pr_warning ("Could not insert probe at %s+%lu: %d\n" , -trace_probe_symbol (tp),trace_probe_offset (tp), ret); -if (ret == -ENOENT &&trace_probe_is_on_module (tp)) { +trace_kprobe_symbol (tp),trace_kprobe_offset (tp), ret); +if (ret == -ENOENT &&trace_kprobe_is_on_module (tp)) {pr_warning ("This probe might be able to register after" "target module is loaded. Continue.\n" ); ret =0 ;
@@ -377,14 +361,14 @@ static int __register_trace_probe(struct trace_probe *tp) }/* Internal unregister function - just handle k*probes and flags */ -static void __unregister_trace_probe (struct trace_probe *tp) +static void __unregister_trace_probe (struct trace_kprobe *tp) { -if (trace_probe_is_registered (tp)) { -if (trace_probe_is_return (tp)) +if (trace_probe_is_registered (&tp->p)) { +if (trace_kprobe_is_return (tp))unregister_kretprobe (&tp->rp);else unregister_kprobe (&tp->rp.kp); - tp->flags &= ~TP_FLAG_REGISTERED ; + tp->p.flags &= ~TP_FLAG_REGISTERED ;/* Cleanup kprobe for reuse */ if (tp->rp.kp.symbol_name) tp->rp.kp.addr =NULL ;
@@ -392,10 +376,10 @@ static void __unregister_trace_probe(struct trace_probe *tp) }/* Unregister a trace_probe and probe_event: call with locking probe_lock */ -static int unregister_trace_probe (struct trace_probe *tp) +static int unregister_trace_probe (struct trace_kprobe *tp) {/* Enabled event can not be unregistered */ -if (trace_probe_is_enabled (tp)) +if (trace_probe_is_enabled (&tp->p))return -EBUSY ;__unregister_trace_probe (tp);
@@ -406,15 +390,15 @@ static int unregister_trace_probe(struct trace_probe *tp) }/* Register a trace_probe and probe_event */ -static int register_trace_probe (struct trace_probe *tp) +static int register_trace_probe (struct trace_kprobe *tp) { -struct trace_probe *old_tp; +struct trace_kprobe *old_tp;int ret;mutex_lock (&probe_lock);/* Delete old (same name) event if exist */ - old_tp =find_trace_probe (tp->call.name, tp->call.class->system); + old_tp =find_trace_probe (tp->p.call.name, tp->p.call.class->system);if (old_tp) { ret =unregister_trace_probe (old_tp);if (ret <0 )
@@ -446,7 +430,7 @@ static int trace_probe_module_callback(struct notifier_block *nb, unsigned long val, void *data) { struct module *mod = data; -struct trace_probe *tp; +struct trace_kprobe *tp;int ret;if (val !=MODULE_STATE_COMING )
@@ -455,14 +439,14 @@ static int trace_probe_module_callback(struct notifier_block *nb,/* Update probes on coming module */ mutex_lock (&probe_lock);list_for_each_entry (tp, &probe_list, list) { -if (trace_probe_within_module (tp, mod)) { +if (trace_kprobe_within_module (tp, mod)) {/* Don't need to check busy - this should have gone. */ __unregister_trace_probe (tp); ret =__register_trace_probe (tp);if (ret)pr_warning ("Failed to re-register probe %s on" "%s: %d\n" , - tp->call.name, mod->name, ret); + tp->p.call.name, mod->name, ret); } }mutex_unlock (&probe_lock);
@@ -495,7 +479,7 @@ static int create_trace_probe(int argc, char **argv)* Type of args: * FETCHARG:TYPE : use TYPE instead of unsigned long. */ -struct trace_probe *tp; +struct trace_kprobe *tp;int i, ret =0 ;bool is_return = false, is_delete = false;char *symbol =NULL , *event =NULL , *group =NULL ;
@@ -609,36 +593,38 @@ static int create_trace_probe(int argc, char **argv)/* parse arguments */ ret =0 ;for (i =0 ; i < argc && i <MAX_TRACE_ARGS ; i++) { +struct probe_arg *parg = &tp->p.args[i]; +/* Increment count for freeing args in error case */ - tp->nr_args++; + tp->p.nr_args++;/* Parse argument name */ arg =strchr (argv[i],'=' );if (arg) { *arg++ ='\0' ; - tp->args[i].name =kstrdup (argv[i],GFP_KERNEL ); + parg->name =kstrdup (argv[i],GFP_KERNEL ); }else { arg = argv[i];/* 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 ); + parg->name =kstrdup (buf,GFP_KERNEL ); } -if (!tp->args[i].name) { +if (!parg->name) {pr_info ("Failed to allocate argument[%d] name.\n" , i); ret = -ENOMEM ; goto error; } -if (!is_good_name (tp->args[i].name)) { +if (!is_good_name (parg->name)) {pr_info ("Invalid argument[%d] name: %s\n" , - i, tp->args[i].name); + i, parg->name); ret = -EINVAL ; goto error; } -if (traceprobe_conflict_field_name (tp->args[i].name, - tp->args, i)) { +if (traceprobe_conflict_field_name (parg->name, + tp->p.args, i)) {pr_info ("Argument[%d] name '%s' conflicts with " "another field.\n" , i, argv[i]); ret = -EINVAL ;
@@ -646,7 +632,7 @@ static int create_trace_probe(int argc, char **argv) }/* Parse fetch argument */ - ret =traceprobe_parse_probe_arg (arg, &tp->size, &tp->args[i], + ret =traceprobe_parse_probe_arg (arg, &tp->p.size, parg, is_return, true);if (ret) {pr_info ("Parse error at argument[%d]. (%d)\n" , i, ret);
@@ -666,19 +652,19 @@ error:static int release_all_trace_probes (void ) { -struct trace_probe *tp; +struct trace_kprobe *tp;int ret =0 ;mutex_lock (&probe_lock);/* Ensure no probe is in use. */ list_for_each_entry (tp, &probe_list, list) -if (trace_probe_is_enabled (tp)) { +if (trace_probe_is_enabled (&tp->p)) { ret = -EBUSY ; goto end; }/* TODO: Use batch unregistration */ while (!list_empty (&probe_list)) { - tp = list_entry(probe_list.next, struct trace_probe, list); + tp = list_entry(probe_list.next, struct trace_kprobe, list);unregister_trace_probe (tp);free_trace_probe (tp); }
@@ -708,22 +694,22 @@ static void probes_seq_stop(struct seq_file *m, void *v)static int probes_seq_show (struct seq_file *m,void *v) { -struct trace_probe *tp = v; +struct trace_kprobe *tp = v;int i; -seq_printf (m,"%c" ,trace_probe_is_return (tp) ?'r' :'p' ); -seq_printf (m,":%s/%s" , tp->call.class->system, tp->call.name); +seq_printf (m,"%c" ,trace_kprobe_is_return (tp) ?'r' :'p' ); +seq_printf (m,":%s/%s" , tp->p.call.class->system, tp->p.call.name);if (!tp->symbol)seq_printf (m," 0x%p" , tp->rp.kp.addr);else if (tp->rp.kp.offset) -seq_printf (m," %s+%u" ,trace_probe_symbol (tp), +seq_printf (m," %s+%u" ,trace_kprobe_symbol (tp), tp->rp.kp.offset);else -seq_printf (m," %s" ,trace_probe_symbol (tp)); +seq_printf (m," %s" ,trace_kprobe_symbol (tp)); -for (i =0 ; i < tp->nr_args; i++) -seq_printf (m," %s=%s" , tp->args[i].name, tp->args[i].comm); +for (i =0 ; i < tp->p.nr_args; i++) +seq_printf (m," %s=%s" , tp->p.args[i].name, tp->p.args[i].comm);seq_printf (m,"\n" );return 0 ;
@@ -768,9 +754,9 @@ static const struct file_operations kprobe_events_ops = {/* Probes profiling interfaces */ static int probes_profile_seq_show (struct seq_file *m,void *v) { -struct trace_probe *tp = v; +struct trace_kprobe *tp = v; -seq_printf (m," %-44s %15lu %15lu\n" , tp->call.name, tp->nhit, +seq_printf (m," %-44s %15lu %15lu\n" , tp->p.call.name, tp->nhit, tp->rp.kp.nmissed);return 0 ;
@@ -956,7 +942,7 @@ static __kprobes void store_trace_args(int ent_size, struct trace_probe *tp,/* Kprobe handler */ static __kprobes void -__kprobe_trace_func (struct trace_probe *tp,struct pt_regs *regs, +__kprobe_trace_func (struct trace_kprobe *tp,struct pt_regs *regs,struct ftrace_event_file *ftrace_file) {struct kprobe_trace_entry_head *entry;
@@ -964,7 +950,7 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs,struct ring_buffer *buffer;int size, dsize, pc;unsigned long irq_flags; -struct ftrace_event_call *call = &tp->call; +struct ftrace_event_call *call = &tp->p.call;WARN_ON (call != ftrace_file->event_call);
@@ -974,8 +960,8 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs,local_save_flags (irq_flags); pc =preempt_count (); - dsize =__get_data_size (tp, regs); - size =sizeof (*entry) + tp->size + dsize; + dsize =__get_data_size (&tp->p, regs); + size =sizeof (*entry) + tp->p.size + dsize; event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, call->event.type,
@@ -985,7 +971,7 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs, entry =ring_buffer_event_data (event); entry->ip = (unsigned long )tp->rp.kp.addr; -store_trace_args (sizeof (*entry), tp, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize);if (!filter_current_check_discard (buffer, call, entry, event)) trace_buffer_unlock_commit_regs(buffer, event,
@@ -993,14 +979,14 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs, }static __kprobes void -kprobe_trace_func (struct trace_probe *tp,struct pt_regs *regs) +kprobe_trace_func (struct trace_kprobe *tp,struct pt_regs *regs) {/* * Note: preempt is already disabled around the kprobe handler. * However, we still need an smp_read_barrier_depends() corresponding * to smp_wmb() in rcu_assign_pointer() to access the pointer. */ -struct ftrace_event_file **file =rcu_dereference_raw (tp->files); +struct ftrace_event_file **file =rcu_dereference_raw (tp->p.files);if (unlikely (!file))return ;
@@ -1013,7 +999,7 @@ kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs)/* Kretprobe handler */ static __kprobes void -__kretprobe_trace_func (struct trace_probe *tp,struct kretprobe_instance *ri, +__kretprobe_trace_func (struct trace_kprobe *tp,struct kretprobe_instance *ri,struct pt_regs *regs,struct ftrace_event_file *ftrace_file) {
@@ -1022,7 +1008,7 @@ __kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,struct ring_buffer *buffer;int size, pc, dsize;unsigned long irq_flags; -struct ftrace_event_call *call = &tp->call; +struct ftrace_event_call *call = &tp->p.call;WARN_ON (call != ftrace_file->event_call);
@@ -1032,8 +1018,8 @@ __kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,local_save_flags (irq_flags); pc =preempt_count (); - dsize =__get_data_size (tp, regs); - size =sizeof (*entry) + tp->size + dsize; + dsize =__get_data_size (&tp->p, regs); + size =sizeof (*entry) + tp->p.size + dsize; event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, call->event.type,
@@ -1044,7 +1030,7 @@ __kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri, entry =ring_buffer_event_data (event); entry->func = (unsigned long )tp->rp.kp.addr; entry->ret_ip = (unsigned long )ri->ret_addr; -store_trace_args (sizeof (*entry), tp, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize);if (!filter_current_check_discard (buffer, call, entry, event)) trace_buffer_unlock_commit_regs(buffer, event,
@@ -1052,7 +1038,7 @@ __kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri, }static __kprobes void -kretprobe_trace_func (struct trace_probe *tp,struct kretprobe_instance *ri, +kretprobe_trace_func (struct trace_kprobe *tp,struct kretprobe_instance *ri,struct pt_regs *regs) {/*
@@ -1060,7 +1046,7 @@ kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,* However, we still need an smp_read_barrier_depends() corresponding * to smp_wmb() in rcu_assign_pointer() to access the pointer. */ -struct ftrace_event_file **file =rcu_dereference_raw (tp->files); +struct ftrace_event_file **file =rcu_dereference_raw (tp->p.files);if (unlikely (!file))return ;
@@ -1155,16 +1141,18 @@ static int kprobe_event_define_fields(struct ftrace_event_call *event_call) {int ret, i;struct kprobe_trace_entry_head field; -struct trace_probe *tp = (struct trace_probe *)event_call->data; +struct trace_kprobe *tp = (struct trace_kprobe *)event_call->data; DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);/* Set argument names as fields */ -for (i =0 ; i < tp->nr_args; i++) { - ret =trace_define_field (event_call, tp->args[i].type->fmttype, - tp->args[i].name, -sizeof (field) + tp->args[i].offset, - tp->args[i].type->size, - tp->args[i].type->is_signed, +for (i =0 ; i < tp->p.nr_args; i++) { +struct probe_arg *parg = &tp->p.args[i]; + + ret =trace_define_field (event_call, parg->type->fmttype, + parg->name, +sizeof (field) + parg->offset, + parg->type->size, + parg->type->is_signed,FILTER_OTHER );if (ret)return ret;
@@ -1176,17 +1164,19 @@ static int kretprobe_event_define_fields(struct ftrace_event_call *event_call) {int ret, i;struct kretprobe_trace_entry_head field; -struct trace_probe *tp = (struct trace_probe *)event_call->data; +struct trace_kprobe *tp = (struct trace_kprobe *)event_call->data; DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0); DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);/* Set argument names as fields */ -for (i =0 ; i < tp->nr_args; i++) { - ret =trace_define_field (event_call, tp->args[i].type->fmttype, - tp->args[i].name, -sizeof (field) + tp->args[i].offset, - tp->args[i].type->size, - tp->args[i].type->is_signed, +for (i =0 ; i < tp->p.nr_args; i++) { +struct probe_arg *parg = &tp->p.args[i]; + + ret =trace_define_field (event_call, parg->type->fmttype, + parg->name, +sizeof (field) + parg->offset, + parg->type->size, + parg->type->is_signed,FILTER_OTHER );if (ret)return ret;
@@ -1194,14 +1184,14 @@ static int kretprobe_event_define_fields(struct ftrace_event_call *event_call)return 0 ; } -static int __set_print_fmt (struct trace_probe *tp,char *buf,int len) +static int __set_print_fmt (struct trace_kprobe *tp,char *buf,int len) {int i;int pos =0 ;const char *fmt, *arg; -if (!trace_probe_is_return (tp)) { +if (!trace_kprobe_is_return (tp)) { fmt ="(%lx)" ; arg ="REC->" FIELD_STRING_IP ; }else {
@@ -1214,21 +1204,21 @@ static int __set_print_fmt(struct trace_probe *tp, char *buf, int len) pos +=snprintf (buf + pos,LEN_OR_ZERO ,"\"%s" , fmt); -for (i =0 ; i < tp->nr_args; i++) { +for (i =0 ; i < tp->p.nr_args; i++) { pos +=snprintf (buf + pos,LEN_OR_ZERO ," %s=%s" , - tp->args[i].name, tp->args[i].type->fmt); + tp->p.args[i].name, tp->p.args[i].type->fmt); } pos +=snprintf (buf + pos,LEN_OR_ZERO ,"\", %s" , arg); -for (i =0 ; i < tp->nr_args; i++) { -if (strcmp (tp->args[i].type->name,"string" ) ==0 ) +for (i =0 ; i < tp->p.nr_args; i++) { +if (strcmp (tp->p.args[i].type->name,"string" ) ==0 ) pos +=snprintf (buf + pos,LEN_OR_ZERO ,", __get_str(%s)" , - tp->args[i].name); + tp->p.args[i].name);else pos +=snprintf (buf + pos,LEN_OR_ZERO ,", REC->%s" , - tp->args[i].name); + tp->p.args[i].name); }#undef LEN_OR_ZERO
@@ -1237,7 +1227,7 @@ static int __set_print_fmt(struct trace_probe *tp, char *buf, int len)return pos; } -static int set_print_fmt (struct trace_probe *tp) +static int set_print_fmt (struct trace_kprobe *tp) {int len;char *print_fmt;
@@ -1250,7 +1240,7 @@ static int set_print_fmt(struct trace_probe *tp)/* Second: actually write the @print_fmt */ __set_print_fmt (tp, print_fmt, len +1 ); - tp->call.print_fmt = print_fmt; + tp->p.call.print_fmt = print_fmt;return 0 ; }
@@ -1259,16 +1249,16 @@ static int set_print_fmt(struct trace_probe *tp)/* Kprobe profile handler */ static __kprobes void -kprobe_perf_func (struct trace_probe *tp,struct pt_regs *regs) +kprobe_perf_func (struct trace_kprobe *tp,struct pt_regs *regs) { -struct ftrace_event_call *call = &tp->call; +struct ftrace_event_call *call = &tp->p.call;struct kprobe_trace_entry_head *entry;struct hlist_head *head;int size, __size, dsize;int rctx; - dsize =__get_data_size (tp, regs); - __size =sizeof (*entry) + tp->size + dsize; + dsize =__get_data_size (&tp->p, regs); + __size =sizeof (*entry) + tp->p.size + dsize; size =ALIGN (__size +sizeof (u32),sizeof (u64)); size -=sizeof (u32); if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
@@ -1281,7 +1271,7 @@ kprobe_perf_func(struct trace_probe *tp, struct pt_regs *regs) entry->ip = (unsigned long )tp->rp.kp.addr;memset (&entry[1 ],0 , dsize); -store_trace_args (sizeof (*entry), tp, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); head =this_cpu_ptr (call->perf_events); perf_trace_buf_submit(entry, size, rctx,
@@ -1290,17 +1280,17 @@ kprobe_perf_func(struct trace_probe *tp, struct pt_regs *regs)/* Kretprobe profile handler */ static __kprobes void -kretprobe_perf_func (struct trace_probe *tp,struct kretprobe_instance *ri, +kretprobe_perf_func (struct trace_kprobe *tp,struct kretprobe_instance *ri,struct pt_regs *regs) { -struct ftrace_event_call *call = &tp->call; +struct ftrace_event_call *call = &tp->p.call;struct kretprobe_trace_entry_head *entry;struct hlist_head *head;int size, __size, dsize;int rctx; - dsize =__get_data_size (tp, regs); - __size =sizeof (*entry) + tp->size + dsize; + dsize =__get_data_size (&tp->p, regs); + __size =sizeof (*entry) + tp->p.size + dsize; size =ALIGN (__size +sizeof (u32),sizeof (u64)); size -=sizeof (u32); if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
@@ -1313,7 +1303,7 @@ kretprobe_perf_func(struct trace_probe *tp, struct kretprobe_instance *ri, entry->func = (unsigned long )tp->rp.kp.addr; entry->ret_ip = (unsigned long )ri->ret_addr; -store_trace_args (sizeof (*entry), tp, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); head =this_cpu_ptr (call->perf_events); perf_trace_buf_submit(entry, size, rctx,
@@ -1325,7 +1315,7 @@ static __kprobesint kprobe_register (struct ftrace_event_call *event,enum trace_reg type,void *data) { -struct trace_probe *tp = (struct trace_probe *)event->data; +struct trace_kprobe *tp = (struct trace_kprobe *)event->data;struct ftrace_event_file *file = data;switch (type) {
@@ -1352,14 +1342,14 @@ int kprobe_register(struct ftrace_event_call *event,static __kprobes int kprobe_dispatcher (struct kprobe *kp,struct pt_regs *regs) { - struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp); + struct trace_kprobe *tp = container_of(kp, struct trace_kprobe, rp.kp); tp->nhit++; -if (tp->flags &TP_FLAG_TRACE ) +if (tp->p.flags &TP_FLAG_TRACE )kprobe_trace_func (tp, regs);#ifdef CONFIG_PERF_EVENTS -if (tp->flags &TP_FLAG_PROFILE ) +if (tp->p.flags &TP_FLAG_PROFILE )kprobe_perf_func (tp, regs);#endif return 0 ;/* We don't tweek kernel, so just return 0 */
@@ -1368,14 +1358,14 @@ int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)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); + struct trace_kprobe *tp = container_of(ri->rp, struct trace_kprobe, rp); tp->nhit++; -if (tp->flags &TP_FLAG_TRACE ) +if (tp->p.flags &TP_FLAG_TRACE )kretprobe_trace_func (tp, ri, regs);#ifdef CONFIG_PERF_EVENTS -if (tp->flags &TP_FLAG_PROFILE ) +if (tp->p.flags &TP_FLAG_PROFILE )kretprobe_perf_func (tp, ri, regs);#endif return 0 ;/* We don't tweek kernel, so just return 0 */
@@ -1389,14 +1379,14 @@ static struct trace_event_functions kprobe_funcs = { .trace = print_kprobe_event }; -static int register_probe_event (struct trace_probe *tp) +static int register_probe_event (struct trace_kprobe *tp) { -struct ftrace_event_call *call = &tp->call; +struct ftrace_event_call *call = &tp->p.call;int ret;/* Initialize ftrace_event_call */ INIT_LIST_HEAD (&call->class->fields); -if (trace_probe_is_return (tp)) { +if (trace_kprobe_is_return (tp)) { call->event.funcs = &kretprobe_funcs; call->class->define_fields = kretprobe_event_define_fields; }else {
@@ -1422,11 +1412,11 @@ static int register_probe_event(struct trace_probe *tp)return ret; } -static void unregister_probe_event (struct trace_probe *tp) +static void unregister_probe_event (struct trace_kprobe *tp) {/* tp->event is unregistered in trace_remove_event_call() */ -trace_remove_event_call (&tp->call); -kfree (tp->call.print_fmt); +trace_remove_event_call (&tp->p.call); +kfree (tp->p.call.print_fmt); }/* Make a debugfs interface for controlling probe points */
@@ -1475,12 +1465,12 @@ static __used int kprobe_trace_selftest_target(int a1, int a2, int a3, }static struct ftrace_event_file * -find_trace_probe_file (struct trace_probe *tp,struct trace_array *tr) +find_trace_probe_file (struct trace_kprobe *tp,struct trace_array *tr) {struct ftrace_event_file *file;list_for_each_entry (file, &tr->events, list) -if (file->event_call == &tp->call) +if (file->event_call == &tp->p.call)return file;return NULL ;
@@ -1490,7 +1480,7 @@ static __init int kprobe_trace_self_tests_init(void) {int ret, warn =0 ;int (*target)(int ,int ,int ,int ,int ,int ); -struct trace_probe *tp; +struct trace_kprobe *tp;struct ftrace_event_file *file; target = kprobe_trace_selftest_target;
kernel/trace/trace_probe.h +20 -0
@@ -159,6 +159,26 @@ struct probe_arg {const struct fetch_type *type;/* Type of this argument */ }; +struct trace_probe { +unsigned int flags;/* For TP_FLAG_* */ +struct ftrace_event_class class; +struct ftrace_event_call call; +struct ftrace_event_file *__rcu *files; +ssize_t size;/* trace entry size */ +unsigned int nr_args; +struct probe_arg args[]; +}; + +static inline bool trace_probe_is_enabled (struct trace_probe *tp) +{ +return !!(tp->flags & (TP_FLAG_TRACE |TP_FLAG_PROFILE )); +} + +static inline bool trace_probe_is_registered (struct trace_probe *tp) +{ +return !!(tp->flags &TP_FLAG_REGISTERED ); +} +#define FETCH_FUNC_NAME (method, type) fetch_##method##_##type#define DECLARE_FETCH_FUNC (method, type) \
Signature · 1 line
1.7.11.7
PATCH 5/12 tracing/uprobes: Convert to struct trace_probe
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
Convert struct trace_uprobe to make use of the common trace_probe structure.
--- kernel/trace/trace_uprobe.c | 151 ++++++++++++++++++++++---------------------- 1 file changed, 75 insertions(+), 76 deletions(-)
kernel/trace/trace_uprobe.c +75 -76
@@ -51,22 +51,17 @@ struct trace_uprobe_filter {*/ struct trace_uprobe {struct list_head list; -struct ftrace_event_class class; -struct ftrace_event_call call;struct trace_uprobe_filter filter;struct uprobe_consumer consumer;struct inode *inode;char *filename;unsigned long offset;unsigned long nhit; -unsigned int flags;/* For TP_FLAG_* */ -ssize_t size;/* trace entry size */ -unsigned int nr_args; -struct probe_arg args[]; +struct trace_probe p; }; -#define SIZEOF_TRACE_UPROBE (n) \ - (offsetof(struct trace_uprobe, args) + \ +#define SIZEOF_TRACE_UPROBE (n) \ + (offsetof(struct trace_uprobe, p.args) + \ (sizeof(struct probe_arg) * (n)))static int register_uprobe_event (struct trace_uprobe *tu);
@@ -114,13 +109,13 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)if (!tu)return ERR_PTR (-ENOMEM ); - tu->call.class = &tu->class; - tu->call.name =kstrdup (event,GFP_KERNEL ); -if (!tu->call.name) + tu->p.call.class = &tu->p.class; + tu->p.call.name =kstrdup (event,GFP_KERNEL ); +if (!tu->p.call.name) goto error; - tu->class.system =kstrdup (group,GFP_KERNEL ); -if (!tu->class.system) + tu->p.class.system =kstrdup (group,GFP_KERNEL ); +if (!tu->p.class.system) goto error;INIT_LIST_HEAD (&tu->list);
@@ -131,7 +126,7 @@ alloc_trace_uprobe(const char *group, const char *event, int nargs, bool is_ret)return tu; error: -kfree (tu->call.name); +kfree (tu->p.call.name);kfree (tu);return ERR_PTR (-ENOMEM );
@@ -141,12 +136,12 @@ static void free_trace_uprobe(struct trace_uprobe *tu) {int i; -for (i =0 ; i < tu->nr_args; i++) -traceprobe_free_probe_arg (&tu->args[i]); +for (i =0 ; i < tu->p.nr_args; i++) +traceprobe_free_probe_arg (&tu->p.args[i]);iput (tu->inode); -kfree (tu->call.class->system); -kfree (tu->call.name); +kfree (tu->p.call.class->system); +kfree (tu->p.call.name);kfree (tu->filename);kfree (tu); }
@@ -156,8 +151,8 @@ static struct trace_uprobe *find_probe_event(const char *event, const char *groustruct trace_uprobe *tu;list_for_each_entry (tu, &uprobe_list, list) -if (strcmp (tu->call.name, event) ==0 && -strcmp (tu->call.class->system, group) ==0 ) +if (strcmp (tu->p.call.name, event) ==0 && +strcmp (tu->p.call.class->system, group) ==0 )return tu;return NULL ;
@@ -180,7 +175,7 @@ static int register_trace_uprobe(struct trace_uprobe *tu)mutex_lock (&uprobe_lock);/* register as an event */ - old_tp =find_probe_event (tu->call.name, tu->call.class->system); + old_tp =find_probe_event (tu->p.call.name, tu->p.call.class->system);if (old_tp)/* delete old event */ unregister_trace_uprobe (old_tp);
@@ -346,34 +341,36 @@ static int create_trace_uprobe(int argc, char **argv)/* parse arguments */ ret =0 ;for (i =0 ; i < argc && i <MAX_TRACE_ARGS ; i++) { +struct probe_arg *parg = &tu->p.args[i]; +/* Increment count for freeing args in error case */ - tu->nr_args++; + tu->p.nr_args++;/* Parse argument name */ arg =strchr (argv[i],'=' );if (arg) { *arg++ ='\0' ; - tu->args[i].name =kstrdup (argv[i],GFP_KERNEL ); + parg->name =kstrdup (argv[i],GFP_KERNEL ); }else { arg = argv[i];/* If argument name is omitted, set "argN" */ snprintf (buf,MAX_EVENT_NAME_LEN ,"arg%d" , i +1 ); - tu->args[i].name =kstrdup (buf,GFP_KERNEL ); + parg->name =kstrdup (buf,GFP_KERNEL ); } -if (!tu->args[i].name) { +if (!parg->name) {pr_info ("Failed to allocate argument[%d] name.\n" , i); ret = -ENOMEM ; goto error; } -if (!is_good_name (tu->args[i].name)) { -pr_info ("Invalid argument[%d] name: %s\n" , i, tu->args[i].name); +if (!is_good_name (parg->name)) { +pr_info ("Invalid argument[%d] name: %s\n" , i, parg->name); ret = -EINVAL ; goto error; } -if (traceprobe_conflict_field_name (tu->args[i].name, tu->args, i)) { +if (traceprobe_conflict_field_name (parg->name, tu->p.args, i)) {pr_info ("Argument[%d] name '%s' conflicts with " "another field.\n" , i, argv[i]); ret = -EINVAL ;
@@ -381,7 +378,8 @@ static int create_trace_uprobe(int argc, char **argv) }/* Parse fetch argument */ - ret =traceprobe_parse_probe_arg (arg, &tu->size, &tu->args[i], false, false); + ret =traceprobe_parse_probe_arg (arg, &tu->p.size, parg, + false, false);if (ret) {pr_info ("Parse error at argument[%d]. (%d)\n" , i, ret); goto error;
@@ -441,11 +439,11 @@ static int probes_seq_show(struct seq_file *m, void *v)char c =is_ret_probe (tu) ?'r' :'p' ;int i; -seq_printf (m,"%c:%s/%s" , c, tu->call.class->system, tu->call.name); +seq_printf (m,"%c:%s/%s" , c, tu->p.call.class->system, tu->p.call.name);seq_printf (m," %s:0x%p" , tu->filename, (void *)tu->offset); -for (i =0 ; i < tu->nr_args; i++) -seq_printf (m," %s=%s" , tu->args[i].name, tu->args[i].comm); +for (i =0 ; i < tu->p.nr_args; i++) +seq_printf (m," %s=%s" , tu->p.args[i].name, tu->p.args[i].comm);seq_printf (m,"\n" );return 0 ;
@@ -486,7 +484,7 @@ static int probes_profile_seq_show(struct seq_file *m, void *v) {struct trace_uprobe *tu = v; -seq_printf (m," %s %-44s %15lu\n" , tu->filename, tu->call.name, tu->nhit); +seq_printf (m," %s %-44s %15lu\n" , tu->filename, tu->p.call.name, tu->nhit);return 0 ; }
@@ -518,11 +516,11 @@ static void uprobe_trace_print(struct trace_uprobe *tu,struct ring_buffer *buffer;void *data;int size, i; -struct ftrace_event_call *call = &tu->call; +struct ftrace_event_call *call = &tu->p.call; size =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); event =trace_current_buffer_lock_reserve (&buffer, call->event.type, - size + tu->size,0 ,0 ); + size + tu->p.size,0 ,0 );if (!event)return ;
@@ -536,8 +534,10 @@ static void uprobe_trace_print(struct trace_uprobe *tu, data =DATAOF_TRACE_ENTRY (entry, false); } -for (i =0 ; i < tu->nr_args; i++) -call_fetch (&tu->args[i].fetch, regs, data + tu->args[i].offset); +for (i =0 ; i < tu->p.nr_args; i++) { +call_fetch (&tu->p.args[i].fetch, regs, + data + tu->p.args[i].offset); + }if (!filter_current_check_discard (buffer, call, entry, event))trace_buffer_unlock_commit (buffer, event,0 ,0 );
@@ -568,23 +568,24 @@ print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *eint i; entry = (struct uprobe_trace_entry_head *)iter->ent; - tu = container_of(event, struct trace_uprobe, call.event); + tu = container_of(event, struct trace_uprobe, p.call.event);if (is_ret_probe (tu)) { -if (!trace_seq_printf (s,"%s: (0x%lx <- 0x%lx)" , tu->call.name, +if (!trace_seq_printf (s,"%s: (0x%lx <- 0x%lx)" , tu->p.call.name, entry->vaddr[1 ], entry->vaddr[0 ])) goto partial; data =DATAOF_TRACE_ENTRY (entry, true); }else { -if (!trace_seq_printf (s,"%s: (0x%lx)" , tu->call.name, +if (!trace_seq_printf (s,"%s: (0x%lx)" , tu->p.call.name, entry->vaddr[0 ])) goto partial; data =DATAOF_TRACE_ENTRY (entry, false); } -for (i =0 ; i < tu->nr_args; i++) { -if (!tu->args[i].type->for (i =0 ; i < tu->p.nr_args; i++) { +struct probe_arg *parg = &tu->p.args[i]; + +if (!parg->type->
@@ -595,11 +596,6 @@ partial:return TRACE_TYPE_PARTIAL_LINE ; } -static inline bool is_trace_uprobe_enabled (struct trace_uprobe *tu) -{ -return tu->flags & (TP_FLAG_TRACE |TP_FLAG_PROFILE ); -} -typedef bool (*filter_func_t )(struct uprobe_consumer *self,enum uprobe_filter_ctx ctx,struct mm_struct *mm);
@@ -609,29 +605,29 @@ probe_event_enable(struct trace_uprobe *tu, int flag, filter_func_t filter) {int ret =0 ; -if (is_trace_uprobe_enabled (tu)) +if (trace_probe_is_enabled (&tu->p))return -EINTR ;WARN_ON (!uprobe_filter_is_empty (&tu->filter)); - tu->flags |= flag; + tu->p.flags |= flag; tu->consumer.filter = filter; ret =uprobe_register (tu->inode, tu->offset, &tu->consumer);if (ret) - tu->flags &= ~flag; + tu->p.flags &= ~flag;return ret; }static void probe_event_disable (struct trace_uprobe *tu,int flag) { -if (!is_trace_uprobe_enabled (tu)) +if (!trace_probe_is_enabled (&tu->p))return ;WARN_ON (!uprobe_filter_is_empty (&tu->filter));uprobe_unregister (tu->inode, tu->offset, &tu->consumer); - tu->flags &= ~flag; + tu->p.flags &= ~flag; }static int uprobe_event_define_fields (struct ftrace_event_call *event_call)
@@ -649,12 +645,12 @@ static int uprobe_event_define_fields(struct ftrace_event_call *event_call) size =SIZEOF_TRACE_ENTRY (false); }/* Set argument names as fields */ -for (i =0 ; i < tu->nr_args; i++) { - ret =trace_define_field (event_call, tu->args[i].type->fmttype, - tu->args[i].name, - size + tu->args[i].offset, - tu->args[i].type->size, - tu->args[i].type->is_signed, +for (i =0 ; i < tu->p.nr_args; i++) { +struct probe_arg *parg = &tu->p.args[i]; + + ret =trace_define_field (event_call, parg->type->fmttype, + parg->name, size + parg->offset, + parg->type->size, parg->type->is_signed,FILTER_OTHER );if (ret)
@@ -682,16 +678,16 @@ static int __set_print_fmt(struct trace_uprobe *tu, char *buf, int len) pos +=snprintf (buf + pos,LEN_OR_ZERO ,"\"%s" , fmt); -for (i =0 ; i < tu->nr_args; i++) { +for (i =0 ; i < tu->p.nr_args; i++) { pos +=snprintf (buf + pos,LEN_OR_ZERO ," %s=%s" , - tu->args[i].name, tu->args[i].type->fmt); + tu->p.args[i].name, tu->p.args[i].type->fmt); } pos +=snprintf (buf + pos,LEN_OR_ZERO ,"\", %s" , arg); -for (i =0 ; i < tu->nr_args; i++) { +for (i =0 ; i < tu->p.nr_args; i++) { pos +=snprintf (buf + pos,LEN_OR_ZERO ,", REC->%s" , - tu->args[i].name); + tu->p.args[i].name); }return pos;/* return the length of print_fmt */
@@ -711,7 +707,7 @@ static int set_print_fmt(struct trace_uprobe *tu)/* Second: actually write the @print_fmt */ __set_print_fmt (tu, print_fmt, len +1 ); - tu->call.print_fmt = print_fmt; + tu->p.call.print_fmt = print_fmt;return 0 ; }
@@ -808,14 +804,14 @@ static bool uprobe_perf_filter(struct uprobe_consumer *uc,static void uprobe_perf_print (struct trace_uprobe *tu,unsigned long func,struct pt_regs *regs) { -struct ftrace_event_call *call = &tu->call; +struct ftrace_event_call *call = &tu->p.call;struct uprobe_trace_entry_head *entry;struct hlist_head *head;void *data;int size, rctx, i; size =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); - size =ALIGN (size + tu->size +sizeof (u32),sizeof (u64)) -sizeof (u32); + size =ALIGN (size + tu->p.size +sizeof (u32),sizeof (u64)) -sizeof (u32);if (WARN_ONCE (size >PERF_MAX_TRACE_SIZE ,"profile buffer not large enough" ))return ;
@@ -837,8 +833,11 @@ static void uprobe_perf_print(struct trace_uprobe *tu, data =DATAOF_TRACE_ENTRY (entry, false); } -for (i =0 ; i < tu->nr_args; i++) -call_fetch (&tu->args[i].fetch, regs, data + tu->args[i].offset); +for (i =0 ; i < tu->p.nr_args; i++) { +struct probe_arg *parg = &tu->p.args[i]; + +call_fetch (&parg->fetch, regs, data + parg->offset); + }perf_trace_buf_submit (entry, size, rctx,0 ,1 , regs, head,NULL ); out:
@@ -905,11 +904,11 @@ static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs) tu = container_of(con, struct trace_uprobe, consumer); tu->nhit++; -if (tu->flags &TP_FLAG_TRACE ) +if (tu->p.flags &TP_FLAG_TRACE ) ret |=uprobe_trace_func (tu, regs);#ifdef CONFIG_PERF_EVENTS -if (tu->flags &TP_FLAG_PROFILE ) +if (tu->p.flags &TP_FLAG_PROFILE ) ret |=uprobe_perf_func (tu, regs);#endif return ret;
@@ -922,11 +921,11 @@ static int uretprobe_dispatcher(struct uprobe_consumer *con, tu = container_of(con, struct trace_uprobe, consumer); -if (tu->flags &TP_FLAG_TRACE ) +if (tu->p.flags &TP_FLAG_TRACE )uretprobe_trace_func (tu, func, regs);#ifdef CONFIG_PERF_EVENTS -if (tu->flags &TP_FLAG_PROFILE ) +if (tu->p.flags &TP_FLAG_PROFILE )uretprobe_perf_func (tu, func, regs);#endif return 0 ;
@@ -938,7 +937,7 @@ static struct trace_event_functions uprobe_funcs = {static int register_uprobe_event (struct trace_uprobe *tu) { -struct ftrace_event_call *call = &tu->call; +struct ftrace_event_call *call = &tu->p.call;int ret;/* Initialize ftrace_event_call */
@@ -971,9 +970,9 @@ static int register_uprobe_event(struct trace_uprobe *tu)static void unregister_uprobe_event (struct trace_uprobe *tu) {/* tu->event is unregistered in trace_remove_event_call() */ -trace_remove_event_call (&tu->call); -kfree (tu->call.print_fmt); - tu->call.print_fmt =NULL ; +trace_remove_event_call (&tu->p.call); +kfree (tu->p.call.print_fmt); + tu->p.call.print_fmt =NULL ; }/* Make a trace interface for controling probe points */
Signature · 1 line
1.7.11.7
PATCH 6/12 tracing/kprobes: Move common functions to trace_probe.c
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
The __get_data_size() and store_trace_args() will be used by uprobes too. Move them to a common location.
--- kernel/trace/trace_kprobe.c | 48 --------------------------------------------- kernel/trace/trace_probe.c | 46 +++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_probe.h | 4 ++++ 3 files changed, 50 insertions(+), 48 deletions(-)
kernel/trace/trace_kprobe.c +0 -48
@@ -892,54 +892,6 @@ const struct fetch_type kprobes_fetch_type_table[] = { ASSIGN_FETCH_TYPE(s64, u64, 1), }; -/* 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); - } -} -/* Kprobe handler */ static __kprobes void __kprobe_trace_func(struct trace_kprobe *tp, struct pt_regs *regs,
kernel/trace/trace_probe.c +46 -0
49 lines not on this page · raw message
kernel/trace/trace_probe.h +4 -0
@@ -297,3 +297,7 @@ extern ssize_t traceprobe_probes_write(struct file *file, int (*createfn)(int, char**));extern int traceprobe_command (const char *buf,int (*createfn)(int ,char **)); + +extern int __get_data_size (struct trace_probe *tp,struct pt_regs *regs); +extern void store_trace_args (int ent_size,struct trace_probe *tp, +struct pt_regs *regs,u8 *data,int maxlen);
Signature · 1 line
1.7.11.7
PATCH 7/12 tracing/kprobes: Remove duplicate set_print_fmt()
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
The set_print_fmt() functions are implemented almost same for [ku]probes. Move it to a common place and get rid of the duplication.
--- kernel/trace/trace_kprobe.c | 63 +-------------------------------------------- kernel/trace/trace_probe.c | 62 ++++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_probe.h | 1 + kernel/trace/trace_uprobe.c | 55 +-------------------------------------- 4 files changed, 65 insertions(+), 116 deletions(-)
kernel/trace/trace_kprobe.c +1 -62
@@ -1136,67 +1136,6 @@ static int kretprobe_event_define_fields(struct ftrace_event_call *event_call)return 0 ; } -static int __set_print_fmt (struct trace_kprobe *tp,char *buf,int len) -{ -int i; -int pos =0 ; - -const char *fmt, *arg; - -if (!trace_kprobe_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->p.nr_args; i++) { - pos +=snprintf (buf + pos,LEN_OR_ZERO ," %s=%s" , - tp->p.args[i].name, tp->p.args[i].type->fmt); - } - - pos +=snprintf (buf + pos,LEN_OR_ZERO ,"\", %s" , arg); - -for (i =0 ; i < tp->p.nr_args; i++) { -if (strcmp (tp->p.args[i].type->name,"string" ) ==0 ) - pos +=snprintf (buf + pos,LEN_OR_ZERO , -", __get_str(%s)" , - tp->p.args[i].name); -else - pos +=snprintf (buf + pos,LEN_OR_ZERO ,", REC->%s" , - tp->p.args[i].name); - } - -#undef LEN_OR_ZERO - -/* return the length of print_fmt */ -return pos; -} - -static int set_print_fmt (struct trace_kprobe *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->p.call.print_fmt = print_fmt; - -return 0 ; -} -#ifdef CONFIG_PERF_EVENTS /* Kprobe profile handler */
@@ -1345,7 +1284,7 @@ static int register_probe_event(struct trace_kprobe *tp) call->event.funcs = &kprobe_funcs; call->class->define_fields = kprobe_event_define_fields; } -if (set_print_fmt (tp) <0 ) +if (set_print_fmt (&tp->p,trace_kprobe_is_return (tp)) <0 )return -ENOMEM ; ret =register_ftrace_event (&call->event);if (!ret) {
kernel/trace/trace_probe.c +62 -0
65 lines not on this page · raw message
kernel/trace/trace_probe.h +1 -0
@@ -301,3 +301,4 @@ extern int traceprobe_command(const char *buf, int (*createfn)(int, char**));extern int __get_data_size (struct trace_probe *tp,struct pt_regs *regs);extern void store_trace_args (int ent_size,struct trace_probe *tp,struct pt_regs *regs,u8 *data,int maxlen); +extern int set_print_fmt (struct trace_probe *tp,bool is_return);
kernel/trace/trace_uprobe.c +1 -54
67 lines not on this page · raw message
Signature · 1 line
1.7.11.7
PATCH 8/12 tracing/uprobes: Fetch args before reserving a ring buffer
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
Fetching from user space should be done in a non-atomic context. So use a temporary buffer and copy its content to the ring buffer atomically.
While at it, use __get_data_size() and store_trace_args() to reduce code duplication.
--- kernel/trace/trace_uprobe.c | 69 ++++++++++++++++++++++++++++++++++----------- 1 file changed, 52 insertions(+), 17 deletions(-)
kernel/trace/trace_uprobe.c +52 -17
@@ -514,15 +514,31 @@ static void uprobe_trace_print(struct trace_uprobe *tu,struct uprobe_trace_entry_head *entry;struct ring_buffer_event *event;struct ring_buffer *buffer; -void *data; -int size, i; +void *data, *tmp; +int size, dsize, esize;struct ftrace_event_call *call = &tu->p.call; - size =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); + dsize =__get_data_size (&tu->p, regs); + esize =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); + +/* +* A temporary buffer is used for storing fetched data before reserving +* the ring buffer because fetching from user space should be done in a +* non-atomic context. +*/ + tmp =kmalloc (tu->p.size + dsize,GFP_KERNEL ); +if (tmp ==NULL ) +return ; + +store_trace_args (esize, &tu->p, regs, tmp, dsize); + + size = esize + tu->p.size + dsize; event =trace_current_buffer_lock_reserve (&buffer, call->event.type, - size + tu->p.size,0 ,0 ); -if (!event) + size,0 ,0 ); +if (!event) { +kfree (tmp);return ; + } entry =ring_buffer_event_data (event);if (is_ret_probe (tu)) {
@@ -534,13 +550,12 @@ static void uprobe_trace_print(struct trace_uprobe *tu, data =DATAOF_TRACE_ENTRY (entry, false); } -for (i =0 ; i < tu->p.nr_args; i++) { -call_fetch (&tu->p.args[i].fetch, regs, - data + tu->p.args[i].offset); - } +memcpy (data, tmp, tu->p.size + dsize);if (!filter_current_check_discard (buffer, call, entry, event))trace_buffer_unlock_commit (buffer, event,0 ,0 ); + +kfree (tmp); }/* uprobe handler */
@@ -754,13 +769,30 @@ static void uprobe_perf_print(struct trace_uprobe *tu,struct ftrace_event_call *call = &tu->p.call;struct uprobe_trace_entry_head *entry;struct hlist_head *head; -void *data; -int size, rctx, i; +void *data, *tmp; +int size, dsize, esize; +int rctx; + + dsize =__get_data_size (&tu->p, regs); + esize =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); + +/* +* A temporary buffer is used for storing fetched data before reserving +* the ring buffer because fetching from user space should be done in a +* non-atomic context. +*/ + tmp =kmalloc (tu->p.size + dsize,GFP_KERNEL ); +if (tmp ==NULL ) +return ; - size =SIZEOF_TRACE_ENTRY (is_ret_probe (tu)); - size =ALIGN (size + tu->p.size +sizeof (u32),sizeof (u64)) -sizeof (u32); -if (WARN_ONCE (size >PERF_MAX_TRACE_SIZE ,"profile buffer not large enough" )) +store_trace_args (esize, &tu->p, regs, tmp, dsize); + + size = esize + tu->p.size + dsize; + size =ALIGN (size + +sizeof (u32),sizeof (u64)) -sizeof (u32); +if (WARN_ONCE (size >PERF_MAX_TRACE_SIZE ,"profile buffer not large enough" )) { +kfree (tmp);return ; + }preempt_disable (); head =this_cpu_ptr (call->perf_events);
@@ -780,15 +812,18 @@ static void uprobe_perf_print(struct trace_uprobe *tu, data =DATAOF_TRACE_ENTRY (entry, false); } -for (i =0 ; i < tu->p.nr_args; i++) { -struct probe_arg *parg = &tu->p.args[i]; +memcpy (data, tmp, tu->p.size + dsize); + +if (size - esize > tu->p.size + dsize) { +int len = tu->p.size + dsize; -call_fetch (&parg->fetch, regs, data + parg->offset); +memset (data + len,0 , size - esize - len); }perf_trace_buf_submit (entry, size, rctx,0 ,1 , regs, head,NULL ); out:preempt_enable (); +kfree (tmp); }/* uprobe profile handler */
Signature · 1 line
1.7.11.7
PATCH 9/12 tracing/uprobes: Fix a comment for uprobe registration syntax
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
The uprobe syntax requires an offset after a file path not a symbol.
--- kernel/trace/trace_uprobe.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_uprobe.c +1 -1
@@ -196,7 +196,7 @@ end:/* * Argument syntax: -* - Add uprobe: p|r[:[GRP/]EVENT] PATH:SYMBOL [FETCHARGS] +* - Add uprobe: p|r[:[GRP/]EVENT] PATH:OFFSET [FETCHARGS] * * - Remove uprobe: -:[GRP/]EVENT */
Signature · 1 line
1.7.11.7
PATCH 10/12 tracing/kprobes: Add priv argument to fetch functions
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
This argument is for passing private data structure to each fetch function and will be used by uprobes.
--- kernel/trace/trace_kprobe.c | 28 ++++++++++++++++------------ kernel/trace/trace_probe.c | 44 +++++++++++++++++++++++--------------------- kernel/trace/trace_probe.h | 15 +++++++++------ kernel/trace/trace_uprobe.c | 8 ++++---- 4 files changed, 52 insertions(+), 43 deletions(-)
kernel/trace/trace_kprobe.c +16 -12
@@ -787,7 +787,7 @@ static const struct file_operations kprobe_profile_ops = {*/ #define DEFINE_FETCH_stack (type) \ static __kprobes void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs,\ - void *offset, void *dest) \ + void *offset, void *dest, void *priv) \ { \ *(type *)dest = (type)regs_get_kernel_stack_nth(regs, \ (unsigned int)((unsigned long)offset)); \
@@ -799,7 +799,7 @@ DEFINE_BASIC_FETCH_FUNCS(stack)#define DEFINE_FETCH_memory (type) \ static __kprobes void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs,\ - void *addr, void *dest) \ + void *addr, void *dest, void *priv) \ { \ type retval; \ if (probe_kernel_address(addr, retval)) \
@@ -813,7 +813,7 @@ DEFINE_BASIC_FETCH_FUNCS(memory)* length and relative data location. */ static __kprobes void FETCH_FUNC_NAME (memory ,string )(struct pt_regs *regs, -void *addr,void *dest) +void *addr,void *dest,void *priv) {long ret;int maxlen =get_rloc_len (*(u32 *)dest);
@@ -850,7 +850,7 @@ static __kprobes void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs,/* 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) +void *addr,void *dest,void *priv) {mm_segment_t old_fs;int ret, len =0 ;
@@ -912,7 +912,7 @@ __kprobe_trace_func(struct trace_kprobe *tp, struct pt_regs *regs,local_save_flags (irq_flags); pc =preempt_count (); - dsize =__get_data_size (&tp->p, regs); + dsize =__get_data_size (&tp->p, regs,NULL ); size =sizeof (*entry) + tp->p.size + dsize; event = trace_event_buffer_lock_reserve(&buffer, ftrace_file,
@@ -923,7 +923,8 @@ __kprobe_trace_func(struct trace_kprobe *tp, struct pt_regs *regs, entry =ring_buffer_event_data (event); entry->ip = (unsigned long )tp->rp.kp.addr; -store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize, +NULL );if (!filter_current_check_discard (buffer, call, entry, event)) trace_buffer_unlock_commit_regs(buffer, event,
@@ -970,7 +971,7 @@ __kretprobe_trace_func(struct trace_kprobe *tp, struct kretprobe_instance *ri,local_save_flags (irq_flags); pc =preempt_count (); - dsize =__get_data_size (&tp->p, regs); + dsize =__get_data_size (&tp->p, regs,NULL ); size =sizeof (*entry) + tp->p.size + dsize; event = trace_event_buffer_lock_reserve(&buffer, ftrace_file,
@@ -982,7 +983,8 @@ __kretprobe_trace_func(struct trace_kprobe *tp, struct kretprobe_instance *ri, entry =ring_buffer_event_data (event); entry->func = (unsigned long )tp->rp.kp.addr; entry->ret_ip = (unsigned long )ri->ret_addr; -store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize, +NULL );if (!filter_current_check_discard (buffer, call, entry, event)) trace_buffer_unlock_commit_regs(buffer, event,
@@ -1148,7 +1150,7 @@ kprobe_perf_func(struct trace_kprobe *tp, struct pt_regs *regs)int size, __size, dsize;int rctx; - dsize =__get_data_size (&tp->p, regs); + dsize =__get_data_size (&tp->p, regs,NULL ); __size =sizeof (*entry) + tp->p.size + dsize; size =ALIGN (__size +sizeof (u32),sizeof (u64)); size -=sizeof (u32);
@@ -1162,7 +1164,8 @@ kprobe_perf_func(struct trace_kprobe *tp, struct pt_regs *regs) entry->ip = (unsigned long )tp->rp.kp.addr;memset (&entry[1 ],0 , dsize); -store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize, +NULL ); head =this_cpu_ptr (call->perf_events); perf_trace_buf_submit(entry, size, rctx,
@@ -1180,7 +1183,7 @@ kretprobe_perf_func(struct trace_kprobe *tp, struct kretprobe_instance *ri,int size, __size, dsize;int rctx; - dsize =__get_data_size (&tp->p, regs); + dsize =__get_data_size (&tp->p, regs,NULL ); __size =sizeof (*entry) + tp->p.size + dsize; size =ALIGN (__size +sizeof (u32),sizeof (u64)); size -=sizeof (u32);
@@ -1194,7 +1197,8 @@ kretprobe_perf_func(struct trace_kprobe *tp, struct kretprobe_instance *ri, entry->func = (unsigned long )tp->rp.kp.addr; entry->ret_ip = (unsigned long )ri->ret_addr; -store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize); +store_trace_args (sizeof (*entry), &tp->p, regs, (u8 *)&entry[1 ], dsize, +NULL ); head =this_cpu_ptr (call->perf_events); perf_trace_buf_submit(entry, size, rctx,
kernel/trace/trace_probe.c +23 -21
142 lines not on this page · raw message
kernel/trace/trace_probe.h +9 -6
@@ -98,7 +98,7 @@ typedef u32 string;typedef u32 string_size ;/* Data fetch function type */ -typedef void (*fetch_func_t )(struct pt_regs *,void *,void *); +typedef void (*fetch_func_t )(struct pt_regs *,void *,void *,void *);/* Printing function type */ typedef int (*print_type_func_t )(struct trace_seq *,const char *,void *,void *);
@@ -182,7 +182,8 @@ static inline bool trace_probe_is_registered(struct trace_probe *tp)#define FETCH_FUNC_NAME (method, type) fetch_##method##_##type#define DECLARE_FETCH_FUNC (method, type) \ -extern void FETCH_FUNC_NAME(method, type)(struct pt_regs *, void *, void *) +extern void FETCH_FUNC_NAME(method, type)(struct pt_regs *, void *, \ + void *, void *)#define DECLARE_BASIC_FETCH_FUNCS (method) \ DECLARE_FETCH_FUNC(method, u8); \
@@ -264,9 +265,9 @@ ASSIGN_FETCH_FUNC(bitfield, ftype), \extern const struct fetch_type kprobes_fetch_type_table[];static inline __kprobes void call_fetch (struct fetch_param *fprm, -struct pt_regs *regs,void *dest) +struct pt_regs *regs,void *dest,void *priv) { -return fprm->fn (regs, fprm->data, dest); +return fprm->fn (regs, fprm->data, dest, priv); }/* Check the name is good for event/group/fields */
@@ -298,7 +299,9 @@ extern ssize_t traceprobe_probes_write(struct file *file,extern int traceprobe_command (const char *buf,int (*createfn)(int ,char **)); -extern int __get_data_size (struct trace_probe *tp,struct pt_regs *regs); +extern int __get_data_size (struct trace_probe *tp,struct pt_regs *regs, +void *priv);extern void store_trace_args (int ent_size,struct trace_probe *tp, -struct pt_regs *regs,u8 *data,int maxlen); +struct pt_regs *regs,u8 *data,int maxlen, +void *priv);extern int set_print_fmt (struct trace_probe *tp,bool is_return);
kernel/trace/trace_uprobe.c +4 -4
@@ -518,7 +518,7 @@ static void uprobe_trace_print(struct trace_uprobe *tu,int size, dsize, esize;struct ftrace_event_call *call = &tu->p.call; - dsize =__get_data_size (&tu->p, regs); + dsize =__get_data_size (&tu->p, regs,NULL ); esize =SIZEOF_TRACE_ENTRY (is_ret_probe (tu));/*
@@ -530,7 +530,7 @@ static void uprobe_trace_print(struct trace_uprobe *tu,if (tmp ==NULL )return ; -store_trace_args (esize, &tu->p, regs, tmp, dsize); +store_trace_args (esize, &tu->p, regs, tmp, dsize,NULL ); size = esize + tu->p.size + dsize; event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
@@ -773,7 +773,7 @@ static void uprobe_perf_print(struct trace_uprobe *tu,int size, dsize, esize;int rctx; - dsize =__get_data_size (&tu->p, regs); + dsize =__get_data_size (&tu->p, regs,NULL ); esize =SIZEOF_TRACE_ENTRY (is_ret_probe (tu));/*
@@ -785,7 +785,7 @@ static void uprobe_perf_print(struct trace_uprobe *tu,if (tmp ==NULL )return ; -store_trace_args (esize, &tu->p, regs, tmp, dsize); +store_trace_args (esize, &tu->p, regs, tmp, dsize,NULL ); size = esize + tu->p.size + dsize; size =ALIGN (size + +sizeof (u32),sizeof (u64)) -sizeof (u32);
Signature · 1 line
1.7.11.7
PATCH 11/12 tracing/uprobes: Add more fetch functions
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
Implement uprobe-specific stack and memory fetch functions and add them to the uprobes_fetch_type_table. Other fetch fucntions will be shared with kprobes.
--- kernel/trace/trace_probe.c | 9 ++- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_uprobe.c | 188 +++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 192 insertions(+), 6 deletions(-)
kernel/trace/trace_probe.c +7 -2
@@ -166,6 +166,10 @@ struct deref_fetch_param {fetch_func_t fetch_size; }; +/* +* For uprobes, it'll get a vaddr from first call_fetch() so pass NULL +* as a priv on the second dprm->fetch() not to translate it to vaddr again. +*/ #define DEFINE_FETCH_deref (type) \ __kprobes void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs, \ void *data, void *dest, void *priv) \
@@ -175,13 +179,14 @@ __kprobes void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs, \call_fetch (&dprm->orig, regs, &addr, priv); \if (addr) { \ addr += dprm->offset; \ - dprm->fetch (regs, (void *)addr, dest, priv); \ + dprm->fetch (regs, (void *)addr, dest,NULL ); \ }else \ *(type *)dest =0 ; \ }DEFINE_BASIC_FETCH_FUNCS (deref)DEFINE_FETCH_deref (string ) +/* Same as above */ __kprobes voidFETCH_FUNC_NAME (deref, string_size)(struct pt_regs *regs,void *data,void *dest,void *priv) {
@@ -191,7 +196,7 @@ __kprobes void FETCH_FUNC_NAME(deref, string_size)(struct pt_regs *regs,call_fetch (&dprm->orig, regs, &addr, priv);if (addr && dprm->fetch_size) { addr += dprm->offset; - dprm->fetch_size (regs, (void *)addr, dest, priv); + dprm->fetch_size (regs, (void *)addr, dest,NULL ); }else *(string_size *)dest =0 ; }
kernel/trace/trace_probe.h +1 -0
@@ -263,6 +263,7 @@ ASSIGN_FETCH_FUNC(bitfield, ftype), \#define NR_FETCH_TYPES 10extern const struct fetch_type kprobes_fetch_type_table[]; +extern const struct fetch_type uprobes_fetch_type_table[];static inline __kprobes void call_fetch (struct fetch_param *fprm,struct pt_regs *regs,void *dest,void *priv)
kernel/trace/trace_uprobe.c +184 -4
218 lines not on this page · raw message
Signature · 1 line
1.7.11.7
PATCH 12/12 tracing/uprobes: Add support for full argument access methods
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
Enable to fetch other types of argument for the uprobes. IOW, we can access stack, memory, deref, bitfield and retval from uprobes now.
--- kernel/trace/trace_probe.c | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-)
kernel/trace/trace_probe.c +20 -14
@@ -318,7 +318,7 @@ fail: }/* Special function : only accept unsigned long */ -static __kprobes void fetch_stack_address (struct pt_regs *regs, +static __kprobes void fetch_kernel_stack_address (struct pt_regs *regs,void *dummy,void *dest,void *priv) { *(unsigned long *)dest =kernel_stack_pointer (regs);
@@ -368,7 +368,8 @@ int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset)#define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))static int parse_probe_vars (char *arg,const struct fetch_type *t, -struct fetch_param *f,bool is_return) +struct fetch_param *f,bool is_return, +bool is_kprobe) {int ret =0 ;unsigned long param;
@@ -380,13 +381,18 @@ static int parse_probe_vars(char *arg, const struct fetch_type *t, ret = -EINVAL ; }else if (strncmp (arg,"stack" ,5 ) ==0 ) {if (arg[5 ] =='\0' ) { -if (strcmp (t->name,DEFAULT_FETCH_TYPE_STR ) ==0 ) - f->fn = fetch_stack_address; -else - ret = -EINVAL ; +if (strcmp (t->name,DEFAULT_FETCH_TYPE_STR )) +return -EINVAL ; + +if (is_kprobe) + f->fn = fetch_kernel_stack_address; +else { + f->fn = t->fetch[FETCH_MTD_stack]; + f->data = (void *)0 ; + } }else if (isdigit (arg[5 ])) { ret =kstrtoul (arg +5 ,10 , ¶m); -if (ret || param >PARAM_MAX_STACK ) +if (ret || (is_kprobe && param >PARAM_MAX_STACK )) ret = -EINVAL ;else { f->fn = t->fetch[FETCH_MTD_stack];
@@ -410,17 +416,13 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,int ret;const struct fetch_type *ttbl; - ttbl = kprobes_fetch_type_table; + ttbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table; ret =0 ; -/* Until uprobe_events supports only reg arguments */ -if (!is_kprobe && arg[0 ] !='%' ) -return -EINVAL ; -switch (arg[0 ]) {case '$' : - ret =parse_probe_vars (arg +1 , t, f, is_return); + ret =parse_probe_vars (arg +1 , t, f, is_return, is_kprobe);break ;case '%' :/* named register */
@@ -443,6 +445,10 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t, }else {struct symbol_cache *sc; +/* uprobes don't support symbols */ +if (!is_kprobe) +return -EINVAL ; + ret =traceprobe_split_symbol_offset (arg +1 , &offset);if (ret)break ;
@@ -554,7 +560,7 @@ int traceprobe_parse_probe_arg(char *arg, ssize_t *size,int ret;const struct fetch_type *ttbl; - ttbl = kprobes_fetch_type_table; + ttbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table;if (strlen (arg) >MAX_ARGSTR_LEN ) {pr_info ("Argument is too long.: %s\n" , arg);
Signature · 1 line
1.7.11.7
Steven Rostedt
maintainerQuoted 5 lines · Namhyung Kim
Hello,
This patchset implements memory (address), stack[N], deference, bitfield and retval (it needs uretprobe tho) fetch methods for uprobes. It's based on the previous work [1] done by Hyeoncheol Lee.
Sending out new code in the middle of a merge window isn't the best timing. You may want to ping us again after the merge window closes, as focus currently is on getting 3.11 changes in and working. This patchset might get forgotten.
Thanks,
-- Steve
Hi Steve,
Quoted 11 lines · Steven Rostedt
Quoted 5 lines · Namhyung Kim
Hello,
This patchset implements memory (address), stack[N], deference, bitfield and retval (it needs uretprobe tho) fetch methods for uprobes. It's based on the previous work [1] done by Hyeoncheol Lee.
Sending out new code in the middle of a merge window isn't the best timing. You may want to ping us again after the merge window closes, as focus currently is on getting 3.11 changes in and working. This patchset might get forgotten.
Okay, I'll send a ping to you after the merge window closed.
Thanks,
Namhyung
Quoted 9 lines · Namhyung Kim
Hello,
This patchset implements memory (address), stack[N], deference, bitfield and retval (it needs uretprobe tho) fetch methods for uprobes. It's based on the previous work [1] done by Hyeoncheol Lee.
Now kprobes and uprobes have their own
fetch_type_tablesand, in turn, memory and stack access methods. Other fetch methods are shared.
Quoted 7 lines
For the dereference method, I added a new argument to fetch functions. It's because for uprobes it needs to know whether the given address is a file offset or a virtual address in an user process. For instance, in case of fetching from a memory directly (like @offset) it should convert the address (offset) to a virtual address of the process, but if it's a dereferencing, the given address already has the virtual address.
Thanks Namhyung,
I agree that uprobe requires a special (file-relative) dereference code. I'll look into the basic implementation after fixing current dynamic-event related bugs. :)
(I see, this one should be updated to the latest tree, after
merge window is closed)
Thank you,
Quoted 108 lines
To determine this in a fetch function, I passed a pointer to
trace_uprobefor direct fetch, and passed NULL for dereference.[1] https://lkml.org/lkml/2012/11/14/84
Simple example:
# cat foo.c int glob = -1; char str[] = "hello uprobe.";struct foo { unsigned int unused: 2; unsigned int foo: 20; unsigned int bar: 10; } foo = { .foo = 5, }; int main(int argc, char *argv[]) { long local = 0x1234;return 127;}
# gcc -o foo -g foo.c# objdump -d foo | grep -A9 -F '<main>' 00000000004004b0 <main>: 4004b0: 55 push %rbp 4004b1: 48 89 e5 mov %rsp,%rbp 4004b4: 89 7d ec mov %edi,-0x14(%rbp) 4004b7: 48 89 75 e0 mov %rsi,-0x20(%rbp) 4004bb: 48 c7 45 f8 34 12 00 movq $0x1234,-0x8(%rbp) 4004c2: 00 4004c3: b8 7f 00 00 00 mov $0x7f,%eax 4004c8: 5d pop %rbp 4004c9: c3 retq# nm foo | grep -e glob$ -e str -e foo 00000000006008bc D foo 00000000006008a8 D glob 00000000006008ac D str# perf probe -x /home/namhyung/tmp/foo -a 'foo=main+0x13 glob=@0x8a8:s32 \Quoted 1 line
str=@0x8ac:string bit=@0x8bc:b10@2/32 argc=%di local=-0x8(%bp)'
Added new event:
probe_foo:foo (on 0x4c3 with glob=@0x8a8:s32 str=@0x8ac:string bit=@0x8bc:b10@2/32 argc=%di local=-0x8(%bp))You can now use it in all perf tools, such as:
perf record -e probe_foo:foo -aR sleep 1
# perf record -e probe_foo:foo ./foo [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.001 MB perf.data (~33 samples) ]# perf script | grep -v ^# foo 2008 [002 2199.867154: probe_foo:foo (4004c3) glob=4294967295 str="hello uprobe." bit=5 argc=1 local=1234Note that 4294967295 is
0xffffffff.Obviously, the perf tools also need to be improved. I'll work on that later.
This patchset is based on the current tip/perf/core. I also put this on my 'uprobe/fetch-v1' branch in my tree:
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung/linux-perf.gitAny comments are welcome, thanks.
NamhyungCc Masami Hiramatsu <[email protected]>Cc Srikar Dronamraju <[email protected]>Cc Oleg Nesterov <[email protected]>Cc Arnaldo Carvalho de Melo <[email protected]>Hyeoncheol Lee (2):
tracing/kprobes: Move fetch functions totrace_kprobe.ctracing/kprobes: Add fetch{,_size} member into symbol and deref fetch
methodNamhyung Kim (10):
tracing/kprobes: Make stack and memory fetch functions static tracing/kprobes: Factor out structtrace_probetracing/uprobes: Convert to structtrace_probetracing/kprobes: Move common functions totrace_probe.ctracing/kprobes: Remove duplicateset_print_fmt()tracing/uprobes: Fetch args before reserving a ring buffer tracing/uprobes: Fix a comment for uprobe registration syntax tracing/kprobes: Add priv argument to fetch functions tracing/uprobes: Add more fetch functions tracing/uprobes: Add support for full argument access methodskernel/trace/trace_kprobe.c | 529 ++++++++++++++++++++++---------------------- kernel/trace/trace_probe.c | 451 ++++++++++++++++++------------------- kernel/trace/trace_probe.h | 154 ++++++++++++- kernel/trace/trace_uprobe.c | 429 ++++++++++++++++++++++++----------- 4 files changed, 926 insertions(+), 637 deletions(-)
Signature · 4 lines
Masami HIRAMATSU IT Management Research Dept. Linux Technology Center Hitachi, Ltd., Yokohama Research Laboratory E-mail: [email protected]
Hi Masami,
Quoted 18 lines · Masami Hiramatsu
Quoted 9 lines · Namhyung Kim
Hello,
This patchset implements memory (address), stack[N], deference, bitfield and retval (it needs uretprobe tho) fetch methods for uprobes. It's based on the previous work [1] done by Hyeoncheol Lee.
Now kprobes and uprobes have their own
fetch_type_tablesand, in turn, memory and stack access methods. Other fetch methods are shared.Quoted 7 lines
For the dereference method, I added a new argument to fetch functions. It's because for uprobes it needs to know whether the given address is a file offset or a virtual address in an user process. For instance, in case of fetching from a memory directly (like @offset) it should convert the address (offset) to a virtual address of the process, but if it's a dereferencing, the given address already has the virtual address.
Quoted 6 lines
Thanks Namhyung,
I agree that uprobe requires a special (file-relative) dereference code. I'll look into the basic implementation after fixing current dynamic-event related bugs. :)
(I see, this one should be updated to the latest tree, after
merge window is closed)
Yes, I'm catching up the changes. I'll resend v2 after -rc1 released.
Thanks,
Namhyung