perf-probe updates - optprobe, elfutils and lazy matching
Subsystems (5)
cover perf-probe updates - optprobe, elfutils and lazy matching
Hi,
Here are several bugfixes and updates for perf-probe/kprobes. This updates includes moving onto elfutils-libdw and
the lazy line matching support.
This version also includes the patchset of the kprobes jump optimization so that we can ensure the 'perf-probe' will utilize it by default. :)
This version changes nothing but merging previous two patch-sets and updating against 2.6.33-tip.
- elfutils library is developed closely with gcc team, and it is simple and fast dwarf analysis library.
- lazy-matching is similar to glob matching but ignoring spaces in both of target and pattern.
- Kprobes jump optimization allows kprobes to replace breakpoint with a jump instruction for reducing probing overhead drastically. (See Documentation/kprobes.txt for details)
This is updated todo list. Most of them are related to the 'type' support.
TODO:
- Enhance probe-finder to decode call frame instructions.
- Support sys_perf_counter_open (for non-root users)
- Support tracing static variables (non global)
- Support variable types from debuginfo (e.g. char, int, ...)
- Support fields of data structures (var->field)
- Support array (var[N])
- Support dynamic array-indexing (var[var2])
- Support string/dynamic arrays (*var, var[N..M])
- Support force type-casting ((type)var)
- Support the type of return value
- More debugger like enhancements(%next, --disasm, etc.)
- Better support for probes on modules
- --list option shows the file-name/line-number of each events.
- Support kprobes optimization on preemptive kernel.
How to check jump optimization
==============================
The jump replacement optimization is transparently and automatically done in kprobes.
So, if you enables CONFIG_KPROBE_EVENT(a.k.a. kprobe-tracer) in kernel config, all kprobes users including 'perf probe' can benefit from this feature.
e.g.
# perf probe schedule Added new event: probe:schedule (on schedule+0)
You can now use it on all perf tools, such as:
perf record -e probe:schedule -a sleep 1
# cat /sys/kernel/debug/kprobes/list c069ce4c k schedule+0x0 [DISABLED]
# echo 1 > /sys/kernel/debug/tracing/events/kprobes/probe1/enable
# cat /sys/kernel/debug/kprobes/list c069ce4c k schedule+0x0 [OPTIMIZED]
Or
# perf record -f -a -e probe:schedule cat /sys/kernel/debug/kprobes/list c069cb8c k schedule+0x0 [OPTIMIZED] [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.036 MB perf.data (~1586 samples) ]
Note:
Which probe can be optimized is depends on the actual kernel binary. So, in some cases, it might not be optimized. Please try to probe another place in that case.
Thank you,
---
Masami Hiramatsu (18):
perf probe: Add lazy line matching support
perf probe: show more lines after last line
perf probe: Check function address range strictly in line finder perf probe: Use libdw callback routines
perf probe: Use elfutils-libdw for analyzing debuginfo perf probe: Rename probe finder functions
perf probe: Fix bugs in line range finder
perf probe: Update perf probe document
perf probe: Do not show --line option without dwarf support
kprobes: Add documents of jump optimization
kprobes/x86: Support kprobes jump optimization on x86
x86: Add text_poke_smp for SMP cross modifying code kprobes/x86: Cleanup save/restore registers
kprobes/x86: Boost probes when reentering
kprobes: Jump optimization sysctl interface
kprobes: Introduce kprobes jump optimization
kprobes: Introduce generic insn_slot framework kprobes/x86: Cleanup RELATIVEJUMP_INSTRUCTION to RELATIVEJUMP_OPCODE
Documentation/kprobes.txt | 207 ++++++ arch/Kconfig | 13 arch/x86/Kconfig | 1 arch/x86/include/asm/alternative.h | 4 arch/x86/include/asm/kprobes.h | 31 + arch/x86/kernel/alternative.c | 60 ++ arch/x86/kernel/kprobes.c | 609 ++++++++++++++++--- include/linux/kprobes.h | 44 + kernel/kprobes.c | 647 +++++++++++++++++--- kernel/sysctl.c | 12 tools/perf/Documentation/perf-probe.txt | 58 ++ tools/perf/Makefile | 10 tools/perf/builtin-probe.c | 36 + tools/perf/util/probe-event.c | 55 +- tools/perf/util/probe-finder.c | 1002 ++++++++++++++----------------- tools/perf/util/probe-finder.h | 53 +- tools/perf/util/string.c | 55 +- tools/perf/util/string.h | 1 18 files changed, 2063 insertions(+), 835 deletions(-)
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
PATCH 1/18 kprobes/x86: Cleanup RELATIVEJUMP_INSTRUCTION to RELATIVEJUMP_OPCODE
Change RELATIVEJUMP_INSTRUCTION macro to RELATIVEJUMP_OPCODE since it represents just the opcode byte.
---
arch/x86/include/asm/kprobes.h | 2 +- arch/x86/kernel/kprobes.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/include/asm/kprobes.h +1 -1
@@ -32,7 +32,7 @@ struct kprobe;typedef u8 kprobe_opcode_t ;#define BREAKPOINT_INSTRUCTION 0xcc -#define RELATIVEJUMP_INSTRUCTION 0xe9 +#define RELATIVEJUMP_OPCODE 0xe9#define MAX_INSN_SIZE 16#define MAX_STACK_SIZE 64#define MIN_STACK_SIZE (ADDR ) \
arch/x86/kernel/kprobes.c +1 -1
@@ -115,7 +115,7 @@ static void __kprobes set_jmp_op(void *from, void *to) } __attribute__((packed)) * jop; jop = (struct __arch_jmp_op *)from; jop->raddr = (s32)((long )(to) - ((long )(from) +5 )); - jop->op =RELATIVEJUMP_INSTRUCTION ; + jop->op =RELATIVEJUMP_OPCODE ; }/*
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Re: [PATCH -tip v3&10 01/18] kprobes/x86: Cleanup RELATIVEJUMP_INSTRUCTION to RELATIVEJUMP_OPCODE
Quoted 2 lines · * Masami Hiramatsu ([email protected]) wrote:
Change
RELATIVEJUMP_INSTRUCTIONmacro toRELATIVEJUMP_OPCODEsince it represents just the opcode byte.
Quoted 58 lines
Signed-off-by Masami Hiramatsu <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>Cc Ingo Molnar <[email protected]>Cc Jim Keniston <[email protected]>Cc Srikar Dronamraju <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Steven Rostedt <[email protected]>Cc Frederic Weisbecker <[email protected]>Cc H. Peter Anvin <[email protected]>Cc Anders Kaseorg <[email protected]>Cc Tim Abbott <[email protected]>Cc Andi Kleen <[email protected]>Cc Jason Baron <[email protected]>Cc Mathieu Desnoyers <[email protected]>---
arch/x86/include/asm/kprobes.h | 2 +- arch/x86/kernel/kprobes.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)arch/x86/include/asm/kprobes.h +1
-1@@ -32,7 +32,7 @@ struct kprobe;typedef u8 kprobe_opcode_t ;#define BREAKPOINT_INSTRUCTION 0xcc -#define RELATIVEJUMP_INSTRUCTION 0xe9 +#define RELATIVEJUMP_OPCODE 0xe9#define MAX_INSN_SIZE 16#define MAX_STACK_SIZE 64#define MIN_STACK_SIZE (ADDR ) \arch/x86/kernel/kprobes.c +1
-1@@ -115,7 +115,7 @@ static void __kprobes set_jmp_op(void *from, void *to) } __attribute__((packed)) * jop; jop = (struct __arch_jmp_op *)from; jop->raddr = (s32)((long )(to) - ((long )(from) +5 )); - jop->op =RELATIVEJUMP_INSTRUCTION ; + jop->op =RELATIVEJUMP_OPCODE ; }/* Signature · 8 lines
-- Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency Consultant EfficiOS Inc. http://www.efficios.com
[tip:perf/probes] kprobes/x86: Cleanup RELATIVEJUMP_INSTRUCTION to RELATIVEJUMP_OPCODE
In reply to Masami HiramatsuCommit-ID: d498f763950703c724c650db1d34a1c8679f9ca8 Gitweb: http://git.kernel.org/tip/d498f763950703c724c650db1d34a1c8679f9ca8 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:33:49 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:24 +0100
kprobes/x86: Cleanup RELATIVEJUMP_INSTRUCTION to RELATIVEJUMP_OPCODE
Change RELATIVEJUMP_INSTRUCTION macro to RELATIVEJUMP_OPCODE since it represents just the opcode byte.
LKML-Reference: <[email protected]>
--- arch/x86/include/asm/kprobes.h | 2 +- arch/x86/kernel/kprobes.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/include/asm/kprobes.h +1 -1
@@ -32,7 +32,7 @@ struct kprobe;typedef u8 kprobe_opcode_t ;#define BREAKPOINT_INSTRUCTION 0xcc -#define RELATIVEJUMP_INSTRUCTION 0xe9 +#define RELATIVEJUMP_OPCODE 0xe9#define MAX_INSN_SIZE 16#define MAX_STACK_SIZE 64#define MIN_STACK_SIZE (ADDR ) \
arch/x86/kernel/kprobes.c +1 -1
@@ -115,7 +115,7 @@ static void __kprobes set_jmp_op(void *from, void *to) } __attribute__((packed)) * jop; jop = (struct __arch_jmp_op *)from; jop->raddr = (s32)((long )(to) - ((long )(from) +5 )); - jop->op =RELATIVEJUMP_INSTRUCTION ; + jop->op =RELATIVEJUMP_OPCODE ; }/*
PATCH 2/18 kprobes: Introduce generic insn_slot framework
In reply to Masami HiramatsuMake insn_slot framework support various size slots.
Current insn_slot just supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.
---
kernel/kprobes.c | 104 ++++++++++++++++++++++++++++++++++-------------------- 1 files changed, 65 insertions(+), 39 deletions(-)
kernel/kprobes.c +65 -39
@@ -105,57 +105,74 @@ static struct kprobe_blackpoint kprobe_blacklist[] = {* stepping on the instruction on a vmalloced/kmalloced/data page * is a recipe for disaster */ -#define INSNS_PER_PAGE (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))) -struct kprobe_insn_page {struct list_head list;kprobe_opcode_t *insns;/* Page of instruction slots */ -char slot_used[INSNS_PER_PAGE ];int nused;int ngarbage; +char slot_used[]; +}; + +#define KPROBE_INSN_PAGE_SIZE (slots) \ + (offsetof(struct kprobe_insn_page, slot_used) + \ + (sizeof(char) * (slots))) + +struct kprobe_insn_cache { +struct list_head pages;/* list of kprobe_insn_page */ +size_t insn_size;/* size of instruction slot */ +int nr_garbage; }; +static int slots_per_page (struct kprobe_insn_cache *c) +{ +return PAGE_SIZE /(c->insn_size *sizeof (kprobe_opcode_t)); +} +enum kprobe_slot_state {SLOT_CLEAN =0 ,SLOT_DIRTY =1 ,SLOT_USED =2 , }; -static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_pages */ -static LIST_HEAD (kprobe_insn_pages); -static int kprobe_garbage_slots; -static int collect_garbage_slots (void ); +static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_slots */ +static struct kprobe_insn_cache kprobe_insn_slots = { + .pages =LIST_HEAD_INIT (kprobe_insn_slots.pages), + .insn_size =MAX_INSN_SIZE , + .nr_garbage =0 , +}; +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c);/** * __get_insn_slot() - Find a slot on an executable page for an instruction. * We allocate an executable page if there's no room on existing ones. */ -static kprobe_opcode_t __kprobes *__get_insn_slot (void ) +static kprobe_opcode_t __kprobes *__get_insn_slot (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip; retry: -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->nused <INSNS_PER_PAGE ) { +list_for_each_entry (kip, &c->pages, list) { +if (kip->nused <slots_per_page (c)) {int i; -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_CLEAN ) { kip->slot_used[i] =SLOT_USED ; kip->nused++; -return kip->insns + (i *MAX_INSN_SIZE ); +return kip->insns + (i * c->insn_size); } } -/* Surprise! No unused slots. Fix kip->nused. */ - kip->nused =INSNS_PER_PAGE ; +/* kip->nused is broken. Fix it. */ + kip->nused =slots_per_page (c); +WARN_ON (1 ); } }/* If there are any garbage slots, collect it and try again. */ -if (kprobe_garbage_slots &&collect_garbage_slots () ==0 ) { +if (c->nr_garbage &&collect_garbage_slots (c) ==0 ) goto retry; - } -/* All out of space. Need to allocate a new page. Use slot 0. */ - kip =kmalloc (sizeof (struct kprobe_insn_page ),GFP_KERNEL ); + +/* All out of space. Need to allocate a new page. */ + kip =kmalloc (KPROBE_INSN_PAGE_SIZE (slots_per_page (c)),GFP_KERNEL );if (!kip)return NULL ;
@@ -170,20 +187,23 @@ static kprobe_opcode_t __kprobes *__get_insn_slot(void)return NULL ; }INIT_LIST_HEAD (&kip->list); -list_add (&kip->list, &kprobe_insn_pages); -memset (kip->slot_used,SLOT_CLEAN ,INSNS_PER_PAGE ); +memset (kip->slot_used,SLOT_CLEAN ,slots_per_page (c)); kip->slot_used[0 ] =SLOT_USED ; kip->nused =1 ; kip->ngarbage =0 ; +list_add (&kip->list, &c->pages);return kip->insns; } +kprobe_opcode_t __kprobes *get_insn_slot (void ) { -kprobe_opcode_t *ret; +kprobe_opcode_t *ret =NULL ; +mutex_lock (&kprobe_insn_mutex); - ret =__get_insn_slot (); + ret =__get_insn_slot (&kprobe_insn_slots);mutex_unlock (&kprobe_insn_mutex); +return ret; }
@@ -199,7 +219,7 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)* so as not to have to set it up again the * next time somebody inserts a probe. */ -if (!list_is_singular (&kprobe_insn_pages)) { +if (!list_is_singular (&kip->list)) {list_del (&kip->list);module_free (NULL , kip->insns);kfree (kip);
@@ -209,49 +229,55 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)return 0 ; } -static int __kprobes collect_garbage_slots (void ) +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip, *next;/* Ensure no-one is interrupted on the garbages */ synchronize_sched (); -list_for_each_entry_safe (kip, next, &kprobe_insn_pages, list) { +list_for_each_entry_safe (kip, next, &c->pages, list) {int i;if (kip->ngarbage ==0 )continue ; kip->ngarbage =0 ;/* we will collect all garbages */ -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_DIRTY &&collect_one_slot (kip, i))break ; } } - kprobe_garbage_slots =0 ; + c->nr_garbage =0 ;return 0 ; } -void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +static void __kprobes __free_insn_slot (struct kprobe_insn_cache *c, +kprobe_opcode_t *slot,int dirty) {struct kprobe_insn_page *kip; -mutex_lock (&kprobe_insn_mutex); -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->insns <= slot && - slot < kip->insns + (INSNS_PER_PAGE *MAX_INSN_SIZE )) { -int i = (slot - kip->insns) /MAX_INSN_SIZE ; +list_for_each_entry (kip, &c->pages, list) { +long idx = ((long )slot - (long )kip->insns) / c->insn_size; +if (idx >=0 && idx <slots_per_page (c)) { +WARN_ON (kip->slot_used[idx] !=SLOT_USED );if (dirty) { - kip->slot_used[i] =SLOT_DIRTY ; + kip->slot_used[idx] =SLOT_DIRTY ; kip->ngarbage++; +if (++c->nr_garbage >slots_per_page (c)) +collect_garbage_slots (c); }else -collect_one_slot (kip, i); -break ; +collect_one_slot (kip, idx); +return ; } } +/* Could not free this slot. */ +WARN_ON (1 ); +} -if (dirty && ++kprobe_garbage_slots >INSNS_PER_PAGE ) -collect_garbage_slots (); - +void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +{ +mutex_lock (&kprobe_insn_mutex); +__free_insn_slot (&kprobe_insn_slots, slot, dirty);mutex_unlock (&kprobe_insn_mutex); }#endif
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Re: [PATCH -tip v3&10 02/18] kprobes: Introduce generic insn_slot framework
Quoted 3 lines · * Masami Hiramatsu ([email protected]) wrote:
Make
insn_slotframework support various size slots.
Currentinsn_slotjust supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.
OK, so you end up having one insn slot cache for kprobes and one insn slot (eventually) for the static jump patching (which needs larger instruction slots than kprobes). That seems like a good way to ensure you do not use more memory than necessary.
We could possibly go even further and automatically use the right insn slot cache given the size of the instruction entry that must be added (a bit like the memory allocator which have different pools for each allocation order).
Possibly that using the terminology of "memory pools" rather than "cache" could be a better fit too. So what this really becomes is an instruction slot allocator and garbage collector.
Thanks,
Mathieu
Quoted 237 lines
Signed-off-by Masami Hiramatsu <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>Cc Ingo Molnar <[email protected]>Cc Jim Keniston <[email protected]>Cc Srikar Dronamraju <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Steven Rostedt <[email protected]>Cc Frederic Weisbecker <[email protected]>Cc H. Peter Anvin <[email protected]>Cc Anders Kaseorg <[email protected]>Cc Tim Abbott <[email protected]>Cc Andi Kleen <[email protected]>Cc Jason Baron <[email protected]>Cc Mathieu Desnoyers <[email protected]>---
kernel/kprobes.c | 104 ++++++++++++++++++++++++++++++++++-------------------- 1 files changed, 65 insertions(+), 39 deletions(-)kernel/kprobes.c +65
-39@@ -105,57 +105,74 @@ static struct kprobe_blackpoint kprobe_blacklist[] = {* stepping on the instruction on a vmalloced/kmalloced/data page * is a recipe for disaster */ -#define INSNS_PER_PAGE (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))) -struct kprobe_insn_page {struct list_head list;kprobe_opcode_t *insns;/* Page of instruction slots */ -char slot_used[INSNS_PER_PAGE ];int nused;int ngarbage; +char slot_used[]; +}; + +#define KPROBE_INSN_PAGE_SIZE (slots) \ + (offsetof(struct kprobe_insn_page, slot_used) + \ + (sizeof(char) * (slots))) + +struct kprobe_insn_cache { +struct list_head pages;/* list of kprobe_insn_page */ +size_t insn_size;/* size of instruction slot */ +int nr_garbage; }; +static int slots_per_page (struct kprobe_insn_cache *c) +{ +return PAGE_SIZE /(c->insn_size *sizeof (kprobe_opcode_t)); +} +enum kprobe_slot_state {SLOT_CLEAN =0 ,SLOT_DIRTY =1 ,SLOT_USED =2 , }; -static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_pages */ -static LIST_HEAD (kprobe_insn_pages); -static int kprobe_garbage_slots; -static int collect_garbage_slots (void ); +static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_slots */ +static struct kprobe_insn_cache kprobe_insn_slots = { + .pages =LIST_HEAD_INIT (kprobe_insn_slots.pages), + .insn_size =MAX_INSN_SIZE , + .nr_garbage =0 , +}; +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c);/** * __get_insn_slot() - Find a slot on an executable page for an instruction. * We allocate an executable page if there's no room on existing ones. */ -static kprobe_opcode_t __kprobes *__get_insn_slot (void ) +static kprobe_opcode_t __kprobes *__get_insn_slot (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip; retry: -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->nused <INSNS_PER_PAGE ) { +list_for_each_entry (kip, &c->pages, list) { +if (kip->nused <slots_per_page (c)) {int i; -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_CLEAN ) { kip->slot_used[i] =SLOT_USED ; kip->nused++; -return kip->insns + (i *MAX_INSN_SIZE ); +return kip->insns + (i * c->insn_size); } } -/* Surprise! No unused slots. Fix kip->nused. */ - kip->nused =INSNS_PER_PAGE ; +/* kip->nused is broken. Fix it. */ + kip->nused =slots_per_page (c); +WARN_ON (1 ); } }/* If there are any garbage slots, collect it and try again. */ -if (kprobe_garbage_slots &&collect_garbage_slots () ==0 ) { +if (c->nr_garbage &&collect_garbage_slots (c) ==0 ) goto retry; - } -/* All out of space. Need to allocate a new page. Use slot 0. */ - kip =kmalloc (sizeof (struct kprobe_insn_page ),GFP_KERNEL ); + +/* All out of space. Need to allocate a new page. */ + kip =kmalloc (KPROBE_INSN_PAGE_SIZE (slots_per_page (c)),GFP_KERNEL );if (!kip)return NULL ;@@ -170,20 +187,23 @@ static kprobe_opcode_t __kprobes *__get_insn_slot(void)return NULL ; }INIT_LIST_HEAD (&kip->list); -list_add (&kip->list, &kprobe_insn_pages); -memset (kip->slot_used,SLOT_CLEAN ,INSNS_PER_PAGE ); +memset (kip->slot_used,SLOT_CLEAN ,slots_per_page (c)); kip->slot_used[0 ] =SLOT_USED ; kip->nused =1 ; kip->ngarbage =0 ; +list_add (&kip->list, &c->pages);return kip->insns; } +kprobe_opcode_t __kprobes *get_insn_slot (void ) { -kprobe_opcode_t *ret; +kprobe_opcode_t *ret =NULL ; +mutex_lock (&kprobe_insn_mutex); - ret =__get_insn_slot (); + ret =__get_insn_slot (&kprobe_insn_slots);mutex_unlock (&kprobe_insn_mutex); +return ret; }@@ -199,7 +219,7 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)* so as not to have to set it up again the * next time somebody inserts a probe. */ -if (!list_is_singular (&kprobe_insn_pages)) { +if (!list_is_singular (&kip->list)) {list_del (&kip->list);module_free (NULL , kip->insns);kfree (kip);@@ -209,49 +229,55 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)return 0 ; } -static int __kprobes collect_garbage_slots (void ) +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip, *next;/* Ensure no-one is interrupted on the garbages */ synchronize_sched (); -list_for_each_entry_safe (kip, next, &kprobe_insn_pages, list) { +list_for_each_entry_safe (kip, next, &c->pages, list) {int i;if (kip->ngarbage ==0 )continue ; kip->ngarbage =0 ;/* we will collect all garbages */ -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_DIRTY &&collect_one_slot (kip, i))break ; } } - kprobe_garbage_slots =0 ; + c->nr_garbage =0 ;return 0 ; } -void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +static void __kprobes __free_insn_slot (struct kprobe_insn_cache *c, +kprobe_opcode_t *slot,int dirty) {struct kprobe_insn_page *kip; -mutex_lock (&kprobe_insn_mutex); -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->insns <= slot && - slot < kip->insns + (INSNS_PER_PAGE *MAX_INSN_SIZE )) { -int i = (slot - kip->insns) /MAX_INSN_SIZE ; +list_for_each_entry (kip, &c->pages, list) { +long idx = ((long )slot - (long )kip->insns) / c->insn_size; +if (idx >=0 && idx <slots_per_page (c)) { +WARN_ON (kip->slot_used[idx] !=SLOT_USED );if (dirty) { - kip->slot_used[i] =SLOT_DIRTY ; + kip->slot_used[idx] =SLOT_DIRTY ; kip->ngarbage++; +if (++c->nr_garbage >slots_per_page (c)) +collect_garbage_slots (c); }else -collect_one_slot (kip, i); -break ; +collect_one_slot (kip, idx); +return ; } } +/* Could not free this slot. */ +WARN_ON (1 ); +} -if (dirty && ++kprobe_garbage_slots >INSNS_PER_PAGE ) -collect_garbage_slots (); - +void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +{ +mutex_lock (&kprobe_insn_mutex); +__free_insn_slot (&kprobe_insn_slots, slot, dirty);mutex_unlock (&kprobe_insn_mutex); }#endif Signature · 8 lines
-- Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency Consultant EfficiOS Inc. http://www.efficios.com
Re: [PATCH -tip v3&10 02/18] kprobes: Introduce generic insn_slot framework
Quoted 10 lines · Mathieu Desnoyers
Quoted 3 lines · * Masami Hiramatsu ([email protected]) wrote:
Make
insn_slotframework support various size slots.
Currentinsn_slotjust supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.OK, so you end up having one insn slot cache for kprobes and one insn slot (eventually) for the static jump patching (which needs larger instruction slots than kprobes). That seems like a good way to ensure you do not use more memory than necessary.
Quoted 4 lines
We could possibly go even further and automatically use the right insn slot cache given the size of the instruction entry that must be added (a bit like the memory allocator which have different pools for each allocation order).
Sure, that will be simpler interface.
Quoted 3 lines
Possibly that using the terminology of "memory pools" rather than "cache" could be a better fit too. So what this really becomes is an instruction slot allocator and garbage collector.
Ah, right. It would be better to rename kprobe_insn_pool() :)
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Re: [PATCH -tip v3&10 02/18] kprobes: Introduce generic insn_slot framework
Quoted 16 lines · Masami Hiramatsu
Quoted 10 lines · Mathieu Desnoyers
Quoted 3 lines · * Masami Hiramatsu ([email protected]) wrote:
Make
insn_slotframework support various size slots.
Currentinsn_slotjust supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.OK, so you end up having one insn slot cache for kprobes and one insn slot (eventually) for the static jump patching (which needs larger instruction slots than kprobes). That seems like a good way to ensure you do not use more memory than necessary.
Quoted 4 lines
We could possibly go even further and automatically use the right insn slot cache given the size of the instruction entry that must be added (a bit like the memory allocator which have different pools for each allocation order).
Quoted 7 lines
Sure, that will be simpler interface.
Quoted 3 lines
Possibly that using the terminology of "memory pools" rather than "cache" could be a better fit too. So what this really becomes is an instruction slot allocator and garbage collector.
Ah, right. It would be better to rename
kprobe_insn_pool():)
Hmm, I tried it. And finally, I found that this doesn't help to simplify code... Maybe it is better to postpone it until another user needs this feature.
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Re: [PATCH -tip v3&10 02/18] kprobes: Introduce generic insn_slot framework
Quoted 23 lines · * Masami Hiramatsu ([email protected]) wrote:
Quoted 22 lines · Masami Hiramatsu
Quoted 10 lines · Mathieu Desnoyers
Quoted 3 lines · * Masami Hiramatsu ([email protected]) wrote:
Make
insn_slotframework support various size slots.
Currentinsn_slotjust supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.OK, so you end up having one insn slot cache for kprobes and one insn slot (eventually) for the static jump patching (which needs larger instruction slots than kprobes). That seems like a good way to ensure you do not use more memory than necessary.
Quoted 4 lines
We could possibly go even further and automatically use the right insn slot cache given the size of the instruction entry that must be added (a bit like the memory allocator which have different pools for each allocation order).
Sure, that will be simpler interface.
Quoted 3 lines
Possibly that using the terminology of "memory pools" rather than "cache" could be a better fit too. So what this really becomes is an instruction slot allocator and garbage collector.
Quoted 5 lines
Quoted 1 line
Ah, right. It would be better to rename
kprobe_insn_pool():)Hmm, I tried it. And finally, I found that this doesn't help to simplify code... Maybe it is better to postpone it until another user needs this feature.
I guess it's a tradeoff between the genericity of the API you provide and the complexity of the code that provides this API. So as you say, maybe it's better to wait until more users appears before improving the API.
Thanks,
Mathieu
Quoted 7 lines
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency Consultant EfficiOS Inc. http://www.efficios.com
Re: [PATCH -tip v3&10 02/18] kprobes: Introduce generic insn_slot framework
Quoted 26 lines · Mathieu Desnoyers
Quoted 25 lines · * Masami Hiramatsu ([email protected]) wrote:
Quoted 23 lines · Masami Hiramatsu
Quoted 10 lines · Mathieu Desnoyers
Quoted 3 lines · * Masami Hiramatsu ([email protected]) wrote:
Make
insn_slotframework support various size slots.
Currentinsn_slotjust supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.OK, so you end up having one insn slot cache for kprobes and one insn slot (eventually) for the static jump patching (which needs larger instruction slots than kprobes). That seems like a good way to ensure you do not use more memory than necessary.
Quoted 4 lines
We could possibly go even further and automatically use the right insn slot cache given the size of the instruction entry that must be added (a bit like the memory allocator which have different pools for each allocation order).
Sure, that will be simpler interface.
Quoted 3 lines
Possibly that using the terminology of "memory pools" rather than "cache" could be a better fit too. So what this really becomes is an instruction slot allocator and garbage collector.
Ah, right. It would be better to rename
kprobe_insn_pool():)
Quoted 8 lines
Quoted 3 lines
Hmm, I tried it. And finally, I found that this doesn't help to simplify code... Maybe it is better to postpone it until another user needs this feature.
I guess it's a tradeoff between the genericity of the API you provide and the complexity of the code that provides this API. So as you say, maybe it's better to wait until more users appears before improving the API.
OK, I'll hold that generalizing patch until that. :)
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
[tip:perf/probes] kprobes: Introduce generic insn_slot framework
In reply to Masami HiramatsuCommit-ID: 4610ee1d3638fa05ba8e87ccfa971db8e4033ae7 Gitweb: http://git.kernel.org/tip/4610ee1d3638fa05ba8e87ccfa971db8e4033ae7 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:33:59 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:24 +0100
kprobes: Introduce generic insn_slot framework
Make insn_slot framework support various size slots. Current insn_slot just supports one-size instruction buffer slot. However, kprobes jump optimization needs larger size buffers.
LKML-Reference: <[email protected]>
--- kernel/kprobes.c | 104 +++++++++++++++++++++++++++++++++-------------------- 1 files changed, 65 insertions(+), 39 deletions(-)
kernel/kprobes.c +65 -39
@@ -105,57 +105,74 @@ static struct kprobe_blackpoint kprobe_blacklist[] = {* stepping on the instruction on a vmalloced/kmalloced/data page * is a recipe for disaster */ -#define INSNS_PER_PAGE (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))) -struct kprobe_insn_page {struct list_head list;kprobe_opcode_t *insns;/* Page of instruction slots */ -char slot_used[INSNS_PER_PAGE ];int nused;int ngarbage; +char slot_used[]; +}; + +#define KPROBE_INSN_PAGE_SIZE (slots) \ + (offsetof(struct kprobe_insn_page, slot_used) + \ + (sizeof(char) * (slots))) + +struct kprobe_insn_cache { +struct list_head pages;/* list of kprobe_insn_page */ +size_t insn_size;/* size of instruction slot */ +int nr_garbage; }; +static int slots_per_page (struct kprobe_insn_cache *c) +{ +return PAGE_SIZE /(c->insn_size *sizeof (kprobe_opcode_t)); +} +enum kprobe_slot_state {SLOT_CLEAN =0 ,SLOT_DIRTY =1 ,SLOT_USED =2 , }; -static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_pages */ -static LIST_HEAD (kprobe_insn_pages); -static int kprobe_garbage_slots; -static int collect_garbage_slots (void ); +static DEFINE_MUTEX (kprobe_insn_mutex);/* Protects kprobe_insn_slots */ +static struct kprobe_insn_cache kprobe_insn_slots = { + .pages =LIST_HEAD_INIT (kprobe_insn_slots.pages), + .insn_size =MAX_INSN_SIZE , + .nr_garbage =0 , +}; +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c);/** * __get_insn_slot() - Find a slot on an executable page for an instruction. * We allocate an executable page if there's no room on existing ones. */ -static kprobe_opcode_t __kprobes *__get_insn_slot (void ) +static kprobe_opcode_t __kprobes *__get_insn_slot (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip; retry: -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->nused <INSNS_PER_PAGE ) { +list_for_each_entry (kip, &c->pages, list) { +if (kip->nused <slots_per_page (c)) {int i; -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_CLEAN ) { kip->slot_used[i] =SLOT_USED ; kip->nused++; -return kip->insns + (i *MAX_INSN_SIZE ); +return kip->insns + (i * c->insn_size); } } -/* Surprise! No unused slots. Fix kip->nused. */ - kip->nused =INSNS_PER_PAGE ; +/* kip->nused is broken. Fix it. */ + kip->nused =slots_per_page (c); +WARN_ON (1 ); } }/* If there are any garbage slots, collect it and try again. */ -if (kprobe_garbage_slots &&collect_garbage_slots () ==0 ) { +if (c->nr_garbage &&collect_garbage_slots (c) ==0 ) goto retry; - } -/* All out of space. Need to allocate a new page. Use slot 0. */ - kip =kmalloc (sizeof (struct kprobe_insn_page ),GFP_KERNEL ); + +/* All out of space. Need to allocate a new page. */ + kip =kmalloc (KPROBE_INSN_PAGE_SIZE (slots_per_page (c)),GFP_KERNEL );if (!kip)return NULL ;
@@ -170,20 +187,23 @@ static kprobe_opcode_t __kprobes *__get_insn_slot(void)return NULL ; }INIT_LIST_HEAD (&kip->list); -list_add (&kip->list, &kprobe_insn_pages); -memset (kip->slot_used,SLOT_CLEAN ,INSNS_PER_PAGE ); +memset (kip->slot_used,SLOT_CLEAN ,slots_per_page (c)); kip->slot_used[0 ] =SLOT_USED ; kip->nused =1 ; kip->ngarbage =0 ; +list_add (&kip->list, &c->pages);return kip->insns; } +kprobe_opcode_t __kprobes *get_insn_slot (void ) { -kprobe_opcode_t *ret; +kprobe_opcode_t *ret =NULL ; +mutex_lock (&kprobe_insn_mutex); - ret =__get_insn_slot (); + ret =__get_insn_slot (&kprobe_insn_slots);mutex_unlock (&kprobe_insn_mutex); +return ret; }
@@ -199,7 +219,7 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)* so as not to have to set it up again the * next time somebody inserts a probe. */ -if (!list_is_singular (&kprobe_insn_pages)) { +if (!list_is_singular (&kip->list)) {list_del (&kip->list);module_free (NULL , kip->insns);kfree (kip);
@@ -209,49 +229,55 @@ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)return 0 ; } -static int __kprobes collect_garbage_slots (void ) +static int __kprobes collect_garbage_slots (struct kprobe_insn_cache *c) {struct kprobe_insn_page *kip, *next;/* Ensure no-one is interrupted on the garbages */ synchronize_sched (); -list_for_each_entry_safe (kip, next, &kprobe_insn_pages, list) { +list_for_each_entry_safe (kip, next, &c->pages, list) {int i;if (kip->ngarbage ==0 )continue ; kip->ngarbage =0 ;/* we will collect all garbages */ -for (i =0 ; i <INSNS_PER_PAGE ; i++) { +for (i =0 ; i <slots_per_page (c); i++) {if (kip->slot_used[i] ==SLOT_DIRTY &&collect_one_slot (kip, i))break ; } } - kprobe_garbage_slots =0 ; + c->nr_garbage =0 ;return 0 ; } -void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +static void __kprobes __free_insn_slot (struct kprobe_insn_cache *c, +kprobe_opcode_t *slot,int dirty) {struct kprobe_insn_page *kip; -mutex_lock (&kprobe_insn_mutex); -list_for_each_entry (kip, &kprobe_insn_pages, list) { -if (kip->insns <= slot && - slot < kip->insns + (INSNS_PER_PAGE *MAX_INSN_SIZE )) { -int i = (slot - kip->insns) /MAX_INSN_SIZE ; +list_for_each_entry (kip, &c->pages, list) { +long idx = ((long )slot - (long )kip->insns) / c->insn_size; +if (idx >=0 && idx <slots_per_page (c)) { +WARN_ON (kip->slot_used[idx] !=SLOT_USED );if (dirty) { - kip->slot_used[i] =SLOT_DIRTY ; + kip->slot_used[idx] =SLOT_DIRTY ; kip->ngarbage++; +if (++c->nr_garbage >slots_per_page (c)) +collect_garbage_slots (c); }else -collect_one_slot (kip, i); -break ; +collect_one_slot (kip, idx); +return ; } } +/* Could not free this slot. */ +WARN_ON (1 ); +} -if (dirty && ++kprobe_garbage_slots >INSNS_PER_PAGE ) -collect_garbage_slots (); - +void __kprobes free_insn_slot (kprobe_opcode_t * slot,int dirty) +{ +mutex_lock (&kprobe_insn_mutex); +__free_insn_slot (&kprobe_insn_slots, slot, dirty);mutex_unlock (&kprobe_insn_mutex); }#endif
PATCH 3/18 kprobes: Introduce kprobes jump optimization
In reply to Masami HiramatsuIntroduce kprobes jump optimization arch-independent parts. Kprobes uses breakpoint instruction for interrupting execution flow, on some architectures, it can be replaced by a jump instruction and interruption emulation code. This gains kprobs' performance drastically.
To enable this feature, set CONFIG_OPTPROBES=y (default y if the arch supports OPTPROBE).
Changes in v9:
- Fix a bug to optimize probe when enabling.
- Check nearby probes can be optimize/unoptimize when disarming/arming kprobes, instead of registering/unregistering. This will help kprobe-tracer because most of probes on it are usually disabled.
Changes in v6:
- Cleanup coding style for readability.
- Add comments around get/put_online_cpus().
Changes in v5:
- Use get_online_cpus()/put_online_cpus() for avoiding text_mutex deadlock.
---
arch/Kconfig | 13 + include/linux/kprobes.h | 36 ++++ kernel/kprobes.c | 461 ++++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 459 insertions(+), 51 deletions(-)
arch/Kconfig +13 -0
@@ -57,6 +57,17 @@ config KPROBES for kernel debugging, non-intrusive instrumentation and testing. If in doubt, say "N". +config OPTPROBES + bool "Kprobes jump optimization support (EXPERIMENTAL)" + default y + depends on KPROBES + depends on !PREEMPT + depends on HAVE_OPTPROBES + select KALLSYMS_ALL + help + This option will allow kprobes to optimize breakpoint to + a jump for reducing its overhead. + config HAVE_EFFICIENT_UNALIGNED_ACCESS bool help
@@ -99,6 +110,8 @@ config HAVE_KPROBES config HAVE_KRETPROBES bool +config HAVE_OPTPROBES + bool # # An arch should select this if it provides all these things: #
include/linux/kprobes.h +36 -0
@@ -122,6 +122,11 @@ struct kprobe {/* Kprobe status flags */ #define KPROBE_FLAG_GONE 1/* breakpoint has already gone */ #define KPROBE_FLAG_DISABLED 2/* probe is temporarily disabled */ +#define KPROBE_FLAG_OPTIMIZED 4/* +* probe is really optimized. +* NOTE: +* this flag is only for optimized_kprobe. +*/ /* Has this kprobe gone ? */ static inline int kprobe_gone (struct kprobe *p)
@@ -134,6 +139,12 @@ static inline int kprobe_disabled(struct kprobe *p) {return p->flags & (KPROBE_FLAG_DISABLED |KPROBE_FLAG_GONE ); } + +/* Is this kprobe really running optimized path ? */ +static inline int kprobe_optimized (struct kprobe *p) +{ +return p->flags &KPROBE_FLAG_OPTIMIZED ; +}/* * Special probe type that uses setjmp-longjmp type tricks to resume * execution at a specified entry with a matching prototype corresponding
@@ -249,6 +260,31 @@ extern kprobe_opcode_t *get_insn_slot(void);extern void free_insn_slot (kprobe_opcode_t *slot,int dirty);extern void kprobes_inc_nmissed_count (struct kprobe *p); +#ifdef CONFIG_OPTPROBES +/* +* Internal structure for direct jump optimized probe +*/ +struct optimized_kprobe { +struct kprobe kp; +struct list_head list;/* list for optimizing queue */ +struct arch_optimized_insn optinsn; +}; + +/* Architecture dependent functions for direct jump optimization */ +extern int arch_prepared_optinsn (struct arch_optimized_insn *optinsn); +extern int arch_check_optimized_kprobe (struct optimized_kprobe *op); +extern int arch_prepare_optimized_kprobe (struct optimized_kprobe *op); +extern void arch_remove_optimized_kprobe (struct optimized_kprobe *op); +extern int arch_optimize_kprobe (struct optimized_kprobe *op); +extern void arch_unoptimize_kprobe (struct optimized_kprobe *op); +extern kprobe_opcode_t *get_optinsn_slot (void ); +extern void free_optinsn_slot (kprobe_opcode_t *slot,int dirty); +extern int arch_within_optimized_kprobe (struct optimized_kprobe *op, +unsigned long addr); + +extern void opt_pre_handler (struct kprobe *p,struct pt_regs *regs); +#endif /* CONFIG_OPTPROBES */ +/* Get the kprobe at this addr (if any) - called with preemption disabled */ struct kprobe *get_kprobe (void *addr); void kretprobe_hash_lock(struct task_struct *tsk,
kernel/kprobes.c +410 -51
676 lines not on this page · raw message
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes: Introduce kprobes jump optimization
Commit-ID: afd66255b9a48f5851326ddae50e2203fbf71dc9 Gitweb: http://git.kernel.org/tip/afd66255b9a48f5851326ddae50e2203fbf71dc9 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:07 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:24 +0100
kprobes: Introduce kprobes jump optimization
Introduce kprobes jump optimization arch-independent parts. Kprobes uses breakpoint instruction for interrupting execution flow, on some architectures, it can be replaced by a jump instruction and interruption emulation code. This gains kprobs' performance drastically.
To enable this feature, set CONFIG_OPTPROBES=y (default y if the arch supports OPTPROBE).
Changes in v9:
- Fix a bug to optimize probe when enabling.
- Check nearby probes can be optimize/unoptimize when disarming/arming kprobes, instead of registering/unregistering. This will help kprobe-tracer because most of probes on it are usually disabled.
Changes in v6:
- Cleanup coding style for readability.
- Add comments around get/put_online_cpus().
Changes in v5:
- Use get_online_cpus()/put_online_cpus() for avoiding text_mutex deadlock.
LKML-Reference: <[email protected]>
--- arch/Kconfig | 13 ++ include/linux/kprobes.h | 36 ++++ kernel/kprobes.c | 461 +++++++++++++++++++++++++++++++++++++++++------ 3 files changed, 459 insertions(+), 51 deletions(-)
arch/Kconfig +13 -0
@@ -57,6 +57,17 @@ config KPROBES for kernel debugging, non-intrusive instrumentation and testing. If in doubt, say "N". +config OPTPROBES + bool "Kprobes jump optimization support (EXPERIMENTAL)" + default y + depends on KPROBES + depends on !PREEMPT + depends on HAVE_OPTPROBES + select KALLSYMS_ALL + help + This option will allow kprobes to optimize breakpoint to + a jump for reducing its overhead. + config HAVE_EFFICIENT_UNALIGNED_ACCESS bool help
@@ -99,6 +110,8 @@ config HAVE_KPROBES config HAVE_KRETPROBES bool +config HAVE_OPTPROBES + bool # # An arch should select this if it provides all these things: #
include/linux/kprobes.h +36 -0
@@ -122,6 +122,11 @@ struct kprobe {/* Kprobe status flags */ #define KPROBE_FLAG_GONE 1/* breakpoint has already gone */ #define KPROBE_FLAG_DISABLED 2/* probe is temporarily disabled */ +#define KPROBE_FLAG_OPTIMIZED 4/* +* probe is really optimized. +* NOTE: +* this flag is only for optimized_kprobe. +*/ /* Has this kprobe gone ? */ static inline int kprobe_gone (struct kprobe *p)
@@ -134,6 +139,12 @@ static inline int kprobe_disabled(struct kprobe *p) {return p->flags & (KPROBE_FLAG_DISABLED |KPROBE_FLAG_GONE ); } + +/* Is this kprobe really running optimized path ? */ +static inline int kprobe_optimized (struct kprobe *p) +{ +return p->flags &KPROBE_FLAG_OPTIMIZED ; +}/* * Special probe type that uses setjmp-longjmp type tricks to resume * execution at a specified entry with a matching prototype corresponding
@@ -249,6 +260,31 @@ extern kprobe_opcode_t *get_insn_slot(void);extern void free_insn_slot (kprobe_opcode_t *slot,int dirty);extern void kprobes_inc_nmissed_count (struct kprobe *p); +#ifdef CONFIG_OPTPROBES +/* +* Internal structure for direct jump optimized probe +*/ +struct optimized_kprobe { +struct kprobe kp; +struct list_head list;/* list for optimizing queue */ +struct arch_optimized_insn optinsn; +}; + +/* Architecture dependent functions for direct jump optimization */ +extern int arch_prepared_optinsn (struct arch_optimized_insn *optinsn); +extern int arch_check_optimized_kprobe (struct optimized_kprobe *op); +extern int arch_prepare_optimized_kprobe (struct optimized_kprobe *op); +extern void arch_remove_optimized_kprobe (struct optimized_kprobe *op); +extern int arch_optimize_kprobe (struct optimized_kprobe *op); +extern void arch_unoptimize_kprobe (struct optimized_kprobe *op); +extern kprobe_opcode_t *get_optinsn_slot (void ); +extern void free_optinsn_slot (kprobe_opcode_t *slot,int dirty); +extern int arch_within_optimized_kprobe (struct optimized_kprobe *op, +unsigned long addr); + +extern void opt_pre_handler (struct kprobe *p,struct pt_regs *regs); +#endif /* CONFIG_OPTPROBES */ +/* Get the kprobe at this addr (if any) - called with preemption disabled */ struct kprobe *get_kprobe (void *addr); void kretprobe_hash_lock(struct task_struct *tsk,
kernel/kprobes.c +410 -51
676 lines not on this page · raw message
PATCH 4/18 kprobes: Jump optimization sysctl interface
In reply to Masami HiramatsuAdd /proc/sys/debug/kprobes-optimization sysctl which enables and disables kprobes jump optimization on the fly for debugging.
Changes in v7:
- Remove ctl_name = CTL_UNNUMBERED for upstream compatibility.
Changes in v6:
- Update comments and coding style.
---
include/linux/kprobes.h | 8 ++++ kernel/kprobes.c | 88 +++++++++++++++++++++++++++++++++++++++++++++-- kernel/sysctl.c | 12 ++++++ 3 files changed, 105 insertions(+), 3 deletions(-)
include/linux/kprobes.h +8 -0
@@ -283,6 +283,14 @@ extern int arch_within_optimized_kprobe(struct optimized_kprobe *op, unsigned long addr);extern void opt_pre_handler (struct kprobe *p,struct pt_regs *regs); + +#ifdef CONFIG_SYSCTL +extern int sysctl_kprobes_optimization; +extern int proc_kprobes_optimization_handler (struct ctl_table *table, +int write,void __user *buffer, +size_t *length,loff_t *ppos); +#endif +#endif /* CONFIG_OPTPROBES */ /* Get the kprobe at this addr (if any) - called with preemption disabled */
kernel/kprobes.c +85 -3
127 lines not on this page · raw message
kernel/sysctl.c +12 -0
@@ -50,6 +50,7 @@#include <linux/ftrace.h> #include <linux/slow-work.h> #include <linux/perf_event.h> +#include <linux/kprobes.h> #include <asm/uaccess.h> #include <asm/processor.h>
@@ -1463,6 +1464,17 @@ static struct ctl_table debug_table[] = { .proc_handler = proc_dointvec },#endif +#if defined(CONFIG_OPTPROBES ) + { + .procname = "kprobes-optimization", + .data = &sysctl_kprobes_optimization, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = proc_kprobes_optimization_handler, + .extra1 = &zero, + .extra2 = &one, + }, +#endif { } };
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes: Jump optimization sysctl interface
Commit-ID: b2be84df99ebc93599c69e931a3c4a5105abfabc Gitweb: http://git.kernel.org/tip/b2be84df99ebc93599c69e931a3c4a5105abfabc Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:15 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:25 +0100
kprobes: Jump optimization sysctl interface
Add /proc/sys/debug/kprobes-optimization sysctl which enables and disables kprobes jump optimization on the fly for debugging.
Changes in v7:
- Remove ctl_name = CTL_UNNUMBERED for upstream compatibility.
Changes in v6:
- Update comments and coding style.
LKML-Reference: <[email protected]>
--- include/linux/kprobes.h | 8 ++++ kernel/kprobes.c | 88 +++++++++++++++++++++++++++++++++++++++++++++-- kernel/sysctl.c | 12 ++++++ 3 files changed, 105 insertions(+), 3 deletions(-)
include/linux/kprobes.h +8 -0
@@ -283,6 +283,14 @@ extern int arch_within_optimized_kprobe(struct optimized_kprobe *op, unsigned long addr);extern void opt_pre_handler (struct kprobe *p,struct pt_regs *regs); + +#ifdef CONFIG_SYSCTL +extern int sysctl_kprobes_optimization; +extern int proc_kprobes_optimization_handler (struct ctl_table *table, +int write,void __user *buffer, +size_t *length,loff_t *ppos); +#endif +#endif /* CONFIG_OPTPROBES */ /* Get the kprobe at this addr (if any) - called with preemption disabled */
kernel/kprobes.c +85 -3
127 lines not on this page · raw message
kernel/sysctl.c +12 -0
@@ -50,6 +50,7 @@#include <linux/ftrace.h> #include <linux/slow-work.h> #include <linux/perf_event.h> +#include <linux/kprobes.h> #include <asm/uaccess.h> #include <asm/processor.h>
@@ -1450,6 +1451,17 @@ static struct ctl_table debug_table[] = { .proc_handler = proc_dointvec },#endif +#if defined(CONFIG_OPTPROBES ) + { + .procname = "kprobes-optimization", + .data = &sysctl_kprobes_optimization, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = proc_kprobes_optimization_handler, + .extra1 = &zero, + .extra2 = &one, + }, +#endif { } };
PATCH 5/18 kprobes/x86: Boost probes when reentering
In reply to Masami HiramatsuIntegrate prepare_singlestep() into setup_singlestep() to boost up reenter probes, if possible.
---
arch/x86/kernel/kprobes.c | 48 ++++++++++++++++++++++++--------------------- 1 files changed, 26 insertions(+), 22 deletions(-)
arch/x86/kernel/kprobes.c +26 -22
@@ -406,18 +406,6 @@ static void __kprobes restore_btf(void)update_debugctlmsr (current->thread.debugctlmsr); } -static void __kprobes prepare_singlestep (struct kprobe *p,struct pt_regs *regs) -{ -clear_btf (); - regs->flags |=X86_EFLAGS_TF ; - regs->flags &= ~X86_EFLAGS_IF ; -/* single step inline if the instruction is an int3 */ -if (p->opcode ==BREAKPOINT_INSTRUCTION ) - regs->ip = (unsigned long )p->addr; -else - regs->ip = (unsigned long )p->ainsn.insn; -} -void __kprobes arch_prepare_kretprobe (struct kretprobe_instance *ri,struct pt_regs *regs) {
@@ -430,19 +418,38 @@ void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri, }static void __kprobes setup_singlestep (struct kprobe *p,struct pt_regs *regs, -struct kprobe_ctlblk *kcb) +struct kprobe_ctlblk *kcb,int reenter) {#if !defined(CONFIG_PREEMPT )if (p->ainsn.boostable ==1 && !p->post_handler) {/* Boost up -- we can execute copied instructions directly */ -reset_current_kprobe (); +if (!reenter) +reset_current_kprobe (); +/* +* Reentering boosted probe doesn't reset current_kprobe, +* nor set current_kprobe, because it doesn't use single +* stepping. +*/ regs->ip = (unsigned long )p->ainsn.insn;preempt_enable_no_resched ();return ; }#endif -prepare_singlestep (p, regs); - kcb->kprobe_status =KPROBE_HIT_SS ; +if (reenter) { +save_previous_kprobe (kcb); +set_current_kprobe (p, regs, kcb); + kcb->kprobe_status =KPROBE_REENTER ; + }else + kcb->kprobe_status =KPROBE_HIT_SS ; +/* Prepare real single stepping */ +clear_btf (); + regs->flags |=X86_EFLAGS_TF ; + regs->flags &= ~X86_EFLAGS_IF ; +/* single step inline if the instruction is an int3 */ +if (p->opcode ==BREAKPOINT_INSTRUCTION ) + regs->ip = (unsigned long )p->addr; +else + regs->ip = (unsigned long )p->ainsn.insn; }/*
@@ -456,11 +463,8 @@ static int __kprobes reenter_kprobe(struct kprobe *p, struct pt_regs *regs,switch (kcb->kprobe_status) {case KPROBE_HIT_SSDONE :case KPROBE_HIT_ACTIVE : -save_previous_kprobe (kcb); -set_current_kprobe (p, regs, kcb);kprobes_inc_nmissed_count (p); -prepare_singlestep (p, regs); - kcb->kprobe_status =KPROBE_REENTER ; +setup_singlestep (p, regs, kcb,1 );break ;case KPROBE_HIT_SS :/* A probe has been hit in the codepath leading up to, or just
@@ -535,13 +539,13 @@ static int __kprobes kprobe_handler(struct pt_regs *regs)* more here. */ if (!p->pre_handler || !p->pre_handler (p, regs)) -setup_singlestep (p, regs, kcb); +setup_singlestep (p, regs, kcb,0 );return 1 ; } }else if (kprobe_running ()) { p =__get_cpu_var (current_kprobe);if (p->break_handler && p->break_handler (p, regs)) { -setup_singlestep (p, regs, kcb); +setup_singlestep (p, regs, kcb,0 );return 1 ; } }/* else: not a kprobe fault; let the kernel handle it */
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes/x86: Boost probes when reentering
Commit-ID: 0f94eb634ef7af736dee5639aac1c2fe9635d089 Gitweb: http://git.kernel.org/tip/0f94eb634ef7af736dee5639aac1c2fe9635d089 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:23 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:25 +0100
kprobes/x86: Boost probes when reentering
Integrate prepare_singlestep() into setup_singlestep() to boost up reenter probes, if possible.
LKML-Reference: <[email protected]>
--- arch/x86/kernel/kprobes.c | 48 ++++++++++++++++++++++++-------------------- 1 files changed, 26 insertions(+), 22 deletions(-)
arch/x86/kernel/kprobes.c +26 -22
@@ -406,18 +406,6 @@ static void __kprobes restore_btf(void)update_debugctlmsr (current->thread.debugctlmsr); } -static void __kprobes prepare_singlestep (struct kprobe *p,struct pt_regs *regs) -{ -clear_btf (); - regs->flags |=X86_EFLAGS_TF ; - regs->flags &= ~X86_EFLAGS_IF ; -/* single step inline if the instruction is an int3 */ -if (p->opcode ==BREAKPOINT_INSTRUCTION ) - regs->ip = (unsigned long )p->addr; -else - regs->ip = (unsigned long )p->ainsn.insn; -} -void __kprobes arch_prepare_kretprobe (struct kretprobe_instance *ri,struct pt_regs *regs) {
@@ -430,19 +418,38 @@ void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri, }static void __kprobes setup_singlestep (struct kprobe *p,struct pt_regs *regs, -struct kprobe_ctlblk *kcb) +struct kprobe_ctlblk *kcb,int reenter) {#if !defined(CONFIG_PREEMPT )if (p->ainsn.boostable ==1 && !p->post_handler) {/* Boost up -- we can execute copied instructions directly */ -reset_current_kprobe (); +if (!reenter) +reset_current_kprobe (); +/* +* Reentering boosted probe doesn't reset current_kprobe, +* nor set current_kprobe, because it doesn't use single +* stepping. +*/ regs->ip = (unsigned long )p->ainsn.insn;preempt_enable_no_resched ();return ; }#endif -prepare_singlestep (p, regs); - kcb->kprobe_status =KPROBE_HIT_SS ; +if (reenter) { +save_previous_kprobe (kcb); +set_current_kprobe (p, regs, kcb); + kcb->kprobe_status =KPROBE_REENTER ; + }else + kcb->kprobe_status =KPROBE_HIT_SS ; +/* Prepare real single stepping */ +clear_btf (); + regs->flags |=X86_EFLAGS_TF ; + regs->flags &= ~X86_EFLAGS_IF ; +/* single step inline if the instruction is an int3 */ +if (p->opcode ==BREAKPOINT_INSTRUCTION ) + regs->ip = (unsigned long )p->addr; +else + regs->ip = (unsigned long )p->ainsn.insn; }/*
@@ -456,11 +463,8 @@ static int __kprobes reenter_kprobe(struct kprobe *p, struct pt_regs *regs,switch (kcb->kprobe_status) {case KPROBE_HIT_SSDONE :case KPROBE_HIT_ACTIVE : -save_previous_kprobe (kcb); -set_current_kprobe (p, regs, kcb);kprobes_inc_nmissed_count (p); -prepare_singlestep (p, regs); - kcb->kprobe_status =KPROBE_REENTER ; +setup_singlestep (p, regs, kcb,1 );break ;case KPROBE_HIT_SS :/* A probe has been hit in the codepath leading up to, or just
@@ -535,13 +539,13 @@ static int __kprobes kprobe_handler(struct pt_regs *regs)* more here. */ if (!p->pre_handler || !p->pre_handler (p, regs)) -setup_singlestep (p, regs, kcb); +setup_singlestep (p, regs, kcb,0 );return 1 ; } }else if (kprobe_running ()) { p =__get_cpu_var (current_kprobe);if (p->break_handler && p->break_handler (p, regs)) { -setup_singlestep (p, regs, kcb); +setup_singlestep (p, regs, kcb,0 );return 1 ; } }/* else: not a kprobe fault; let the kernel handle it */
PATCH 6/18 kprobes/x86: Cleanup save/restore registers
In reply to Masami HiramatsuIntroduce SAVE/RESOTRE_REGS_STRING for cleanup kretprobe-trampoline asm code. These macros will be used for emulating interruption.
---
arch/x86/kernel/kprobes.c | 128 ++++++++++++++++++++++++--------------------- 1 files changed, 67 insertions(+), 61 deletions(-)
arch/x86/kernel/kprobes.c +67 -61
@@ -554,6 +554,69 @@ static int __kprobes kprobe_handler(struct pt_regs *regs)return 0 ; } +#ifdef CONFIG_X86_64 +#define SAVE_REGS_STRING \ +/* Skip cs, ip, orig_ax. */ \ + " subq $24, %rsp\n" \ + " pushq %rdi\n" \ + " pushq %rsi\n" \ + " pushq %rdx\n" \ + " pushq %rcx\n" \ + " pushq %rax\n" \ + " pushq %r8\n" \ + " pushq %r9\n" \ + " pushq %r10\n" \ + " pushq %r11\n" \ + " pushq %rbx\n" \ + " pushq %rbp\n" \ + " pushq %r12\n" \ + " pushq %r13\n" \ + " pushq %r14\n" \ + " pushq %r15\n" +#define RESTORE_REGS_STRING \ + " popq %r15\n" \ + " popq %r14\n" \ + " popq %r13\n" \ + " popq %r12\n" \ + " popq %rbp\n" \ + " popq %rbx\n" \ + " popq %r11\n" \ + " popq %r10\n" \ + " popq %r9\n" \ + " popq %r8\n" \ + " popq %rax\n" \ + " popq %rcx\n" \ + " popq %rdx\n" \ + " popq %rsi\n" \ + " popq %rdi\n" \ +/* Skip orig_ax, ip, cs */ \ + " addq $24, %rsp\n" +#else +#define SAVE_REGS_STRING \ +/* Skip cs, ip, orig_ax and gs. */ \ + " subl $16, %esp\n" \ + " pushl %fs\n" \ + " pushl %ds\n" \ + " pushl %es\n" \ + " pushl %eax\n" \ + " pushl %ebp\n" \ + " pushl %edi\n" \ + " pushl %esi\n" \ + " pushl %edx\n" \ + " pushl %ecx\n" \ + " pushl %ebx\n" +#define RESTORE_REGS_STRING \ + " popl %ebx\n" \ + " popl %ecx\n" \ + " popl %edx\n" \ + " popl %esi\n" \ + " popl %edi\n" \ + " popl %ebp\n" \ + " popl %eax\n" \ +/* Skip ds, es, fs, gs, orig_ax, and ip. Note: don't pop cs here*/ \ + " addl $24, %esp\n" +#endif +/* * When a retprobed function returns, this code saves registers and * calls trampoline_handler() runs, which calls the kretprobe's handler.
@@ -567,65 +630,16 @@ static void __used __kprobes kretprobe_trampoline_holder(void)/* We don't bother saving the ss register */ " pushq %rsp\n" " pushfq\n" -/* -* Skip cs, ip, orig_ax. -* trampoline_handler() will plug in these values -*/ -" subq $24, %rsp\n" -" pushq %rdi\n" -" pushq %rsi\n" -" pushq %rdx\n" -" pushq %rcx\n" -" pushq %rax\n" -" pushq %r8\n" -" pushq %r9\n" -" pushq %r10\n" -" pushq %r11\n" -" pushq %rbx\n" -" pushq %rbp\n" -" pushq %r12\n" -" pushq %r13\n" -" pushq %r14\n" -" pushq %r15\n" +SAVE_REGS_STRING " movq %rsp, %rdi\n" " call trampoline_handler\n" /* Replace saved sp with true return address. */ " movq %rax, 152(%rsp)\n" -" popq %r15\n" -" popq %r14\n" -" popq %r13\n" -" popq %r12\n" -" popq %rbp\n" -" popq %rbx\n" -" popq %r11\n" -" popq %r10\n" -" popq %r9\n" -" popq %r8\n" -" popq %rax\n" -" popq %rcx\n" -" popq %rdx\n" -" popq %rsi\n" -" popq %rdi\n" -/* Skip orig_ax, ip, cs */ -" addq $24, %rsp\n" +RESTORE_REGS_STRING " popfq\n"#else " pushf\n" -/* -* Skip cs, ip, orig_ax and gs. -* trampoline_handler() will plug in these values -*/ -" subl $16, %esp\n" -" pushl %fs\n" -" pushl %es\n" -" pushl %ds\n" -" pushl %eax\n" -" pushl %ebp\n" -" pushl %edi\n" -" pushl %esi\n" -" pushl %edx\n" -" pushl %ecx\n" -" pushl %ebx\n" +SAVE_REGS_STRING " movl %esp, %eax\n" " call trampoline_handler\n" /* Move flags to cs */
@@ -633,15 +647,7 @@ static void __used __kprobes kretprobe_trampoline_holder(void)" movl %edx, 52(%esp)\n" /* Replace saved flags with true return address. */ " movl %eax, 56(%esp)\n" -" popl %ebx\n" -" popl %ecx\n" -" popl %edx\n" -" popl %esi\n" -" popl %edi\n" -" popl %ebp\n" -" popl %eax\n" -/* Skip ds, es, fs, gs, orig_ax and ip */ -" addl $24, %esp\n" +RESTORE_REGS_STRING " popf\n"#endif " ret\n");
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes/x86: Cleanup save/restore registers
Commit-ID: f007ea2685692bafb386820144cf73a14016fc7c Gitweb: http://git.kernel.org/tip/f007ea2685692bafb386820144cf73a14016fc7c Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:30 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:26 +0100
kprobes/x86: Cleanup save/restore registers
Introduce SAVE/RESOTRE_REGS_STRING for cleanup kretprobe-trampoline asm code. These macros will be used for emulating interruption.
LKML-Reference: <[email protected]>
--- arch/x86/kernel/kprobes.c | 128 +++++++++++++++++++++++--------------------- 1 files changed, 67 insertions(+), 61 deletions(-)
arch/x86/kernel/kprobes.c +67 -61
@@ -554,6 +554,69 @@ static int __kprobes kprobe_handler(struct pt_regs *regs)return 0 ; } +#ifdef CONFIG_X86_64 +#define SAVE_REGS_STRING \ +/* Skip cs, ip, orig_ax. */ \ + " subq $24, %rsp\n" \ + " pushq %rdi\n" \ + " pushq %rsi\n" \ + " pushq %rdx\n" \ + " pushq %rcx\n" \ + " pushq %rax\n" \ + " pushq %r8\n" \ + " pushq %r9\n" \ + " pushq %r10\n" \ + " pushq %r11\n" \ + " pushq %rbx\n" \ + " pushq %rbp\n" \ + " pushq %r12\n" \ + " pushq %r13\n" \ + " pushq %r14\n" \ + " pushq %r15\n" +#define RESTORE_REGS_STRING \ + " popq %r15\n" \ + " popq %r14\n" \ + " popq %r13\n" \ + " popq %r12\n" \ + " popq %rbp\n" \ + " popq %rbx\n" \ + " popq %r11\n" \ + " popq %r10\n" \ + " popq %r9\n" \ + " popq %r8\n" \ + " popq %rax\n" \ + " popq %rcx\n" \ + " popq %rdx\n" \ + " popq %rsi\n" \ + " popq %rdi\n" \ +/* Skip orig_ax, ip, cs */ \ + " addq $24, %rsp\n" +#else +#define SAVE_REGS_STRING \ +/* Skip cs, ip, orig_ax and gs. */ \ + " subl $16, %esp\n" \ + " pushl %fs\n" \ + " pushl %ds\n" \ + " pushl %es\n" \ + " pushl %eax\n" \ + " pushl %ebp\n" \ + " pushl %edi\n" \ + " pushl %esi\n" \ + " pushl %edx\n" \ + " pushl %ecx\n" \ + " pushl %ebx\n" +#define RESTORE_REGS_STRING \ + " popl %ebx\n" \ + " popl %ecx\n" \ + " popl %edx\n" \ + " popl %esi\n" \ + " popl %edi\n" \ + " popl %ebp\n" \ + " popl %eax\n" \ +/* Skip ds, es, fs, gs, orig_ax, and ip. Note: don't pop cs here*/ \ + " addl $24, %esp\n" +#endif +/* * When a retprobed function returns, this code saves registers and * calls trampoline_handler() runs, which calls the kretprobe's handler.
@@ -567,65 +630,16 @@ static void __used __kprobes kretprobe_trampoline_holder(void)/* We don't bother saving the ss register */ " pushq %rsp\n" " pushfq\n" -/* -* Skip cs, ip, orig_ax. -* trampoline_handler() will plug in these values -*/ -" subq $24, %rsp\n" -" pushq %rdi\n" -" pushq %rsi\n" -" pushq %rdx\n" -" pushq %rcx\n" -" pushq %rax\n" -" pushq %r8\n" -" pushq %r9\n" -" pushq %r10\n" -" pushq %r11\n" -" pushq %rbx\n" -" pushq %rbp\n" -" pushq %r12\n" -" pushq %r13\n" -" pushq %r14\n" -" pushq %r15\n" +SAVE_REGS_STRING " movq %rsp, %rdi\n" " call trampoline_handler\n" /* Replace saved sp with true return address. */ " movq %rax, 152(%rsp)\n" -" popq %r15\n" -" popq %r14\n" -" popq %r13\n" -" popq %r12\n" -" popq %rbp\n" -" popq %rbx\n" -" popq %r11\n" -" popq %r10\n" -" popq %r9\n" -" popq %r8\n" -" popq %rax\n" -" popq %rcx\n" -" popq %rdx\n" -" popq %rsi\n" -" popq %rdi\n" -/* Skip orig_ax, ip, cs */ -" addq $24, %rsp\n" +RESTORE_REGS_STRING " popfq\n"#else " pushf\n" -/* -* Skip cs, ip, orig_ax and gs. -* trampoline_handler() will plug in these values -*/ -" subl $16, %esp\n" -" pushl %fs\n" -" pushl %es\n" -" pushl %ds\n" -" pushl %eax\n" -" pushl %ebp\n" -" pushl %edi\n" -" pushl %esi\n" -" pushl %edx\n" -" pushl %ecx\n" -" pushl %ebx\n" +SAVE_REGS_STRING " movl %esp, %eax\n" " call trampoline_handler\n" /* Move flags to cs */
@@ -633,15 +647,7 @@ static void __used __kprobes kretprobe_trampoline_holder(void)" movl %edx, 52(%esp)\n" /* Replace saved flags with true return address. */ " movl %eax, 56(%esp)\n" -" popl %ebx\n" -" popl %ecx\n" -" popl %edx\n" -" popl %esi\n" -" popl %edi\n" -" popl %ebp\n" -" popl %eax\n" -/* Skip ds, es, fs, gs, orig_ax and ip */ -" addl $24, %esp\n" +RESTORE_REGS_STRING " popf\n"#endif " ret\n");
PATCH 7/18 x86: Add text_poke_smp for SMP cross modifying code
In reply to Masami HiramatsuAdd generic text_poke_smp for SMP which uses stop_machine() to synchronize modifying code.
This stop_machine() method is officially described at "7.1.3 Handling Self- and Cross-Modifying Code" on the intel's software developer's manual 3A.
Since stop_machine() can't protect code against NMI/MCE, this function can not modify those handlers. And also, this function is basically for modifying multibyte-single-instruction. For modifying multibyte-multi-instructions, we need another special trap & detour code.
This code originaly comes from immediate values with stop_machine() version. Thanks Jason and Mathieu!
---
arch/x86/include/asm/alternative.h | 4 ++ arch/x86/kernel/alternative.c | 60 ++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletions(-)
arch/x86/include/asm/alternative.h +3 -1
@@ -165,10 +165,12 @@ static inline void apply_paravirt(struct paravirt_patch_site *start,* invalid instruction possible) or if the instructions are changed from a * consistent state to another consistent state atomically. * More care must be taken when modifying code in the SMP case because of -* Intel's errata. +* Intel's errata. text_poke_smp() takes care that errata, but still +* doesn't support NMI/MCE handler code modifying. * On the local CPU you need to be protected again NMI or MCE handlers seeing an * inconsistent instruction while you patch. */ extern void *text_poke (void *addr,const void *opcode,size_t len); +extern void *text_poke_smp (void *addr,const void *opcode,size_t len);#endif /* _ASM_X86_ALTERNATIVE_H */
arch/x86/kernel/alternative.c +60 -0
69 lines not on this page · raw message
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Re: [PATCH -tip v3&10 07/18] x86: Add text_poke_smp for SMP cross modifying code
Quoted 85 lines · * Masami Hiramatsu ([email protected]) wrote:
Add generic
text_poke_smpfor SMP which usesstop_machine()to synchronize modifying code.
Thisstop_machine()method is officially described at "7.1.3 Handling Self- and Cross-Modifying Code" on the intel's software developer's manual 3A.Since
stop_machine()can't protect code against NMI/MCE, this function can not modify those handlers. And also, this function is basically for modifying multibyte-single-instruction. For modifying multibyte-multi-instructions, we need another special trap & detour code.This code originaly comes from immediate values with
stop_machine()version. Thanks Jason and Mathieu!Signed-off-by Masami Hiramatsu <[email protected]>Cc Mathieu Desnoyers <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>Cc Ingo Molnar <[email protected]>Cc Jim Keniston <[email protected]>Cc Srikar Dronamraju <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Steven Rostedt <[email protected]>Cc Frederic Weisbecker <[email protected]>Cc H. Peter Anvin <[email protected]>Cc Anders Kaseorg <[email protected]>Cc Tim Abbott <[email protected]>Cc Andi Kleen <[email protected]>Cc Jason Baron <[email protected]>---
arch/x86/include/asm/alternative.h | 4 ++ arch/x86/kernel/alternative.c | 60 ++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletions(-)arch/x86/include/asm/alternative.h +3
-1@@ -165,10 +165,12 @@ static inline void apply_paravirt(struct paravirt_patch_site *start,* invalid instruction possible) or if the instructions are changed from a * consistent state to another consistent state atomically. * More care must be taken when modifying code in the SMP case because of -* Intel's errata. +* Intel's errata. text_poke_smp() takes care that errata, but still +* doesn't support NMI/MCE handler code modifying. * On the local CPU you need to be protected again NMI or MCE handlers seeing an * inconsistent instruction while you patch. */ extern void *text_poke (void *addr,const void *opcode,size_t len); +extern void *text_poke_smp (void *addr,const void *opcode,size_t len);#endif /* _ASM_X86_ALTERNATIVE_H */ arch/x86/kernel/alternative.c +17
-0@@ -7,6 +7,7 @@#include <linux/mm.h> #include <linux/vmalloc.h> #include <linux/memory.h> +#include <linux/stop_machine.h> #include <asm/alternative.h> #include <asm/sections.h> #include <asm/pgtable.h> @@ -572,3 +573,62 @@ void *__kprobes text_poke(void *addr, const void *opcode, size_t len)local_irq_restore (flags);return addr; } + +/* +* Cross-modifying kernel text with stop_machine(). +* This code originally comes from immediate value. +*/ +static atomic_t stop_machine_first; +static int wrote_text; + +struct text_poke_params { +void *addr; +const void *opcode; +size_t len; +}; + +static int __kprobes stop_machine_text_poke (void *data) +{
arch/x86/kernel/alternative.c void *__kprobes text_poke(void *addr, const void *opcode, size_t len) · line 601
Quoted 10 lines
arch/x86/kernel/alternative.c +10
-0+struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* Make sure other cpus see that this has run */ + wrote_text =1 ; + }else { +while (!wrote_text) +smp_rmb (); +sync_core ();
Hrm, there is a problem in there. The last loop, when wrote_text becomes true, does not perform any smp_mb(), so you end up in a situation where cpus in the "else" branch may never issue any memory barrier. I'd rather do:
+static volatile int wrote_text;
...
+static int __kprobes stop_machine_text_poke(void *data) +{
+ struct text_poke_params *tpp = data;
+
+ if (atomic_dec_and_test(&stop_machine_first)) {
+ text_poke(tpp->addr, tpp->opcode, tpp->len);
+ smp_wmb(); /* order text_poke stores before store to wrote_text */
+ wrote_text = 1;
+ } else {
+ while (!wrote_text)
+ cpu_relax();
+ smp_mb(); /* order wrote_text load before following execution */
+ }
If you don't like the "volatile int" definition of wrote_text, then we should probably use the ACCESS_ONCE() macro instead.
Thanks,
Mathieu
Quoted 44 lines
arch/x86/kernel/alternative.c +33
-0+ } + +flush_icache_range ((unsigned long )tpp->addr, + (unsigned long )tpp->addr + tpp->len); +return 0 ; +} + +/** +* text_poke_smp - Update instructions on a live kernel on SMP +* @addr: address to modify +* @opcode: source of the copy +* @len: length to copy +* +* Modify multi-byte instruction by using stop_machine() on SMP. This allows +* user to poke/set multi-byte text on SMP. Only non-NMI/MCE code modifying +* should be allowed, since stop_machine() does _not_ protect code against +* NMI and MCE. +* +* Note: Must be called under get_online_cpus() and text_mutex. +*/ +void *__kprobes text_poke_smp (void *addr,const void *opcode,size_t len) +{ +struct text_poke_params tpp; + + tpp.addr = addr; + tpp.opcode = opcode; + tpp.len = len; +atomic_set (&stop_machine_first,1 ); + wrote_text =0 ; +stop_machine (stop_machine_text_poke, (void *)&tpp,NULL ); +return addr; +} +Signature · 8 lines
-- Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency Consultant EfficiOS Inc. http://www.efficios.com
Re: [PATCH -tip v3&10 07/18] x86: Add text_poke_smp for SMP cross modifying code
Quoted 1 line · Mathieu Desnoyers
* Masami Hiramatsu ([email protected]) wrote:
[...]
Quoted 23 lines
Quoted 23 lines
arch/x86/kernel/alternative.c +23
-0+ +/* +* Cross-modifying kernel text with stop_machine(). +* This code originally comes from immediate value. +*/ +static atomic_t stop_machine_first; +static int wrote_text; + +struct text_poke_params { +void *addr; +const void *opcode; +size_t len; +}; + +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* Make sure other cpus see that this has run */ + wrote_text =1 ; + }else {
Quoted 8 lines
arch/x86/kernel/alternative.c void *__kprobes text_poke(void *addr, const void *opcode, size_t len) · line 601
Quoted 3 lines
arch/x86/kernel/alternative.c +3
-0+while (!wrote_text) +smp_rmb (); +sync_core ();Hrm, there is a problem in there. The last loop, when
wrote_textbecomes true, does not perform anysmp_mb(), so you end up in a situation where cpus in the "else" branch may never issue any memory barrier. I'd rather do:
Hmm, so how about this? :)
---
} else {
do {
smp_rmb();
while (!wrote_text);
sync_core();
}---
Quoted 19 lines
arch/x86/kernel/alternative.c +14
-0+static volatile int wrote_text; +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* order text_poke stores before store to wrote_text */ + wrote_text =1 ; + }else { +while (!wrote_text) +cpu_relax (); +smp_mb ();/* order wrote_text load before following execution */ + }
Quoted 2 lines
If you don't like the "volatile int" definition of
wrote_text, then we should probably use theACCESS_ONCE()macro instead.
hm, yeah, volatile will be required.
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Re: [PATCH -tip v3&10 07/18] x86: Add text_poke_smp for SMP cross modifying code
Quoted 37 lines · * Masami Hiramatsu ([email protected]) wrote:
Quoted 1 line · Mathieu Desnoyers
* Masami Hiramatsu ([email protected]) wrote:
[...]
Quoted 23 lines
Quoted 23 lines
arch/x86/kernel/alternative.c +23
-0+ +/* +* Cross-modifying kernel text with stop_machine(). +* This code originally comes from immediate value. +*/ +static atomic_t stop_machine_first; +static int wrote_text; + +struct text_poke_params { +void *addr; +const void *opcode; +size_t len; +}; + +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* Make sure other cpus see that this has run */ + wrote_text =1 ; + }else {Quoted 8 lines
arch/x86/kernel/alternative.c void *__kprobes text_poke(void *addr, const void *opcode, size_t len) · line 601
Quoted 3 lines
arch/x86/kernel/alternative.c +3
-0+while (!wrote_text) +smp_rmb (); +sync_core ();Hrm, there is a problem in there. The last loop, when
wrote_textbecomes true, does not perform anysmp_mb(), so you end up in a situation where cpus in the "else" branch may never issue any memory barrier. I'd rather do:Hmm, so how about this? :)
---
Quoted 8 lines
} else { do { smp_rmb(); while (!wrote_text); sync_core(); }---
The ordering we are looking for here are:
Write-side: smp_wmb() orders text_poke stores before store to wrote_text.
Read-side: order wrote_text load before subsequent execution of modified
instructions.
Here again, strictly speaking, wrote_text load is not ordered with respect to following instructions. So maybe it's fine on x86-TSO specifically, but I would not count on this kind of synchronization to work in the general case.
Given the very small expected performance impact of this code path, I would recomment using the more solid/generic alternative below. If there is really a gain to get by creating this weird wait loop with strange memory barrier semantics, fine, otherwise I'd be reluctant to accept your proposals as obviously correct.
If you really, really want to go down the route of proving the correctness of your memory barrier usage, I can recommend looking at the memory barrier formal verification framework I did as part of my thesis. But, really, in this case, the performance gain is just not there, so there is no point in spending time trying to prove this.
Thanks,
Mathieu
Quoted 33 lines
Quoted 19 lines
arch/x86/kernel/alternative.c +14
-0+static volatile int wrote_text; +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* order text_poke stores before store to wrote_text */ + wrote_text =1 ; + }else { +while (!wrote_text) +cpu_relax (); +smp_mb ();/* order wrote_text load before following execution */ + }Quoted 2 lines
If you don't like the "volatile int" definition of
wrote_text, then we should probably use theACCESS_ONCE()macro instead.hm, yeah, volatile will be required.
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Signature · 4 lines
Mathieu Desnoyers Operating System Efficiency Consultant EfficiOS Inc. http://www.efficios.com
Re: [PATCH -tip v3&10 07/18] x86: Add text_poke_smp for SMP cross modifying code
Quoted 64 lines · Mathieu Desnoyers
Quoted 37 lines · * Masami Hiramatsu ([email protected]) wrote:
Quoted 1 line · Mathieu Desnoyers
* Masami Hiramatsu ([email protected]) wrote:
[...]
Quoted 23 lines
Quoted 23 lines
arch/x86/kernel/alternative.c +23
-0+ +/* +* Cross-modifying kernel text with stop_machine(). +* This code originally comes from immediate value. +*/ +static atomic_t stop_machine_first; +static int wrote_text; + +struct text_poke_params { +void *addr; +const void *opcode; +size_t len; +}; + +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* Make sure other cpus see that this has run */ + wrote_text =1 ; + }else {Quoted 8 lines
arch/x86/kernel/alternative.c void *__kprobes text_poke(void *addr, const void *opcode, size_t len) · line 601
Quoted 3 lines
arch/x86/kernel/alternative.c +3
-0+while (!wrote_text) +smp_rmb (); +sync_core ();Hrm, there is a problem in there. The last loop, when
wrote_textbecomes true, does not perform anysmp_mb(), so you end up in a situation where cpus in the "else" branch may never issue any memory barrier. I'd rather do:Hmm, so how about this? :)
---Quoted 8 lines
} else { do { smp_rmb(); while (!wrote_text); sync_core(); }---
The ordering we are looking for here are:
Write-side:
smp_wmb()orderstext_pokestores before store towrote_text.Read-side: order
wrote_textload before subsequent execution of modified
instructions.Here again, strictly speaking,
wrote_textload is not ordered with respect to following instructions. So maybe it's fine on x86-TSO specifically, but I would not count on this kind of synchronization to work in the general case.Given the very small expected performance impact of this code path, I would recomment using the more solid/generic alternative below. If there is really a gain to get by creating this weird wait loop with strange memory barrier semantics, fine, otherwise I'd be reluctant to accept your proposals as obviously correct.
Quoted 5 lines
If you really, really want to go down the route of proving the correctness of your memory barrier usage, I can recommend looking at the memory barrier formal verification framework I did as part of my thesis. But, really, in this case, the performance gain is just not there, so there is no point in spending time trying to prove this.
OK, that was my misunderstand. and cpu_relax() will be better for HT processors. I'll update it according to your code below.
Thank you,
Quoted 39 lines
Thanks,
Mathieu
Quoted 33 lines
Quoted 19 lines
arch/x86/kernel/alternative.c +14
-0+static volatile int wrote_text; +static int __kprobes stop_machine_text_poke (void *data) +{ +struct text_poke_params *tpp = data; + +if (atomic_dec_and_test (&stop_machine_first)) { +text_poke (tpp->addr, tpp->opcode, tpp->len); +smp_wmb ();/* order text_poke stores before store to wrote_text */ + wrote_text =1 ; + }else { +while (!wrote_text) +cpu_relax (); +smp_mb ();/* order wrote_text load before following execution */ + }Quoted 2 lines
If you don't like the "volatile int" definition of
wrote_text, then we should probably use theACCESS_ONCE()macro instead.hm, yeah, volatile will be required.
Thank you,
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
Signature · 2 lines
Masami Hiramatsu e-mail: [email protected]
[tip:perf/probes] x86: Add text_poke_smp for SMP cross modifying code
In reply to Masami HiramatsuCommit-ID: 3d55cc8a058ee96291d6d45b1e35121b9920eca3 Gitweb: http://git.kernel.org/tip/3d55cc8a058ee96291d6d45b1e35121b9920eca3 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:38 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:26 +0100
x86: Add text_poke_smp for SMP cross modifying code
Add generic text_poke_smp for SMP which uses stop_machine() to synchronize modifying code.
This stop_machine() method is officially described at "7.1.3 Handling Self- and Cross-Modifying Code" on the intel's software developer's manual 3A.
Since stop_machine() can't protect code against NMI/MCE, this function can not modify those handlers. And also, this function is basically for modifying multibyte-single-instruction. For modifying multibyte-multi-instructions, we need another special trap & detour code.
This code originaly comes from immediate values with stop_machine() version. Thanks Jason and Mathieu!
LKML-Reference: <[email protected]>
--- arch/x86/include/asm/alternative.h | 4 ++- arch/x86/kernel/alternative.c | 60 ++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletions(-)
arch/x86/include/asm/alternative.h +3 -1
@@ -160,10 +160,12 @@ static inline void apply_paravirt(struct paravirt_patch_site *start,* invalid instruction possible) or if the instructions are changed from a * consistent state to another consistent state atomically. * More care must be taken when modifying code in the SMP case because of -* Intel's errata. +* Intel's errata. text_poke_smp() takes care that errata, but still +* doesn't support NMI/MCE handler code modifying. * On the local CPU you need to be protected again NMI or MCE handlers seeing an * inconsistent instruction while you patch. */ extern void *text_poke (void *addr,const void *opcode,size_t len); +extern void *text_poke_smp (void *addr,const void *opcode,size_t len);#endif /* _ASM_X86_ALTERNATIVE_H */
arch/x86/kernel/alternative.c +60 -0
69 lines not on this page · raw message
PATCH 8/18 kprobes/x86: Support kprobes jump optimization on x86
In reply to Masami HiramatsuIntroduce x86 arch-specific optimization code, which supports both of x86-32 and x86-64.
This code also supports safety checking, which decodes whole of a function in which probe is inserted, and checks following conditions before optimization:
- The optimized instructions which will be replaced by a jump instruction don't straddle the function boundary.
- There is no indirect jump instruction, because it will jumps into the address range which is replaced by jump operand.
- There is no jump/loop instruction which jumps into the address range which is replaced by jump operand.
- Don't optimize kprobes if it is in functions into which fixup code will jumps.
This uses text_poke_multibyte() which doesn't support modifying code on NMI/MCE handler. However, since kprobes itself doesn't support NMI/MCE code probing, it's not a problem.
Changes in v9:
- Use *_text_reserved() for checking the probe can be optimized.
- Verify jump address range is in 2G range when preparing slot.
- Backup original code when switching optimized buffer, instead of preparing buffer, because there can be int3 of other probes in preparing phase.
- Check kprobe is disabled in arch_check_optimized_kprobe().
- Strictly check indirect jump opcodes (ff /4, ff /5).
Changes in v6:
- Split stop_machine-based jump patching code.
- Update comments and coding style.
Changes in v5:
- Introduce stop_machine-based jump replacing.
---
arch/x86/Kconfig | 1 arch/x86/include/asm/kprobes.h | 29 +++ arch/x86/kernel/kprobes.c | 433 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 441 insertions(+), 22 deletions(-)
arch/x86/Kconfig +1 -0
@@ -31,6 +31,7 @@ config X86 select ARCH_WANT_FRAME_POINTERS select HAVE_DMA_ATTRS select HAVE_KRETPROBES + select HAVE_OPTPROBES select HAVE_FTRACE_MCOUNT_RECORD select HAVE_DYNAMIC_FTRACE select HAVE_FUNCTION_TRACER
arch/x86/include/asm/kprobes.h +29 -0
@@ -33,6 +33,9 @@ struct kprobe;typedef u8 kprobe_opcode_t ;#define BREAKPOINT_INSTRUCTION 0xcc#define RELATIVEJUMP_OPCODE 0xe9 +#define RELATIVEJUMP_SIZE 5 +#define RELATIVECALL_OPCODE 0xe8 +#define RELATIVE_ADDR_SIZE 4#define MAX_INSN_SIZE 16#define MAX_STACK_SIZE 64#define MIN_STACK_SIZE (ADDR ) \
@@ -44,6 +47,17 @@ typedef u8 kprobe_opcode_t;#define flush_insn_slot (p) do { } while (0) +/* optinsn template addresses */ +extern kprobe_opcode_t optprobe_template_entry; +extern kprobe_opcode_t optprobe_template_val; +extern kprobe_opcode_t optprobe_template_call; +extern kprobe_opcode_t optprobe_template_end; +#define MAX_OPTIMIZED_LENGTH (MAX_INSN_SIZE + RELATIVE_ADDR_SIZE) +#define MAX_OPTINSN_SIZE \ + (((unsigned long)&optprobe_template_end - \ + (unsigned long)&optprobe_template_entry) + \ + MAX_OPTIMIZED_LENGTH + RELATIVEJUMP_SIZE) +extern const int kretprobe_blacklist_size;void arch_remove_kprobe (struct kprobe *p);
@@ -64,6 +78,21 @@ struct arch_specific_insn {int boostable; }; +struct arch_optimized_insn { +/* copy of the original instructions */ +kprobe_opcode_t copied_insn[RELATIVE_ADDR_SIZE ]; +/* detour code buffer */ +kprobe_opcode_t *insn; +/* the size of instructions copied to detour code buffer */ +size_t size; +}; + +/* Return true (!0) if optinsn is prepared for optimization. */ +static inline int arch_prepared_optinsn (struct arch_optimized_insn *optinsn) +{ +return optinsn->size; +} +struct prev_kprobe {struct kprobe *kp;unsigned long status;
arch/x86/kernel/kprobes.c +411 -22
504 lines not on this page · raw message
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes/x86: Support kprobes jump optimization on x86
Commit-ID: c0f7ac3a9edde786bc129d37627953a8b8abefdf Gitweb: http://git.kernel.org/tip/c0f7ac3a9edde786bc129d37627953a8b8abefdf Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:34:46 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:26 +0100
kprobes/x86: Support kprobes jump optimization on x86
Introduce x86 arch-specific optimization code, which supports both of x86-32 and x86-64.
This code also supports safety checking, which decodes whole of a function in which probe is inserted, and checks following conditions before optimization:
- The optimized instructions which will be replaced by a jump instruction don't straddle the function boundary.
- There is no indirect jump instruction, because it will jumps into the address range which is replaced by jump operand.
- There is no jump/loop instruction which jumps into the address range which is replaced by jump operand.
- Don't optimize kprobes if it is in functions into which fixup code will jumps.
This uses text_poke_multibyte() which doesn't support modifying code on NMI/MCE handler. However, since kprobes itself doesn't support NMI/MCE code probing, it's not a problem.
Changes in v9:
- Use *_text_reserved() for checking the probe can be optimized.
- Verify jump address range is in 2G range when preparing slot.
- Backup original code when switching optimized buffer, instead of preparing buffer, because there can be int3 of other probes in preparing phase.
- Check kprobe is disabled in arch_check_optimized_kprobe().
- Strictly check indirect jump opcodes (ff /4, ff /5).
Changes in v6:
- Split stop_machine-based jump patching code.
- Update comments and coding style.
Changes in v5:
- Introduce stop_machine-based jump replacing.
LKML-Reference: <[email protected]>
--- arch/x86/Kconfig | 1 + arch/x86/include/asm/kprobes.h | 29 +++ arch/x86/kernel/kprobes.c | 433 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 441 insertions(+), 22 deletions(-)
arch/x86/Kconfig +1 -0
@@ -31,6 +31,7 @@ config X86 select ARCH_WANT_FRAME_POINTERS select HAVE_DMA_ATTRS select HAVE_KRETPROBES + select HAVE_OPTPROBES select HAVE_FTRACE_MCOUNT_RECORD select HAVE_DYNAMIC_FTRACE select HAVE_FUNCTION_TRACER
arch/x86/include/asm/kprobes.h +29 -0
@@ -33,6 +33,9 @@ struct kprobe;typedef u8 kprobe_opcode_t ;#define BREAKPOINT_INSTRUCTION 0xcc#define RELATIVEJUMP_OPCODE 0xe9 +#define RELATIVEJUMP_SIZE 5 +#define RELATIVECALL_OPCODE 0xe8 +#define RELATIVE_ADDR_SIZE 4#define MAX_INSN_SIZE 16#define MAX_STACK_SIZE 64#define MIN_STACK_SIZE (ADDR ) \
@@ -44,6 +47,17 @@ typedef u8 kprobe_opcode_t;#define flush_insn_slot (p) do { } while (0) +/* optinsn template addresses */ +extern kprobe_opcode_t optprobe_template_entry; +extern kprobe_opcode_t optprobe_template_val; +extern kprobe_opcode_t optprobe_template_call; +extern kprobe_opcode_t optprobe_template_end; +#define MAX_OPTIMIZED_LENGTH (MAX_INSN_SIZE + RELATIVE_ADDR_SIZE) +#define MAX_OPTINSN_SIZE \ + (((unsigned long)&optprobe_template_end - \ + (unsigned long)&optprobe_template_entry) + \ + MAX_OPTIMIZED_LENGTH + RELATIVEJUMP_SIZE) +extern const int kretprobe_blacklist_size;void arch_remove_kprobe (struct kprobe *p);
@@ -64,6 +78,21 @@ struct arch_specific_insn {int boostable; }; +struct arch_optimized_insn { +/* copy of the original instructions */ +kprobe_opcode_t copied_insn[RELATIVE_ADDR_SIZE ]; +/* detour code buffer */ +kprobe_opcode_t *insn; +/* the size of instructions copied to detour code buffer */ +size_t size; +}; + +/* Return true (!0) if optinsn is prepared for optimization. */ +static inline int arch_prepared_optinsn (struct arch_optimized_insn *optinsn) +{ +return optinsn->size; +} +struct prev_kprobe {struct kprobe *kp;unsigned long status;
arch/x86/kernel/kprobes.c +411 -22
504 lines not on this page · raw message
PATCH 9/18 kprobes: Add documents of jump optimization
In reply to Masami HiramatsuAdd documentations about kprobe jump optimization to Documentation/kprobes.txt.
Changes in v10:
- Editorial fixups by Jim Keniston.
Changes in v8:
- Update documentation and benchmark results.
---
Documentation/kprobes.txt | 207 ++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 195 insertions(+), 12 deletions(-)
Documentation/kprobes.txt +195 -12
@@ -1,6 +1,7 @@ Title : Kernel Probes (Kprobes) Authors : Jim Keniston <[email protected]> - : Prasanna S Panchamukhi <[email protected]> + : Prasanna S Panchamukhi <[email protected]> + : Masami Hiramatsu <[email protected]> CONTENTS
@@ -15,6 +16,7 @@ CONTENTS 9. Jprobes Example 10. Kretprobes Example Appendix A: The kprobes debugfs interface +Appendix B: The kprobes sysctl interface 1. Concepts: Kprobes, Jprobes, Return Probes
@@ -42,13 +44,13 @@ registration/unregistration of a group of *probes. These functions can speed up unregistration process when you have to unregister a lot of probes at once. -The next three subsections explain how the different types of -probes work. They explain certain things that you'll need to -know in order to make the best use of Kprobes -- e.g., the -difference between a pre_handler and a post_handler, and how -to use the maxactive and nmissed fields of a kretprobe. But -if you're in a hurry to start using Kprobes, you can skip ahead -to section 2. +The next four subsections explain how the different types of +probes work and how jump optimization works. They explain certain +things that you'll need to know in order to make the best use of +Kprobes -- e.g., the difference between a pre_handler and +a post_handler, and how to use the maxactive and nmissed fields of +a kretprobe. But if you're in a hurry to start using Kprobes, you +can skip ahead to section 2. 1.1 How Does a Kprobe Work?
@@ -161,13 +163,125 @@ In case probed function is entered but there is no kretprobe_instance object available, then in addition to incrementing the nmissed count, the user entry_handler invocation is also skipped. +1.4 How Does Jump Optimization Work? + +If you configured your kernel with CONFIG_OPTPROBES=y (currently +this option is supported on x86/x86-64, non-preemptive kernel) and +the "debug.kprobes_optimization" kernel parameter is set to 1 (see +sysctl(8)), Kprobes tries to reduce probe-hit overhead by using a jump +instruction instead of a breakpoint instruction at each probepoint. + +1.4.1 Init a Kprobe + +When a probe is registered, before attempting this optimization, +Kprobes inserts an ordinary, breakpoint-based kprobe at the specified +address. So, even if it's not possible to optimize this particular +probepoint, there'll be a probe there. + +1.4.2 Safety Check + +Before optimizing a probe, Kprobes performs the following safety checks: + +- Kprobes verifies that the region that will be replaced by the jump +instruction (the "optimized region") lies entirely within one function. +(A jump instruction is multiple bytes, and so may overlay multiple +instructions.) + +- Kprobes analyzes the entire function and verifies that there is no +jump into the optimized region. Specifically: + - the function contains no indirect jump; + - the function contains no instruction that causes an exception (since + the fixup code triggered by the exception could jump back into the + optimized region -- Kprobes checks the exception tables to verify this); + and + - there is no near jump to the optimized region (other than to the first + byte). + +- For each instruction in the optimized region, Kprobes verifies that +the instruction can be executed out of line. + +1.4.3 Preparing Detour Buffer + +Next, Kprobes prepares a "detour" buffer, which contains the following +instruction sequence: +- code to push the CPU's registers (emulating a breakpoint trap) +- a call to the trampoline code which calls user's probe handlers. +- code to restore registers +- the instructions from the optimized region +- a jump back to the original execution path. + +1.4.4 Pre-optimization + +After preparing the detour buffer, Kprobes verifies that none of the +following situations exist: +- The probe has either a break_handler (i.e., it's a jprobe) or a +post_handler. +- Other instructions in the optimized region are probed. +- The probe is disabled. +In any of the above cases, Kprobes won't start optimizing the probe. +Since these are temporary situations, Kprobes tries to start +optimizing it again if the situation is changed. + +If the kprobe can be optimized, Kprobes enqueues the kprobe to an +optimizing list, and kicks the kprobe-optimizer workqueue to optimize +it. If the to-be-optimized probepoint is hit before being optimized, +Kprobes returns control to the original instruction path by setting +the CPU's instruction pointer to the copied code in the detour buffer +-- thus at least avoiding the single-step. + +1.4.5 Optimization + +The Kprobe-optimizer doesn't insert the jump instruction immediately; +rather, it calls synchronize_sched() for safety first, because it's +possible for a CPU to be interrupted in the middle of executing the +optimized region(*). As you know, synchronize_sched() can ensure +that all interruptions that were active when synchronize_sched() +was called are done, but only if CONFIG_PREEMPT=n. So, this version +of kprobe optimization supports only kernels with CONFIG_PREEMPT=n.(**) + +After that, the Kprobe-optimizer calls stop_machine() to replace +the optimized region with a jump instruction to the detour buffer, +using text_poke_smp(). + +1.4.6 Unoptimization + +When an optimized kprobe is unregistered, disabled, or blocked by +another kprobe, it will be unoptimized. If this happens before +the optimization is complete, the kprobe is just dequeued from the +optimized list. If the optimization has been done, the jump is +replaced with the original code (except for an int3 breakpoint in +the first byte) by using text_poke_smp(). + +(*)Please imagine that the 2nd instruction is interrupted and then +the optimizer replaces the 2nd instruction with the jump *address* +while the interrupt handler is running. When the interrupt +returns to original address, there is no valid instruction, +and it causes an unexpected result. + +(**)This optimization-safety checking may be replaced with the +stop-machine method that ksplice uses for supporting a CONFIG_PREEMPT=y +kernel. + +NOTE for geeks: +The jump optimization changes the kprobe's pre_handler behavior. +Without optimization, the pre_handler can change the kernel's execution +path by changing regs->ip and returning 1. However, when the probe +is optimized, that modification is ignored. Thus, if you want to +tweak the kernel's execution path, you need to suppress optimization, +using one of the following techniques: +- Specify an empty function for the kprobe's post_handler or break_handler. + or +- Config CONFIG_OPTPROBES=n. + or +- Execute 'sysctl -w debug.kprobes_optimization=n' + 2. Architectures Supported Kprobes, jprobes, and return probes are implemented on the following architectures: -- i386 -- x86_64 (AMD-64, EM64T) +- i386 (Supports jump optimization) +- x86_64 (AMD-64, EM64T) (Supports jump optimization) - ppc64 - ia64 (Does not support probes on instruction slot1.) - sparc64 (Return probes not yet implemented.)
@@ -193,6 +307,10 @@ it useful to "Compile the kernel with debug info" (CONFIG_DEBUG_INFO), so you can use "objdump -d -l vmlinux" to see the source-to-object code mapping. +If you want to reduce probing overhead, set "Kprobes jump optimization +support" (CONFIG_OPTPROBES) to "y". You can find this option under the +"Kprobes" line. + 4. API Reference The Kprobes API includes a "register" function and an "unregister"
@@ -389,7 +507,10 @@ the probe which has been registered. Kprobes allows multiple probes at the same address. Currently, however, there cannot be multiple jprobes on the same function at -the same time. +the same time. Also, a probepoint for which there is a jprobe or +a post_handler cannot be optimized. So if you install a jprobe, +or a kprobe with a post_handler, at an optimized probepoint, the +probepoint will be unoptimized automatically. In general, you can install a probe anywhere in the kernel. In particular, you can probe interrupt handlers. Known exceptions
@@ -453,6 +574,38 @@ reason, Kprobes doesn't support return probes (or kprobes or jprobes) on the x86_64 version of __switch_to(); the registration functions return -EINVAL. +On x86/x86-64, since the Jump Optimization of Kprobes modifies +instructions widely, there are some limitations to optimization. To +explain it, we introduce some terminology. Imagine a 3-instruction +sequence consisting of a two 2-byte instructions and one 3-byte +instruction. + + IA + | +[-2][-1][0][1][2][3][4][5][6][7] + [ins1][ins2][ ins3 ] + [<- DCR ->] + [<- JTPR ->] + +ins1: 1st Instruction +ins2: 2nd Instruction +ins3: 3rd Instruction +IA: Insertion Address +JTPR: Jump Target Prohibition Region +DCR: Detoured Code Region + +The instructions in DCR are copied to the out-of-line buffer +of the kprobe, because the bytes in DCR are replaced by +a 5-byte jump instruction. So there are several limitations. + +a) The instructions in DCR must be relocatable. +b) The instructions in DCR must not include a call instruction. +c) JTPR must not be targeted by any jump or call instruction. +d) DCR must not straddle the border betweeen functions. + +Anyway, these limitations are checked by the in-kernel instruction +decoder, so you don't need to worry about that. + 6. Probe Overhead On a typical CPU in use in 2005, a kprobe hit takes 0.5 to 1.0
@@ -476,6 +629,19 @@ k = 0.49 usec; j = 0.76; r = 0.80; kr = 0.82; jr = 1.07 ppc64: POWER5 (gr), 1656 MHz (SMT disabled, 1 virtual CPU per physical CPU) k = 0.77 usec; j = 1.31; r = 1.26; kr = 1.45; jr = 1.99 +6.1 Optimized Probe Overhead + +Typically, an optimized kprobe hit takes 0.07 to 0.1 microseconds to +process. Here are sample overhead figures (in usec) for x86 architectures. +k = unoptimized kprobe, b = boosted (single-step skipped), o = optimized kprobe, +r = unoptimized kretprobe, rb = boosted kretprobe, ro = optimized kretprobe. + +i386: Intel(R) Xeon(R) E5410, 2.33GHz, 4656.90 bogomips +k = 0.80 usec; b = 0.33; o = 0.05; r = 1.10; rb = 0.61; ro = 0.33 + +x86-64: Intel(R) Xeon(R) E5410, 2.33GHz, 4656.90 bogomips +k = 0.99 usec; b = 0.43; o = 0.06; r = 1.24; rb = 0.68; ro = 0.30 + 7. TODO a. SystemTap (http://sourceware.org/systemtap): Provides a simplified
@@ -523,7 +689,8 @@ is also specified. Following columns show probe status. If the probe is on a virtual address that is no longer valid (module init sections, module virtual addresses that correspond to modules that've been unloaded), such probes are marked with [GONE]. If the probe is temporarily disabled, -such probes are marked with [DISABLED]. +such probes are marked with [DISABLED]. If the probe is optimized, it is +marked with [OPTIMIZED]. /sys/kernel/debug/kprobes/enabled: Turn kprobes ON/OFF forcibly.
@@ -533,3 +700,19 @@ registered probes will be disarmed, till such time a "1" is echoed to this file. Note that this knob just disarms and arms all kprobes and doesn't change each probe's disabling state. This means that disabled kprobes (marked [DISABLED]) will be not enabled if you turn ON all kprobes by this knob. + + +Appendix B: The kprobes sysctl interface + +/proc/sys/debug/kprobes-optimization: Turn kprobes optimization ON/OFF. + +When CONFIG_OPTPROBES=y, this sysctl interface appears and it provides +a knob to globally and forcibly turn jump optimization (see section +1.4) ON or OFF. By default, jump optimization is allowed (ON). +If you echo "0" to this file or set "debug.kprobes_optimization" to +0 via sysctl, all optimized probes will be unoptimized, and any new +probes registered after that will not be optimized. Note that this +knob *changes* the optimized state. This means that optimized probes +(marked [OPTIMIZED]) will be unoptimized ([OPTIMIZED] tag will be +removed). If the knob is turned on, they will be optimized again. +
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] kprobes: Add documents of jump optimization
Commit-ID: b26486bf75148ab7b776c6a532a9bad33f987a38 Gitweb: http://git.kernel.org/tip/b26486bf75148ab7b776c6a532a9bad33f987a38 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:04 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:27 +0100
kprobes: Add documents of jump optimization
Add documentations about kprobe jump optimization to Documentation/kprobes.txt.
Changes in v10:
- Editorial fixups by Jim Keniston.
Changes in v8:
- Update documentation and benchmark results.
LKML-Reference: <[email protected]>
--- Documentation/kprobes.txt | 207 ++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 195 insertions(+), 12 deletions(-)
Documentation/kprobes.txt +195 -12
@@ -1,6 +1,7 @@ Title : Kernel Probes (Kprobes) Authors : Jim Keniston <[email protected]> - : Prasanna S Panchamukhi <[email protected]> + : Prasanna S Panchamukhi <[email protected]> + : Masami Hiramatsu <[email protected]> CONTENTS
@@ -15,6 +16,7 @@ CONTENTS 9. Jprobes Example 10. Kretprobes Example Appendix A: The kprobes debugfs interface +Appendix B: The kprobes sysctl interface 1. Concepts: Kprobes, Jprobes, Return Probes
@@ -42,13 +44,13 @@ registration/unregistration of a group of *probes. These functions can speed up unregistration process when you have to unregister a lot of probes at once. -The next three subsections explain how the different types of -probes work. They explain certain things that you'll need to -know in order to make the best use of Kprobes -- e.g., the -difference between a pre_handler and a post_handler, and how -to use the maxactive and nmissed fields of a kretprobe. But -if you're in a hurry to start using Kprobes, you can skip ahead -to section 2. +The next four subsections explain how the different types of +probes work and how jump optimization works. They explain certain +things that you'll need to know in order to make the best use of +Kprobes -- e.g., the difference between a pre_handler and +a post_handler, and how to use the maxactive and nmissed fields of +a kretprobe. But if you're in a hurry to start using Kprobes, you +can skip ahead to section 2. 1.1 How Does a Kprobe Work?
@@ -161,13 +163,125 @@ In case probed function is entered but there is no kretprobe_instance object available, then in addition to incrementing the nmissed count, the user entry_handler invocation is also skipped. +1.4 How Does Jump Optimization Work? + +If you configured your kernel with CONFIG_OPTPROBES=y (currently +this option is supported on x86/x86-64, non-preemptive kernel) and +the "debug.kprobes_optimization" kernel parameter is set to 1 (see +sysctl(8)), Kprobes tries to reduce probe-hit overhead by using a jump +instruction instead of a breakpoint instruction at each probepoint. + +1.4.1 Init a Kprobe + +When a probe is registered, before attempting this optimization, +Kprobes inserts an ordinary, breakpoint-based kprobe at the specified +address. So, even if it's not possible to optimize this particular +probepoint, there'll be a probe there. + +1.4.2 Safety Check + +Before optimizing a probe, Kprobes performs the following safety checks: + +- Kprobes verifies that the region that will be replaced by the jump +instruction (the "optimized region") lies entirely within one function. +(A jump instruction is multiple bytes, and so may overlay multiple +instructions.) + +- Kprobes analyzes the entire function and verifies that there is no +jump into the optimized region. Specifically: + - the function contains no indirect jump; + - the function contains no instruction that causes an exception (since + the fixup code triggered by the exception could jump back into the + optimized region -- Kprobes checks the exception tables to verify this); + and + - there is no near jump to the optimized region (other than to the first + byte). + +- For each instruction in the optimized region, Kprobes verifies that +the instruction can be executed out of line. + +1.4.3 Preparing Detour Buffer + +Next, Kprobes prepares a "detour" buffer, which contains the following +instruction sequence: +- code to push the CPU's registers (emulating a breakpoint trap) +- a call to the trampoline code which calls user's probe handlers. +- code to restore registers +- the instructions from the optimized region +- a jump back to the original execution path. + +1.4.4 Pre-optimization + +After preparing the detour buffer, Kprobes verifies that none of the +following situations exist: +- The probe has either a break_handler (i.e., it's a jprobe) or a +post_handler. +- Other instructions in the optimized region are probed. +- The probe is disabled. +In any of the above cases, Kprobes won't start optimizing the probe. +Since these are temporary situations, Kprobes tries to start +optimizing it again if the situation is changed. + +If the kprobe can be optimized, Kprobes enqueues the kprobe to an +optimizing list, and kicks the kprobe-optimizer workqueue to optimize +it. If the to-be-optimized probepoint is hit before being optimized, +Kprobes returns control to the original instruction path by setting +the CPU's instruction pointer to the copied code in the detour buffer +-- thus at least avoiding the single-step. + +1.4.5 Optimization + +The Kprobe-optimizer doesn't insert the jump instruction immediately; +rather, it calls synchronize_sched() for safety first, because it's +possible for a CPU to be interrupted in the middle of executing the +optimized region(*). As you know, synchronize_sched() can ensure +that all interruptions that were active when synchronize_sched() +was called are done, but only if CONFIG_PREEMPT=n. So, this version +of kprobe optimization supports only kernels with CONFIG_PREEMPT=n.(**) + +After that, the Kprobe-optimizer calls stop_machine() to replace +the optimized region with a jump instruction to the detour buffer, +using text_poke_smp(). + +1.4.6 Unoptimization + +When an optimized kprobe is unregistered, disabled, or blocked by +another kprobe, it will be unoptimized. If this happens before +the optimization is complete, the kprobe is just dequeued from the +optimized list. If the optimization has been done, the jump is +replaced with the original code (except for an int3 breakpoint in +the first byte) by using text_poke_smp(). + +(*)Please imagine that the 2nd instruction is interrupted and then +the optimizer replaces the 2nd instruction with the jump *address* +while the interrupt handler is running. When the interrupt +returns to original address, there is no valid instruction, +and it causes an unexpected result. + +(**)This optimization-safety checking may be replaced with the +stop-machine method that ksplice uses for supporting a CONFIG_PREEMPT=y +kernel. + +NOTE for geeks: +The jump optimization changes the kprobe's pre_handler behavior. +Without optimization, the pre_handler can change the kernel's execution +path by changing regs->ip and returning 1. However, when the probe +is optimized, that modification is ignored. Thus, if you want to +tweak the kernel's execution path, you need to suppress optimization, +using one of the following techniques: +- Specify an empty function for the kprobe's post_handler or break_handler. + or +- Config CONFIG_OPTPROBES=n. + or +- Execute 'sysctl -w debug.kprobes_optimization=n' + 2. Architectures Supported Kprobes, jprobes, and return probes are implemented on the following architectures: -- i386 -- x86_64 (AMD-64, EM64T) +- i386 (Supports jump optimization) +- x86_64 (AMD-64, EM64T) (Supports jump optimization) - ppc64 - ia64 (Does not support probes on instruction slot1.) - sparc64 (Return probes not yet implemented.)
@@ -193,6 +307,10 @@ it useful to "Compile the kernel with debug info" (CONFIG_DEBUG_INFO), so you can use "objdump -d -l vmlinux" to see the source-to-object code mapping. +If you want to reduce probing overhead, set "Kprobes jump optimization +support" (CONFIG_OPTPROBES) to "y". You can find this option under the +"Kprobes" line. + 4. API Reference The Kprobes API includes a "register" function and an "unregister"
@@ -389,7 +507,10 @@ the probe which has been registered. Kprobes allows multiple probes at the same address. Currently, however, there cannot be multiple jprobes on the same function at -the same time. +the same time. Also, a probepoint for which there is a jprobe or +a post_handler cannot be optimized. So if you install a jprobe, +or a kprobe with a post_handler, at an optimized probepoint, the +probepoint will be unoptimized automatically. In general, you can install a probe anywhere in the kernel. In particular, you can probe interrupt handlers. Known exceptions
@@ -453,6 +574,38 @@ reason, Kprobes doesn't support return probes (or kprobes or jprobes) on the x86_64 version of __switch_to(); the registration functions return -EINVAL. +On x86/x86-64, since the Jump Optimization of Kprobes modifies +instructions widely, there are some limitations to optimization. To +explain it, we introduce some terminology. Imagine a 3-instruction +sequence consisting of a two 2-byte instructions and one 3-byte +instruction. + + IA + | +[-2][-1][0][1][2][3][4][5][6][7] + [ins1][ins2][ ins3 ] + [<- DCR ->] + [<- JTPR ->] + +ins1: 1st Instruction +ins2: 2nd Instruction +ins3: 3rd Instruction +IA: Insertion Address +JTPR: Jump Target Prohibition Region +DCR: Detoured Code Region + +The instructions in DCR are copied to the out-of-line buffer +of the kprobe, because the bytes in DCR are replaced by +a 5-byte jump instruction. So there are several limitations. + +a) The instructions in DCR must be relocatable. +b) The instructions in DCR must not include a call instruction. +c) JTPR must not be targeted by any jump or call instruction. +d) DCR must not straddle the border betweeen functions. + +Anyway, these limitations are checked by the in-kernel instruction +decoder, so you don't need to worry about that. + 6. Probe Overhead On a typical CPU in use in 2005, a kprobe hit takes 0.5 to 1.0
@@ -476,6 +629,19 @@ k = 0.49 usec; j = 0.76; r = 0.80; kr = 0.82; jr = 1.07 ppc64: POWER5 (gr), 1656 MHz (SMT disabled, 1 virtual CPU per physical CPU) k = 0.77 usec; j = 1.31; r = 1.26; kr = 1.45; jr = 1.99 +6.1 Optimized Probe Overhead + +Typically, an optimized kprobe hit takes 0.07 to 0.1 microseconds to +process. Here are sample overhead figures (in usec) for x86 architectures. +k = unoptimized kprobe, b = boosted (single-step skipped), o = optimized kprobe, +r = unoptimized kretprobe, rb = boosted kretprobe, ro = optimized kretprobe. + +i386: Intel(R) Xeon(R) E5410, 2.33GHz, 4656.90 bogomips +k = 0.80 usec; b = 0.33; o = 0.05; r = 1.10; rb = 0.61; ro = 0.33 + +x86-64: Intel(R) Xeon(R) E5410, 2.33GHz, 4656.90 bogomips +k = 0.99 usec; b = 0.43; o = 0.06; r = 1.24; rb = 0.68; ro = 0.30 + 7. TODO a. SystemTap (http://sourceware.org/systemtap): Provides a simplified
@@ -523,7 +689,8 @@ is also specified. Following columns show probe status. If the probe is on a virtual address that is no longer valid (module init sections, module virtual addresses that correspond to modules that've been unloaded), such probes are marked with [GONE]. If the probe is temporarily disabled, -such probes are marked with [DISABLED]. +such probes are marked with [DISABLED]. If the probe is optimized, it is +marked with [OPTIMIZED]. /sys/kernel/debug/kprobes/enabled: Turn kprobes ON/OFF forcibly.
@@ -533,3 +700,19 @@ registered probes will be disarmed, till such time a "1" is echoed to this file. Note that this knob just disarms and arms all kprobes and doesn't change each probe's disabling state. This means that disabled kprobes (marked [DISABLED]) will be not enabled if you turn ON all kprobes by this knob. + + +Appendix B: The kprobes sysctl interface + +/proc/sys/debug/kprobes-optimization: Turn kprobes optimization ON/OFF. + +When CONFIG_OPTPROBES=y, this sysctl interface appears and it provides +a knob to globally and forcibly turn jump optimization (see section +1.4) ON or OFF. By default, jump optimization is allowed (ON). +If you echo "0" to this file or set "debug.kprobes_optimization" to +0 via sysctl, all optimized probes will be unoptimized, and any new +probes registered after that will not be optimized. Note that this +knob *changes* the optimized state. This means that optimized probes +(marked [OPTIMIZED]) will be unoptimized ([OPTIMIZED] tag will be +removed). If the knob is turned on, they will be optimized again. +
PATCH 10/18 perf probe: Do not show --line option without dwarf support
In reply to Masami HiramatsuDo not show --line option in help message when perf doesn't support dwarf.
---
tools/perf/builtin-probe.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
tools/perf/builtin-probe.c +2 -0
@@ -156,7 +156,9 @@ static const char * const probe_usage[] = {"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]" ,"perf probe [<options>] --del '[GROUP:]EVENT' ..." ,"perf probe --list" , +#ifndef NO_LIBDWARF"perf probe --line 'LINEDESC'" , +#endif NULL };
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Do not show --line option without dwarf support
Commit-ID: f3ab481ca6ffe5e272c8501317bea726f9a83959 Gitweb: http://git.kernel.org/tip/f3ab481ca6ffe5e272c8501317bea726f9a83959 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:12 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:27 +0100
perf probe: Do not show --line option without dwarf support
Do not show --line option in help message when perf doesn't support dwarf.
LKML-Reference: <[email protected]>
--- tools/perf/builtin-probe.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
tools/perf/builtin-probe.c +2 -0
@@ -156,7 +156,9 @@ static const char * const probe_usage[] = {"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]" ,"perf probe [<options>] --del '[GROUP:]EVENT' ..." ,"perf probe --list" , +#ifndef NO_LIBDWARF"perf probe --line 'LINEDESC'" , +#endif NULL };
PATCH 11/18 perf probe: Update perf probe document
In reply to Masami HiramatsuUpdate perf-probe.txt to suit to current perf-probe command and add some examples.
---
tools/perf/Documentation/perf-probe.txt | 28 ++++++++++++++++++++++++++-- 1 files changed, 26 insertions(+), 2 deletions(-)
tools/perf/Documentation/perf-probe.txt +26 -2
@@ -41,7 +41,8 @@ OPTIONS -d:: --del=:: - Delete a probe event. + Delete probe events. This accepts glob wildcards('*', '?') and character + classes(e.g. [a-z], [!A-Z]). -l:: --list::
@@ -50,7 +51,11 @@ OPTIONS -L:: --line=:: Show source code lines which can be probed. This needs an argument - which specifies a range of the source code. + which specifies a range of the source code. (see LINE SYNTAX for detail) + +-f:: +--force:: + Forcibly add events with existing name. PROBE SYNTAX ------------
@@ -76,6 +81,25 @@ and 'ALN2' is end line number in the file. It is also possible to specify how many lines to show by using 'NUM'. So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function. +EXAMPLES +-------- +Display which lines in schedule() can be probed: + + ./perf probe --line schedule + +Add a probe on schedule() function 12th line with recording cpu local variable: + + ./perf probe schedule:12 cpu + or + ./perf probe --add='schedule:12 cpu' + + this will add one or more probes which has the name start with "schedule". + +Delete all probes on schedule(). + + ./perf probe --del='schedule*' + + SEE ALSO -------- linkperf:perf-trace[1], linkperf:perf-record[1]
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Update perf probe document
Commit-ID: ee391de876ae4272926b8632be04ed4a460321e3 Gitweb: http://git.kernel.org/tip/ee391de876ae4272926b8632be04ed4a460321e3 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:19 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:27 +0100
perf probe: Update perf probe document
Update perf-probe.txt to suit to current perf-probe command and add some examples.
LKML-Reference: <[email protected]>
--- tools/perf/Documentation/perf-probe.txt | 28 ++++++++++++++++++++++++++-- 1 files changed, 26 insertions(+), 2 deletions(-)
tools/perf/Documentation/perf-probe.txt +26 -2
@@ -41,7 +41,8 @@ OPTIONS -d:: --del=:: - Delete a probe event. + Delete probe events. This accepts glob wildcards('*', '?') and character + classes(e.g. [a-z], [!A-Z]). -l:: --list::
@@ -50,7 +51,11 @@ OPTIONS -L:: --line=:: Show source code lines which can be probed. This needs an argument - which specifies a range of the source code. + which specifies a range of the source code. (see LINE SYNTAX for detail) + +-f:: +--force:: + Forcibly add events with existing name. PROBE SYNTAX ------------
@@ -76,6 +81,25 @@ and 'ALN2' is end line number in the file. It is also possible to specify how many lines to show by using 'NUM'. So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function. +EXAMPLES +-------- +Display which lines in schedule() can be probed: + + ./perf probe --line schedule + +Add a probe on schedule() function 12th line with recording cpu local variable: + + ./perf probe schedule:12 cpu + or + ./perf probe --add='schedule:12 cpu' + + this will add one or more probes which has the name start with "schedule". + +Delete all probes on schedule(). + + ./perf probe --del='schedule*' + + SEE ALSO -------- linkperf:perf-trace[1], linkperf:perf-record[1]
PATCH 12/18 perf probe: Fix bugs in line range finder
In reply to Masami HiramatsuFix find_line_range_by_line() to init line_list and remove misconseptional found marking which should be done when real lines are found (if there is no lines probe-able, find_line_range() should return 0).
---
tools/perf/util/probe-finder.c | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-)
tools/perf/util/probe-finder.c +1 -2
@@ -788,6 +788,7 @@ static void find_line_range_by_line(struct line_finder *lf)Dwarf_Addr addr;int ret; +INIT_LIST_HEAD (&lf->lr->line_list); ret =dwarf_srclines (lf->cu_die, &lines, &cnt, &__dw_error);DIE_IF (ret !=DW_DLV_OK );
@@ -848,8 +849,6 @@ static int linefunc_callback(struct die_link *dlink, void *data) lr->start = lf->lno_s; lr->end = lf->lno_e;find_line_range_by_line (lf); -/* If we find a target function, this should be end. */ - lf->found =1 ;return 1 ; }return 0 ;
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Fix bugs in line range finder
Commit-ID: 3cb8bc6ac95ff86147d11ee1d36d18e1ddf3637c Gitweb: http://git.kernel.org/tip/3cb8bc6ac95ff86147d11ee1d36d18e1ddf3637c Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:27 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:28 +0100
perf probe: Fix bugs in line range finder
Fix find_line_range_by_line() to init line_list and remove misconseptional found marking which should be done when real lines are found (if there is no lines probe-able, find_line_range() should return 0).
LKML-Reference: <[email protected]>
--- tools/perf/util/probe-finder.c | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-)
tools/perf/util/probe-finder.c +1 -2
@@ -788,6 +788,7 @@ static void find_line_range_by_line(struct line_finder *lf)Dwarf_Addr addr;int ret; +INIT_LIST_HEAD (&lf->lr->line_list); ret =dwarf_srclines (lf->cu_die, &lines, &cnt, &__dw_error);DIE_IF (ret !=DW_DLV_OK );
@@ -848,8 +849,6 @@ static int linefunc_callback(struct die_link *dlink, void *data) lr->start = lf->lno_s; lr->end = lf->lno_e;find_line_range_by_line (lf); -/* If we find a target function, this should be end. */ - lf->found =1 ;return 1 ; }return 0 ;
PATCH 13/18 perf probe: Rename probe finder functions
In reply to Masami HiramatsuRename *_probepoint to *_probe_point, for nothing but a cosmetic reason.
---
tools/perf/builtin-probe.c | 2 +- tools/perf/util/probe-finder.c | 12 ++++++------ tools/perf/util/probe-finder.h | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-)
tools/perf/builtin-probe.c +1 -1
@@ -314,7 +314,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)continue ;lseek (fd,SEEK_SET ,0 ); - ret =find_probepoint (fd, pp); + ret =find_probe_point (fd, pp);if (ret >0 )continue ;if (ret ==0 ) {/* No error but failed to find probe point. */
tools/perf/util/probe-finder.c +6 -6
@@ -524,8 +524,8 @@ static void free_current_frame_base(struct probe_finder *pf) }/* Show a probe point to output buffer */ -static void show_probepoint (Dwarf_Die sp_die,Dwarf_Signed offs, -struct probe_finder *pf) +static void show_probe_point (Dwarf_Die sp_die,Dwarf_Signed offs, +struct probe_finder *pf) {struct probe_point *pp = pf->pp;char *name;
@@ -585,7 +585,7 @@ static int probeaddr_callback(struct die_link *dlink, void *data)/* Check the address is in this subprogram */ if (tag == DW_TAG_subprogram &&die_within_subprogram (dlink->die, pf->addr, &offs)) { -show_probepoint (dlink->die, offs, pf); +show_probe_point (dlink->die, offs, pf);return 1 ; }return 0 ;
@@ -668,7 +668,7 @@ static int probefunc_callback(struct die_link *dlink, void *data) pf->addr =die_get_entrypc (dlink->die); pf->addr += pp->offset;/* TODO: Check the address in this function */ -show_probepoint (dlink->die, pp->offset, pf); +show_probe_point (dlink->die, pp->offset, pf);return 1 ;/* Exit; no same symbol in this CU. */ } }else if (tag == DW_TAG_inlined_subroutine && pf->inl_offs) {
@@ -691,7 +691,7 @@ found:/* Get offset from subprogram */ ret =die_within_subprogram (lk->die, pf->addr, &offs);DIE_IF (!ret); -show_probepoint (lk->die, offs, pf); +show_probe_point (lk->die, offs, pf);/* Continue to search */ } }
@@ -704,7 +704,7 @@ static void find_probe_point_by_func(struct probe_finder *pf) }/* Find a probe point */ -int find_probepoint (int fd,struct probe_point *pp) +int find_probe_point (int fd,struct probe_point *pp) {Dwarf_Half addr_size =0 ;Dwarf_Unsigned next_cuh =0 ;
tools/perf/util/probe-finder.h +1 -1
@@ -52,7 +52,7 @@ struct line_range { };#ifndef NO_LIBDWARF -extern int find_probepoint (int fd,struct probe_point *pp); +extern int find_probe_point (int fd,struct probe_point *pp);extern int find_line_range (int fd,struct line_range *lr);/* Workaround for undefined _MIPS_SZLONG bug in libdwarf.h: */
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Rename probe finder functions
Commit-ID: 81cb8aa327b5923b38eccc795c8b7170be20b9ff Gitweb: http://git.kernel.org/tip/81cb8aa327b5923b38eccc795c8b7170be20b9ff Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:34 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:28 +0100
perf probe: Rename probe finder functions
Rename *_probepoint to *_probe_point, for nothing but a cosmetic reason.
LKML-Reference: <[email protected]>
--- tools/perf/builtin-probe.c | 2 +- tools/perf/util/probe-finder.c | 12 ++++++------ tools/perf/util/probe-finder.h | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-)
tools/perf/builtin-probe.c +1 -1
@@ -314,7 +314,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)continue ;lseek (fd,SEEK_SET ,0 ); - ret =find_probepoint (fd, pp); + ret =find_probe_point (fd, pp);if (ret >0 )continue ;if (ret ==0 ) {/* No error but failed to find probe point. */
tools/perf/util/probe-finder.c +6 -6
@@ -524,8 +524,8 @@ static void free_current_frame_base(struct probe_finder *pf) }/* Show a probe point to output buffer */ -static void show_probepoint (Dwarf_Die sp_die,Dwarf_Signed offs, -struct probe_finder *pf) +static void show_probe_point (Dwarf_Die sp_die,Dwarf_Signed offs, +struct probe_finder *pf) {struct probe_point *pp = pf->pp;char *name;
@@ -585,7 +585,7 @@ static int probeaddr_callback(struct die_link *dlink, void *data)/* Check the address is in this subprogram */ if (tag == DW_TAG_subprogram &&die_within_subprogram (dlink->die, pf->addr, &offs)) { -show_probepoint (dlink->die, offs, pf); +show_probe_point (dlink->die, offs, pf);return 1 ; }return 0 ;
@@ -668,7 +668,7 @@ static int probefunc_callback(struct die_link *dlink, void *data) pf->addr =die_get_entrypc (dlink->die); pf->addr += pp->offset;/* TODO: Check the address in this function */ -show_probepoint (dlink->die, pp->offset, pf); +show_probe_point (dlink->die, pp->offset, pf);return 1 ;/* Exit; no same symbol in this CU. */ } }else if (tag == DW_TAG_inlined_subroutine && pf->inl_offs) {
@@ -691,7 +691,7 @@ found:/* Get offset from subprogram */ ret =die_within_subprogram (lk->die, pf->addr, &offs);DIE_IF (!ret); -show_probepoint (lk->die, offs, pf); +show_probe_point (lk->die, offs, pf);/* Continue to search */ } }
@@ -704,7 +704,7 @@ static void find_probe_point_by_func(struct probe_finder *pf) }/* Find a probe point */ -int find_probepoint (int fd,struct probe_point *pp) +int find_probe_point (int fd,struct probe_point *pp) {Dwarf_Half addr_size =0 ;Dwarf_Unsigned next_cuh =0 ;
tools/perf/util/probe-finder.h +1 -1
@@ -52,7 +52,7 @@ struct line_range { };#ifndef NO_LIBDWARF -extern int find_probepoint (int fd,struct probe_point *pp); +extern int find_probe_point (int fd,struct probe_point *pp);extern int find_line_range (int fd,struct line_range *lr);/* Workaround for undefined _MIPS_SZLONG bug in libdwarf.h: */
PATCH 14/18 perf probe: Use elfutils-libdw for analyzing debuginfo
In reply to Masami HiramatsuNewer gcc introduces newer & richer debuginfo, and only libdw in elfutils project can support it. So perf probe moves onto elfutils-libdw from libdwarf.
Changes in v3:
- Cast Dwarf_Addr/Dwarf_Word to uintmax_t for printf-formats.
- Recover a sign-prefix which was removed in v2 by mistake.
Changes in v2:
- Fix a type-casting bug in Makefile.
- Cast Dwarf_Addr/Dwarf_Word to unsigned long long for printf-formats.
---
tools/perf/Makefile | 10 - tools/perf/builtin-probe.c | 22 + tools/perf/util/probe-finder.c | 696 ++++++++++++++++------------------------ tools/perf/util/probe-finder.h | 52 +-- 4 files changed, 314 insertions(+), 466 deletions(-)
tools/perf/Makefile +5 -5
@@ -500,12 +500,12 @@ else msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel and glibc-dev[el]); endif -ifneq ($(shell sh -c "(echo '\#ifndef _MIPS_SZLONG'; echo '\#define _MIPS_SZLONG 0'; echo '\#endif'; echo '\#include <dwarf.h>'; echo '\#include <libdwarf.h>'; echo 'int main(void) { Dwarf_Debug dbg; Dwarf_Error err; Dwarf_Ranges *rng; dwarf_init(0, DW_DLC_READ, 0, 0, &dbg, &err); dwarf_get_ranges(dbg, 0, &rng, 0, 0, &err); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/libdwarf -ldwarf -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y) - msg := $(warning No libdwarf.h found or old libdwarf.h found, disables dwarf support. Please install libdwarf-dev/libdwarf-devel >= 20081231); - BASIC_CFLAGS += -DNO_LIBDWARF +ifneq ($(shell sh -c "(echo '\#include <dwarf.h>'; echo '\#include <libdw.h>'; echo 'int main(void) { Dwarf *dbg; dbg = dwarf_begin(0, DWARF_C_READ); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/elfutils -ldw -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y) + msg := $(warning No libdw.h found or old libdw.h found, disables dwarf support. Please install elfutils-devel/elfutils-dev); + BASIC_CFLAGS += -DNO_DWARF_SUPPORT else - BASIC_CFLAGS += -I/usr/include/libdwarf - EXTLIBS += -lelf -ldwarf + BASIC_CFLAGS += -I/usr/include/elfutils + EXTLIBS += -lelf -ldw LIB_OBJS += util/probe-finder.o endif
tools/perf/builtin-probe.c +11 -11
@@ -128,7 +128,7 @@ static void evaluate_probe_point(struct probe_point *pp) pp->function); } -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT static int open_vmlinux (void ) {if (map__load (session.kmaps[MAP__FUNCTION ],NULL ) <0 ) {
@@ -156,7 +156,7 @@ static const char * const probe_usage[] = {"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]" ,"perf probe [<options>] --del '[GROUP:]EVENT' ..." ,"perf probe --list" , -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT"perf probe --line 'LINEDESC'" , #endifNULL
@@ -165,7 +165,7 @@ static const char * const probe_usage[] = {static const struct option options[] = {OPT_BOOLEAN ('v' ,"verbose" , &verbose,"be more verbose (show parsed arguments, etc)" ), -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORTOPT_STRING ('k' ,"vmlinux" , &symbol_conf.vmlinux_name,"file" ,"vmlinux pathname" ), #endif
@@ -174,7 +174,7 @@ static const struct option options[] = {OPT_CALLBACK ('d' ,"del" ,NULL ,"[GROUP:]EVENT" ,"delete a probe event." , opt_del_probe_event), OPT_CALLBACK('a', "add", NULL, -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT "[EVENT=]FUNC[+OFFS|%return] [ARG ...]", #else "[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]",
@@ -185,7 +185,7 @@ static const struct option options[] = { "\t\tFUNC:\tFunction name\n" "\t\tOFFS:\tOffset from function entry (in byte)\n" "\t\t%return:\tPut the probe at function return\n" -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT "\t\tARG:\tProbe argument (only \n" #else"\t\tSRC:\tSource code path\n"
@@ -197,7 +197,7 @@ static const struct option options[] = { opt_add_probe_event),OPT_BOOLEAN ('f' ,"force" , &session.force_add,"forcibly add events" " with existing name" ), -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORTOPT_CALLBACK ('L' ,"line" ,NULL ,"FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]" , "Show source code lines.", opt_show_lines),
@@ -225,7 +225,7 @@ static void init_vmlinux(void)int cmd_probe (int argc,const char **argv,const char *prefix__used ) {int i, ret; -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT int fd;#endif struct probe_point *pp;
@@ -261,7 +261,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)return 0 ; } -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT if (session.show_lines) {if (session.nr_probe !=0 || session.dellist) { pr_warning(" Error: Don't use --line with"
@@ -292,9 +292,9 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)init_vmlinux (); if (session.need_dwarf) -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT die ("Debuginfo-analysis is not supported" ); -#else /* !NO_LIBDWARF */ +#else /* !NO_DWARF_SUPPORT */ pr_debug ("Some probes require debuginfo.\n" ); fd =open_vmlinux ();
@@ -335,7 +335,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)close (fd); end_dwarf: -#endif /* !NO_LIBDWARF */ +#endif /* !NO_DWARF_SUPPORT */ /* Synthesize probes without dwarf */ for (i =0 ; i < session.nr_probe; i++) {
tools/perf/util/probe-finder.c +274 -422
1,023 lines not on this page · raw message
tools/perf/util/probe-finder.h +24 -28
83 lines not on this page · raw message
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Use elfutils-libdw for analyzing debuginfo
Commit-ID: 804b36068eccd8163ccea420c662fb5d1a21b141 Gitweb: http://git.kernel.org/tip/804b36068eccd8163ccea420c662fb5d1a21b141 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:42 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:29 +0100
perf probe: Use elfutils-libdw for analyzing debuginfo
Newer gcc introduces newer & richer debuginfo, and only libdw in elfutils project can support it. So perf probe moves onto elfutils-libdw from libdwarf.
Changes in v3:
- Cast Dwarf_Addr/Dwarf_Word to uintmax_t for printf-formats.
- Recover a sign-prefix which was removed in v2 by mistake.
Changes in v2:
- Fix a type-casting bug in Makefile.
- Cast Dwarf_Addr/Dwarf_Word to unsigned long long for printf-formats.
LKML-Reference: <[email protected]>
--- tools/perf/Makefile | 10 +- tools/perf/builtin-probe.c | 22 +- tools/perf/util/probe-finder.c | 696 ++++++++++++++++------------------------ tools/perf/util/probe-finder.h | 52 ++-- 4 files changed, 314 insertions(+), 466 deletions(-)
tools/perf/Makefile +5 -5
@@ -500,12 +500,12 @@ else msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel and glibc-dev[el]); endif -ifneq ($(shell sh -c "(echo '\#ifndef _MIPS_SZLONG'; echo '\#define _MIPS_SZLONG 0'; echo '\#endif'; echo '\#include <dwarf.h>'; echo '\#include <libdwarf.h>'; echo 'int main(void) { Dwarf_Debug dbg; Dwarf_Error err; Dwarf_Ranges *rng; dwarf_init(0, DW_DLC_READ, 0, 0, &dbg, &err); dwarf_get_ranges(dbg, 0, &rng, 0, 0, &err); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/libdwarf -ldwarf -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y) - msg := $(warning No libdwarf.h found or old libdwarf.h found, disables dwarf support. Please install libdwarf-dev/libdwarf-devel >= 20081231); - BASIC_CFLAGS += -DNO_LIBDWARF +ifneq ($(shell sh -c "(echo '\#include <dwarf.h>'; echo '\#include <libdw.h>'; echo 'int main(void) { Dwarf *dbg; dbg = dwarf_begin(0, DWARF_C_READ); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/elfutils -ldw -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y) + msg := $(warning No libdw.h found or old libdw.h found, disables dwarf support. Please install elfutils-devel/elfutils-dev); + BASIC_CFLAGS += -DNO_DWARF_SUPPORT else - BASIC_CFLAGS += -I/usr/include/libdwarf - EXTLIBS += -lelf -ldwarf + BASIC_CFLAGS += -I/usr/include/elfutils + EXTLIBS += -lelf -ldw LIB_OBJS += util/probe-finder.o endif
tools/perf/builtin-probe.c +11 -11
@@ -128,7 +128,7 @@ static void evaluate_probe_point(struct probe_point *pp) pp->function); } -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT static int open_vmlinux (void ) {if (map__load (session.kmaps[MAP__FUNCTION ],NULL ) <0 ) {
@@ -156,7 +156,7 @@ static const char * const probe_usage[] = {"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]" ,"perf probe [<options>] --del '[GROUP:]EVENT' ..." ,"perf probe --list" , -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT"perf probe --line 'LINEDESC'" , #endifNULL
@@ -165,7 +165,7 @@ static const char * const probe_usage[] = {static const struct option options[] = {OPT_BOOLEAN ('v' ,"verbose" , &verbose,"be more verbose (show parsed arguments, etc)" ), -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORTOPT_STRING ('k' ,"vmlinux" , &symbol_conf.vmlinux_name,"file" ,"vmlinux pathname" ), #endif
@@ -174,7 +174,7 @@ static const struct option options[] = {OPT_CALLBACK ('d' ,"del" ,NULL ,"[GROUP:]EVENT" ,"delete a probe event." , opt_del_probe_event), OPT_CALLBACK('a', "add", NULL, -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT "[EVENT=]FUNC[+OFFS|%return] [ARG ...]", #else "[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]",
@@ -185,7 +185,7 @@ static const struct option options[] = { "\t\tFUNC:\tFunction name\n" "\t\tOFFS:\tOffset from function entry (in byte)\n" "\t\t%return:\tPut the probe at function return\n" -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT "\t\tARG:\tProbe argument (only \n" #else"\t\tSRC:\tSource code path\n"
@@ -197,7 +197,7 @@ static const struct option options[] = { opt_add_probe_event),OPT_BOOLEAN ('f' ,"force" , &session.force_add,"forcibly add events" " with existing name" ), -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORTOPT_CALLBACK ('L' ,"line" ,NULL ,"FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]" , "Show source code lines.", opt_show_lines),
@@ -225,7 +225,7 @@ static void init_vmlinux(void)int cmd_probe (int argc,const char **argv,const char *prefix__used ) {int i, ret; -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT int fd;#endif struct probe_point *pp;
@@ -261,7 +261,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)return 0 ; } -#ifndef NO_LIBDWARF +#ifndef NO_DWARF_SUPPORT if (session.show_lines) {if (session.nr_probe !=0 || session.dellist) { pr_warning(" Error: Don't use --line with"
@@ -292,9 +292,9 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)init_vmlinux (); if (session.need_dwarf) -#ifdef NO_LIBDWARF +#ifdef NO_DWARF_SUPPORT die ("Debuginfo-analysis is not supported" ); -#else /* !NO_LIBDWARF */ +#else /* !NO_DWARF_SUPPORT */ pr_debug ("Some probes require debuginfo.\n" ); fd =open_vmlinux ();
@@ -335,7 +335,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)close (fd); end_dwarf: -#endif /* !NO_LIBDWARF */ +#endif /* !NO_DWARF_SUPPORT */ /* Synthesize probes without dwarf */ for (i =0 ; i < session.nr_probe; i++) {
tools/perf/util/probe-finder.c +274 -422
1,023 lines not on this page · raw message
tools/perf/util/probe-finder.h +24 -28
83 lines not on this page · raw message
PATCH 15/18 perf probe: Use libdw callback routines
In reply to Masami HiramatsuUse libdw callback functions aggressively, and remove local tree-search API. This change simplifies the code.
Changes in v3:
- Cast Dwarf_Addr to uintmax_t for printf-formats.
Changes in v2:
- Cast Dwarf_Addr to unsigned long long for printf-formats.
---
tools/perf/util/probe-finder.c | 262 +++++++++++++--------------------------- tools/perf/util/probe-finder.h | 1 2 files changed, 86 insertions(+), 177 deletions(-)
tools/perf/util/probe-finder.c +86 -176
@@ -38,13 +38,6 @@#include "probe-finder.h" -/* Dwarf_Die Linkage to parent Die */ -struct die_link { -struct die_link *parent;/* Parent die */ -Dwarf_Die die;/* Current die */ -}; - -/* * Generic dwarf analysis helpers */
@@ -177,26 +170,6 @@ static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)return strcmp (tname, name); } -/* Check the address is in the subprogram(function). */ -static bool die_within_subprogram (Dwarf_Die *sp_die,Dwarf_Addr addr, -size_t *offs) -{ -Dwarf_Addr epc; -int ret; - - ret =dwarf_haspc (sp_die, addr); -if (ret <=0 ) -return false; - -if (offs) { - ret =dwarf_entrypc (sp_die, &epc); -DIE_IF (ret ==-1 ); - *offs = addr - epc; - } - -return true; -} -/* Get entry pc(or low pc, 1st entry of ranges) of the die */ static Dwarf_Addr die_get_entrypc (Dwarf_Die *dw_die) {
@@ -208,70 +181,34 @@ static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)return epc; } -/* Check if the abstract origin's address or not */ -static bool die_compare_abstract_origin (Dwarf_Die *in_die,void *origin_addr) -{ -Dwarf_Attribute attr; -Dwarf_Die origin; - -if (!dwarf_attr (in_die, DW_AT_abstract_origin, &attr)) -return false; -if (!dwarf_formref_die (&attr, &origin)) -return false; - -return origin.addr == origin_addr; -} - -/* -* Search a Die from Die tree. -* Note: cur_link->die should be deallocated in this function. -*/ -static int __search_die_tree (struct die_link *cur_link, -int (*die_cb)(struct die_link *,void *), -void *data) +/* Get a variable die */ +static Dwarf_Die *die_find_variable (Dwarf_Die *sp_die,const char *name, +Dwarf_Die *die_mem) { -struct die_link new_link; +Dwarf_Die child_die; +int tag;int ret; -if (!die_cb) -return 0 ; - -/* Check current die */ -while (!(ret =die_cb (cur_link, data))) { -/* Check child die */ - ret =dwarf_child (&cur_link->die, &new_link.die); -if (ret ==0 ) { - new_link.parent = cur_link; - ret =__search_die_tree (&new_link, die_cb, data); -if (ret) -break ; - } + ret =dwarf_child (sp_die, die_mem); +if (ret !=0 ) +return NULL ; -/* Move to next sibling */ - ret =dwarf_siblingof (&cur_link->die, &cur_link->die); -if (ret !=0 ) -return 0 ; - } -return ret; -} +do { + tag =dwarf_tag (die_mem); +if ((tag == DW_TAG_formal_parameter || + tag == DW_TAG_variable) && + (die_compare_name (die_mem, name) ==0 )) +return die_mem; -/* Search a die in its children's die tree */ -static int search_die_from_children (Dwarf_Die *parent_die, -int (*die_cb)(struct die_link *,void *), -void *data) -{ -struct die_link new_link; -int ret; +if (die_find_variable (die_mem, name, &child_die)) { +memcpy (die_mem, &child_die,sizeof (Dwarf_Die)); +return die_mem; + } + }while (dwarf_siblingof (die_mem, die_mem) ==0 ); - new_link.parent =NULL ; - ret =dwarf_child (parent_die, &new_link.die); -if (ret ==0 ) -return __search_die_tree (&new_link, die_cb, data); -else -return 0 ; +return NULL ; } -/* * Probe finder related functions */
@@ -347,28 +284,13 @@ error: " Perhaps, it has been optimized out.", pf->var); } -static int variable_search_cb (struct die_link *dlink,void *data) -{ -struct probe_finder *pf = (struct probe_finder *)data; -int tag; - - tag =dwarf_tag (&dlink->die); -DIE_IF (tag <0 ); -if ((tag == DW_TAG_formal_parameter || - tag == DW_TAG_variable) && - (die_compare_name (&dlink->die, pf->var) ==0 )) { -show_variable (&dlink->die, pf); -return 1 ; - } -/* TODO: Support struct members and arrays */ -return 0 ; -} -/* Find a variable in a subprogram die */ static void find_variable (Dwarf_Die *sp_die,struct probe_finder *pf) {int ret; +Dwarf_Die vr_die; +/* TODO: Support struct members and arrays */ if (!is_c_varname (pf->var)) {/* Output raw parameters */ ret =snprintf (pf->buf, pf->len," %s" , pf->var);
@@ -379,31 +301,42 @@ static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)pr_debug ("Searching '%s' variable in context.\n" , pf->var);/* Search child die for local variables and parameters. */ - ret =search_die_from_children (sp_die, variable_search_cb, pf); -if (!ret) +if (!die_find_variable (sp_die, pf->var, &vr_die))die ("Failed to find '%s' in this function." , pf->var); + +show_variable (&vr_die, pf); }/* Show a probe point to output buffer */ -static void show_probe_point (Dwarf_Die *sp_die,size_t offs, -struct probe_finder *pf) +static void show_probe_point (Dwarf_Die *sp_die,struct probe_finder *pf) {struct probe_point *pp = pf->pp; +Dwarf_Addr eaddr; +Dwarf_Die die_mem;const char *name;char tmp[MAX_PROBE_BUFFER ];int ret, i, len;Dwarf_Attribute fb_attr;size_t nops; +/* If no real subprogram, find a real one */ +if (!sp_die ||dwarf_tag (sp_die) != DW_TAG_subprogram) { + sp_die =die_get_real_subprogram (&pf->cu_die, + pf->addr, &die_mem); +if (!sp_die) +die ("Probe point is not found in subprograms." ); + } +/* Output name of probe point */ name =dwarf_diename (sp_die);if (name) { - ret =snprintf (tmp,MAX_PROBE_BUFFER ,"%s+%u" , name, - (unsigned int )offs); +dwarf_entrypc (sp_die, &eaddr); + ret =snprintf (tmp,MAX_PROBE_BUFFER ,"%s+%lu" , name, + (unsigned long )(pf->addr - eaddr));/* Copy the function name if possible */ if (!pp->function) { pp->function =strdup (name); - pp->offset = offs; + pp->offset = (size_t )(pf->addr - eaddr); } }else {/* This function has no name. */
@@ -450,10 +383,9 @@ static void find_probe_point_by_line(struct probe_finder *pf)Dwarf_Lines *lines;Dwarf_Line *line;size_t nlines, i; -Dwarf_Addr addr, epc; +Dwarf_Addr addr;int lineno;int ret; -Dwarf_Die *sp_die, die_mem; ret =dwarf_getsrclines (&pf->cu_die, &lines, &nlines);DIE_IF (ret !=0 );
@@ -474,77 +406,57 @@ static void find_probe_point_by_line(struct probe_finder *pf) (int)i, lineno, (uintmax_t)addr); pf->addr = addr; - sp_die =die_get_real_subprogram (&pf->cu_die, addr, &die_mem); -if (!sp_die) -die ("Probe point is not found in subprograms." ); -dwarf_entrypc (sp_die, &epc); -show_probe_point (sp_die, (size_t )(addr - epc), pf); +show_probe_point (NULL , pf);/* Continuing, because target line might be inlined. */ } } +static int probe_point_inline_cb (Dwarf_Die *in_die,void *data) +{ +struct probe_finder *pf = (struct probe_finder *)data; +struct probe_point *pp = pf->pp; + +/* Get probe address */ + pf->addr =die_get_entrypc (in_die); + pf->addr += pp->offset; +pr_debug ("found inline addr: 0x%jx\n" , (uintmax_t )pf->addr); + +show_probe_point (in_die, pf); +return DWARF_CB_OK ; +}/* Search function from function name */ -static int probe_point_search_cb (struct die_link *dlink,void *data) +static int probe_point_search_cb (Dwarf_Die *sp_die,void *data) {struct probe_finder *pf = (struct probe_finder *)data;struct probe_point *pp = pf->pp; -struct die_link *lk; -size_t offs; -int tag; -int ret; - tag =dwarf_tag (&dlink->die); -if (tag == DW_TAG_subprogram) { -if (die_compare_name (&dlink->die, pp->function) ==0 ) { -if (pp->line) {/* Function relative line */ - pf->fname =dwarf_decl_file (&dlink->die); -dwarf_decl_line (&dlink->die, &pf->lno); - pf->lno += pp->line; -find_probe_point_by_line (pf); -return 1 ; - } -if (dwarf_func_inline (&dlink->die)) { -/* Inlined function, save it. */ - pf->origin = dlink->die.addr; -return 0 ;/* Continue to search */ - } -/* Get probe address */ - pf->addr =die_get_entrypc (&dlink->die); - pf->addr += pp->offset; -/* TODO: Check the address in this function */ -show_probe_point (&dlink->die, pp->offset, pf); -return 1 ;/* Exit; no same symbol in this CU. */ - } - }else if (tag == DW_TAG_inlined_subroutine && pf->origin) { -if (die_compare_abstract_origin (&dlink->die, pf->origin)) { -/* Get probe address */ - pf->addr =die_get_entrypc (&dlink->die); - pf->addr += pp->offset; -pr_debug ("found inline addr: 0x%jx\n" , - (uintmax_t )pf->addr); -/* Inlined function. Get a real subprogram */ -for (lk = dlink->parent; lk !=NULL ; lk = lk->parent) { - tag =dwarf_tag (&lk->die); -if (tag == DW_TAG_subprogram && - !dwarf_func_inline (&lk->die)) - goto found; - } -die ("Failed to find real subprogram." ); -found: -/* Get offset from subprogram */ - ret =die_within_subprogram (&lk->die, pf->addr, &offs); -DIE_IF (!ret); -show_probe_point (&lk->die, offs, pf); -/* Continue to search */ - } - } -return 0 ; +/* Check tag and diename */ +if (dwarf_tag (sp_die) != DW_TAG_subprogram || +die_compare_name (sp_die, pp->function) !=0 ) +return 0 ; + +if (pp->line) {/* Function relative line */ + pf->fname =dwarf_decl_file (sp_die); +dwarf_decl_line (sp_die, &pf->lno); + pf->lno += pp->line; +find_probe_point_by_line (pf); + }else if (!dwarf_func_inline (sp_die)) { +/* Real function */ + pf->addr =die_get_entrypc (sp_die); + pf->addr += pp->offset; +/* TODO: Check the address in this function */ +show_probe_point (sp_die, pf); + }else +/* Inlined function: search instances */ +dwarf_func_inline_instances (sp_die, probe_point_inline_cb, pf); + +return 1 ;/* Exit; no same symbol in this CU. */ }static void find_probe_point_by_func (struct probe_finder *pf) { -search_die_from_children (&pf->cu_die, probe_point_search_cb, pf); +dwarf_getfuncs (&pf->cu_die, probe_point_search_cb, pf,0 ); }/* Find a probe point */
@@ -669,27 +581,25 @@ static void find_line_range_by_line(struct line_finder *lf) }/* Search function from function name */ -static int line_range_search_cb (struct die_link *dlink,void *data) +static int line_range_search_cb (Dwarf_Die *sp_die,void *data) {struct line_finder *lf = (struct line_finder *)data;struct line_range *lr = lf->lr; -int tag;int ret; - tag =dwarf_tag (&dlink->die); -if (tag == DW_TAG_subprogram && -die_compare_name (&dlink->die, lr->function) ==0 ) { +if (dwarf_tag (sp_die) == DW_TAG_subprogram && +die_compare_name (sp_die, lr->function) ==0 ) {/* Get the address range of this function */ - ret =dwarf_highpc (&dlink->die, &lf->addr_e); + ret =dwarf_highpc (sp_die, &lf->addr_e);if (ret ==0 ) - ret =dwarf_lowpc (&dlink->die, &lf->addr_s); + ret =dwarf_lowpc (sp_die, &lf->addr_s);if (ret !=0 ) { lf->addr_s =0 ; lf->addr_e =0 ; } - lf->fname =dwarf_decl_file (&dlink->die); -dwarf_decl_line (&dlink->die, &lr->offset); + lf->fname =dwarf_decl_file (sp_die); +dwarf_decl_line (sp_die, &lr->offset);pr_debug ("fname: %s, lineno:%d\n" , lf->fname, lr->offset); lf->lno_s = lr->offset + lr->start;if (!lr->end)
@@ -706,7 +616,7 @@ static int line_range_search_cb(struct die_link *dlink, void *data)static void find_line_range_by_func (struct line_finder *lf) { -search_die_from_children (&lf->cu_die, line_range_search_cb, lf); +dwarf_getfuncs (&lf->cu_die, line_range_search_cb, lf,0 ); }int find_line_range (int fd,struct line_range *lr)
tools/perf/util/probe-finder.h +0 -1
@@ -66,7 +66,6 @@ struct probe_finder {Dwarf_Addr addr;/* Address */ const char *fname;/* File name */ int lno;/* Line number */ -void *origin;/* Inline origin addr */ Dwarf_Die cu_die;/* Current CU */ /* For variable searching */
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Use libdw callback routines
Commit-ID: e92b85e1ffaa0bd8e5d92e7c378a3909e7f23122 Gitweb: http://git.kernel.org/tip/e92b85e1ffaa0bd8e5d92e7c378a3909e7f23122 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:50 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:29 +0100
perf probe: Use libdw callback routines
Use libdw callback functions aggressively, and remove local tree-search API. This change simplifies the code.
Changes in v3:
- Cast Dwarf_Addr to uintmax_t for printf-formats.
Changes in v2:
- Cast Dwarf_Addr to unsigned long long for printf-formats.
LKML-Reference: <[email protected]>
--- tools/perf/util/probe-finder.c | 262 +++++++++++++--------------------------- tools/perf/util/probe-finder.h | 1 - 2 files changed, 86 insertions(+), 177 deletions(-)
tools/perf/util/probe-finder.c +86 -176
@@ -38,13 +38,6 @@#include "probe-finder.h" -/* Dwarf_Die Linkage to parent Die */ -struct die_link { -struct die_link *parent;/* Parent die */ -Dwarf_Die die;/* Current die */ -}; - -/* * Generic dwarf analysis helpers */
@@ -177,26 +170,6 @@ static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)return strcmp (tname, name); } -/* Check the address is in the subprogram(function). */ -static bool die_within_subprogram (Dwarf_Die *sp_die,Dwarf_Addr addr, -size_t *offs) -{ -Dwarf_Addr epc; -int ret; - - ret =dwarf_haspc (sp_die, addr); -if (ret <=0 ) -return false; - -if (offs) { - ret =dwarf_entrypc (sp_die, &epc); -DIE_IF (ret ==-1 ); - *offs = addr - epc; - } - -return true; -} -/* Get entry pc(or low pc, 1st entry of ranges) of the die */ static Dwarf_Addr die_get_entrypc (Dwarf_Die *dw_die) {
@@ -208,70 +181,34 @@ static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)return epc; } -/* Check if the abstract origin's address or not */ -static bool die_compare_abstract_origin (Dwarf_Die *in_die,void *origin_addr) -{ -Dwarf_Attribute attr; -Dwarf_Die origin; - -if (!dwarf_attr (in_die, DW_AT_abstract_origin, &attr)) -return false; -if (!dwarf_formref_die (&attr, &origin)) -return false; - -return origin.addr == origin_addr; -} - -/* -* Search a Die from Die tree. -* Note: cur_link->die should be deallocated in this function. -*/ -static int __search_die_tree (struct die_link *cur_link, -int (*die_cb)(struct die_link *,void *), -void *data) +/* Get a variable die */ +static Dwarf_Die *die_find_variable (Dwarf_Die *sp_die,const char *name, +Dwarf_Die *die_mem) { -struct die_link new_link; +Dwarf_Die child_die; +int tag;int ret; -if (!die_cb) -return 0 ; - -/* Check current die */ -while (!(ret =die_cb (cur_link, data))) { -/* Check child die */ - ret =dwarf_child (&cur_link->die, &new_link.die); -if (ret ==0 ) { - new_link.parent = cur_link; - ret =__search_die_tree (&new_link, die_cb, data); -if (ret) -break ; - } + ret =dwarf_child (sp_die, die_mem); +if (ret !=0 ) +return NULL ; -/* Move to next sibling */ - ret =dwarf_siblingof (&cur_link->die, &cur_link->die); -if (ret !=0 ) -return 0 ; - } -return ret; -} +do { + tag =dwarf_tag (die_mem); +if ((tag == DW_TAG_formal_parameter || + tag == DW_TAG_variable) && + (die_compare_name (die_mem, name) ==0 )) +return die_mem; -/* Search a die in its children's die tree */ -static int search_die_from_children (Dwarf_Die *parent_die, -int (*die_cb)(struct die_link *,void *), -void *data) -{ -struct die_link new_link; -int ret; +if (die_find_variable (die_mem, name, &child_die)) { +memcpy (die_mem, &child_die,sizeof (Dwarf_Die)); +return die_mem; + } + }while (dwarf_siblingof (die_mem, die_mem) ==0 ); - new_link.parent =NULL ; - ret =dwarf_child (parent_die, &new_link.die); -if (ret ==0 ) -return __search_die_tree (&new_link, die_cb, data); -else -return 0 ; +return NULL ; } -/* * Probe finder related functions */
@@ -347,28 +284,13 @@ error: " Perhaps, it has been optimized out.", pf->var); } -static int variable_search_cb (struct die_link *dlink,void *data) -{ -struct probe_finder *pf = (struct probe_finder *)data; -int tag; - - tag =dwarf_tag (&dlink->die); -DIE_IF (tag <0 ); -if ((tag == DW_TAG_formal_parameter || - tag == DW_TAG_variable) && - (die_compare_name (&dlink->die, pf->var) ==0 )) { -show_variable (&dlink->die, pf); -return 1 ; - } -/* TODO: Support struct members and arrays */ -return 0 ; -} -/* Find a variable in a subprogram die */ static void find_variable (Dwarf_Die *sp_die,struct probe_finder *pf) {int ret; +Dwarf_Die vr_die; +/* TODO: Support struct members and arrays */ if (!is_c_varname (pf->var)) {/* Output raw parameters */ ret =snprintf (pf->buf, pf->len," %s" , pf->var);
@@ -379,31 +301,42 @@ static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)pr_debug ("Searching '%s' variable in context.\n" , pf->var);/* Search child die for local variables and parameters. */ - ret =search_die_from_children (sp_die, variable_search_cb, pf); -if (!ret) +if (!die_find_variable (sp_die, pf->var, &vr_die))die ("Failed to find '%s' in this function." , pf->var); + +show_variable (&vr_die, pf); }/* Show a probe point to output buffer */ -static void show_probe_point (Dwarf_Die *sp_die,size_t offs, -struct probe_finder *pf) +static void show_probe_point (Dwarf_Die *sp_die,struct probe_finder *pf) {struct probe_point *pp = pf->pp; +Dwarf_Addr eaddr; +Dwarf_Die die_mem;const char *name;char tmp[MAX_PROBE_BUFFER ];int ret, i, len;Dwarf_Attribute fb_attr;size_t nops; +/* If no real subprogram, find a real one */ +if (!sp_die ||dwarf_tag (sp_die) != DW_TAG_subprogram) { + sp_die =die_get_real_subprogram (&pf->cu_die, + pf->addr, &die_mem); +if (!sp_die) +die ("Probe point is not found in subprograms." ); + } +/* Output name of probe point */ name =dwarf_diename (sp_die);if (name) { - ret =snprintf (tmp,MAX_PROBE_BUFFER ,"%s+%u" , name, - (unsigned int )offs); +dwarf_entrypc (sp_die, &eaddr); + ret =snprintf (tmp,MAX_PROBE_BUFFER ,"%s+%lu" , name, + (unsigned long )(pf->addr - eaddr));/* Copy the function name if possible */ if (!pp->function) { pp->function =strdup (name); - pp->offset = offs; + pp->offset = (size_t )(pf->addr - eaddr); } }else {/* This function has no name. */
@@ -450,10 +383,9 @@ static void find_probe_point_by_line(struct probe_finder *pf)Dwarf_Lines *lines;Dwarf_Line *line;size_t nlines, i; -Dwarf_Addr addr, epc; +Dwarf_Addr addr;int lineno;int ret; -Dwarf_Die *sp_die, die_mem; ret =dwarf_getsrclines (&pf->cu_die, &lines, &nlines);DIE_IF (ret !=0 );
@@ -474,77 +406,57 @@ static void find_probe_point_by_line(struct probe_finder *pf) (int)i, lineno, (uintmax_t)addr); pf->addr = addr; - sp_die =die_get_real_subprogram (&pf->cu_die, addr, &die_mem); -if (!sp_die) -die ("Probe point is not found in subprograms." ); -dwarf_entrypc (sp_die, &epc); -show_probe_point (sp_die, (size_t )(addr - epc), pf); +show_probe_point (NULL , pf);/* Continuing, because target line might be inlined. */ } } +static int probe_point_inline_cb (Dwarf_Die *in_die,void *data) +{ +struct probe_finder *pf = (struct probe_finder *)data; +struct probe_point *pp = pf->pp; + +/* Get probe address */ + pf->addr =die_get_entrypc (in_die); + pf->addr += pp->offset; +pr_debug ("found inline addr: 0x%jx\n" , (uintmax_t )pf->addr); + +show_probe_point (in_die, pf); +return DWARF_CB_OK ; +}/* Search function from function name */ -static int probe_point_search_cb (struct die_link *dlink,void *data) +static int probe_point_search_cb (Dwarf_Die *sp_die,void *data) {struct probe_finder *pf = (struct probe_finder *)data;struct probe_point *pp = pf->pp; -struct die_link *lk; -size_t offs; -int tag; -int ret; - tag =dwarf_tag (&dlink->die); -if (tag == DW_TAG_subprogram) { -if (die_compare_name (&dlink->die, pp->function) ==0 ) { -if (pp->line) {/* Function relative line */ - pf->fname =dwarf_decl_file (&dlink->die); -dwarf_decl_line (&dlink->die, &pf->lno); - pf->lno += pp->line; -find_probe_point_by_line (pf); -return 1 ; - } -if (dwarf_func_inline (&dlink->die)) { -/* Inlined function, save it. */ - pf->origin = dlink->die.addr; -return 0 ;/* Continue to search */ - } -/* Get probe address */ - pf->addr =die_get_entrypc (&dlink->die); - pf->addr += pp->offset; -/* TODO: Check the address in this function */ -show_probe_point (&dlink->die, pp->offset, pf); -return 1 ;/* Exit; no same symbol in this CU. */ - } - }else if (tag == DW_TAG_inlined_subroutine && pf->origin) { -if (die_compare_abstract_origin (&dlink->die, pf->origin)) { -/* Get probe address */ - pf->addr =die_get_entrypc (&dlink->die); - pf->addr += pp->offset; -pr_debug ("found inline addr: 0x%jx\n" , - (uintmax_t )pf->addr); -/* Inlined function. Get a real subprogram */ -for (lk = dlink->parent; lk !=NULL ; lk = lk->parent) { - tag =dwarf_tag (&lk->die); -if (tag == DW_TAG_subprogram && - !dwarf_func_inline (&lk->die)) - goto found; - } -die ("Failed to find real subprogram." ); -found: -/* Get offset from subprogram */ - ret =die_within_subprogram (&lk->die, pf->addr, &offs); -DIE_IF (!ret); -show_probe_point (&lk->die, offs, pf); -/* Continue to search */ - } - } -return 0 ; +/* Check tag and diename */ +if (dwarf_tag (sp_die) != DW_TAG_subprogram || +die_compare_name (sp_die, pp->function) !=0 ) +return 0 ; + +if (pp->line) {/* Function relative line */ + pf->fname =dwarf_decl_file (sp_die); +dwarf_decl_line (sp_die, &pf->lno); + pf->lno += pp->line; +find_probe_point_by_line (pf); + }else if (!dwarf_func_inline (sp_die)) { +/* Real function */ + pf->addr =die_get_entrypc (sp_die); + pf->addr += pp->offset; +/* TODO: Check the address in this function */ +show_probe_point (sp_die, pf); + }else +/* Inlined function: search instances */ +dwarf_func_inline_instances (sp_die, probe_point_inline_cb, pf); + +return 1 ;/* Exit; no same symbol in this CU. */ }static void find_probe_point_by_func (struct probe_finder *pf) { -search_die_from_children (&pf->cu_die, probe_point_search_cb, pf); +dwarf_getfuncs (&pf->cu_die, probe_point_search_cb, pf,0 ); }/* Find a probe point */
@@ -669,27 +581,25 @@ static void find_line_range_by_line(struct line_finder *lf) }/* Search function from function name */ -static int line_range_search_cb (struct die_link *dlink,void *data) +static int line_range_search_cb (Dwarf_Die *sp_die,void *data) {struct line_finder *lf = (struct line_finder *)data;struct line_range *lr = lf->lr; -int tag;int ret; - tag =dwarf_tag (&dlink->die); -if (tag == DW_TAG_subprogram && -die_compare_name (&dlink->die, lr->function) ==0 ) { +if (dwarf_tag (sp_die) == DW_TAG_subprogram && +die_compare_name (sp_die, lr->function) ==0 ) {/* Get the address range of this function */ - ret =dwarf_highpc (&dlink->die, &lf->addr_e); + ret =dwarf_highpc (sp_die, &lf->addr_e);if (ret ==0 ) - ret =dwarf_lowpc (&dlink->die, &lf->addr_s); + ret =dwarf_lowpc (sp_die, &lf->addr_s);if (ret !=0 ) { lf->addr_s =0 ; lf->addr_e =0 ; } - lf->fname =dwarf_decl_file (&dlink->die); -dwarf_decl_line (&dlink->die, &lr->offset); + lf->fname =dwarf_decl_file (sp_die); +dwarf_decl_line (sp_die, &lr->offset);pr_debug ("fname: %s, lineno:%d\n" , lf->fname, lr->offset); lf->lno_s = lr->offset + lr->start;if (!lr->end)
@@ -706,7 +616,7 @@ static int line_range_search_cb(struct die_link *dlink, void *data)static void find_line_range_by_func (struct line_finder *lf) { -search_die_from_children (&lf->cu_die, line_range_search_cb, lf); +dwarf_getfuncs (&lf->cu_die, line_range_search_cb, lf,0 ); }int find_line_range (int fd,struct line_range *lr)
tools/perf/util/probe-finder.h +0 -1
@@ -66,7 +66,6 @@ struct probe_finder {Dwarf_Addr addr;/* Address */ const char *fname;/* File name */ int lno;/* Line number */ -void *origin;/* Inline origin addr */ Dwarf_Die cu_die;/* Current CU */ /* For variable searching */
PATCH 16/18 perf probe: Check function address range strictly in line finder
In reply to Masami HiramatsuCheck (inlined) function address range strictly for improving output of probe-able lines of inline functions.
Without this change, perf probe --line <function> sometimes showed other inline function bodies too, because it didn't filter out inlined functions.
---
tools/perf/util/probe-finder.c | 74 +++++++++++++++++++++++++++++----------- tools/perf/util/probe-finder.h | 2 - 2 files changed, 53 insertions(+), 23 deletions(-)
tools/perf/util/probe-finder.c +53 -21
@@ -161,6 +161,31 @@ static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,return die_mem; } +/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */ +static Dwarf_Die *die_get_inlinefunc (Dwarf_Die *sp_die,Dwarf_Addr addr, +Dwarf_Die *die_mem) +{ +Dwarf_Die child_die; +int ret; + + ret =dwarf_child (sp_die, die_mem); +if (ret !=0 ) +return NULL ; + +do { +if (dwarf_tag (die_mem) == DW_TAG_inlined_subroutine && +dwarf_haspc (die_mem, addr)) +return die_mem; + +if (die_get_inlinefunc (die_mem, addr, &child_die)) { +memcpy (die_mem, &child_die,sizeof (Dwarf_Die)); +return die_mem; + } + }while (dwarf_siblingof (die_mem, die_mem) ==0 ); + +return NULL ; +} +/* Compare diename and tname */ static bool die_compare_name (Dwarf_Die *dw_die,const char *tname) {
@@ -534,7 +559,7 @@ found: }/* Find line range from its line number */ -static void find_line_range_by_line (struct line_finder *lf) +static void find_line_range_by_line (Dwarf_Die *sp_die,struct line_finder *lf) {Dwarf_Lines *lines;Dwarf_Line *line;
@@ -543,6 +568,7 @@ static void find_line_range_by_line(struct line_finder *lf)int lineno;int ret;const char *src; +Dwarf_Die die_mem;INIT_LIST_HEAD (&lf->lr->line_list); ret =dwarf_getsrclines (&lf->cu_die, &lines, &nlines);
@@ -550,22 +576,28 @@ static void find_line_range_by_line(struct line_finder *lf)for (i =0 ; i < nlines; i++) { line =dwarf_onesrcline (lines, i); -dwarf_lineno (line, &lineno); + ret =dwarf_lineno (line, &lineno); +DIE_IF (ret !=0 );if (lf->lno_s > lineno || lf->lno_e < lineno)continue ; +if (sp_die) { +/* Address filtering 1: does sp_die include addr? */ + ret =dwarf_lineaddr (line, &addr); +DIE_IF (ret !=0 ); +if (!dwarf_haspc (sp_die, addr)) +continue ; + +/* Address filtering 2: No child include addr? */ +if (die_get_inlinefunc (sp_die, addr, &die_mem)) +continue ; + } +/* TODO: Get fileno from line, but how? */ src =dwarf_linesrc (line,NULL ,NULL );if (strtailcmp (src, lf->fname) !=0 )continue ; -/* Filter line in the function address range */ -if (lf->addr_s && lf->addr_e) { - ret =dwarf_lineaddr (line, &addr); -DIE_IF (ret !=0 ); -if (lf->addr_s > addr || lf->addr_e <= addr) -continue ; - }/* Copy real path */ if (!lf->lr->path) lf->lr->path =strdup (src);
@@ -580,24 +612,20 @@ static void find_line_range_by_line(struct line_finder *lf) } } +static int line_range_inline_cb (Dwarf_Die *in_die,void *data) +{ +find_line_range_by_line (in_die, (struct line_finder *)data); +return DWARF_CB_ABORT ;/* No need to find other instances */ +} +/* Search function from function name */ static int line_range_search_cb (Dwarf_Die *sp_die,void *data) {struct line_finder *lf = (struct line_finder *)data;struct line_range *lr = lf->lr; -int ret;if (dwarf_tag (sp_die) == DW_TAG_subprogram &&die_compare_name (sp_die, lr->function) ==0 ) { -/* Get the address range of this function */ - ret =dwarf_highpc (sp_die, &lf->addr_e); -if (ret ==0 ) - ret =dwarf_lowpc (sp_die, &lf->addr_s); -if (ret !=0 ) { - lf->addr_s =0 ; - lf->addr_e =0 ; - } - lf->fname =dwarf_decl_file (sp_die);dwarf_decl_line (sp_die, &lr->offset);pr_debug ("fname: %s, lineno:%d\n" , lf->fname, lr->offset);
@@ -608,7 +636,11 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data) lf->lno_e = lr->offset + lr->end; lr->start = lf->lno_s; lr->end = lf->lno_e; -find_line_range_by_line (lf); +if (dwarf_func_inline (sp_die)) +dwarf_func_inline_instances (sp_die, + line_range_inline_cb, lf); +else +find_line_range_by_line (sp_die, lf);return 1 ; }return 0 ;
@@ -660,7 +692,7 @@ int find_line_range(int fd, struct line_range *lr) lf.lno_e =INT_MAX ; else lf.lno_e = lr->end; -find_line_range_by_line (&lf); +find_line_range_by_line (NULL , &lf); } } off = noff;
tools/perf/util/probe-finder.h +0 -2
@@ -82,8 +82,6 @@ struct line_finder {const char *fname;/* File name */ int lno_s;/* Start line number */ int lno_e;/* End line number */ -Dwarf_Addr addr_s;/* Start address */ -Dwarf_Addr addr_e;/* End address */ Dwarf_Die cu_die;/* Current CU */ int found; };
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Check function address range strictly in line finder
Commit-ID: 161a26b0c231b5d2e60e9c132fa360cd9dac4720 Gitweb: http://git.kernel.org/tip/161a26b0c231b5d2e60e9c132fa360cd9dac4720 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:35:57 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:29 +0100
perf probe: Check function address range strictly in line finder
Check (inlined) function address range strictly for improving output of probe-able lines of inline functions.
Without this change, perf probe --line <function> sometimes showed other inline function bodies too, because it didn't filter out inlined functions.
LKML-Reference: <[email protected]>
--- tools/perf/util/probe-finder.c | 74 ++++++++++++++++++++++++++++----------- tools/perf/util/probe-finder.h | 2 - 2 files changed, 53 insertions(+), 23 deletions(-)
tools/perf/util/probe-finder.c +53 -21
@@ -161,6 +161,31 @@ static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,return die_mem; } +/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */ +static Dwarf_Die *die_get_inlinefunc (Dwarf_Die *sp_die,Dwarf_Addr addr, +Dwarf_Die *die_mem) +{ +Dwarf_Die child_die; +int ret; + + ret =dwarf_child (sp_die, die_mem); +if (ret !=0 ) +return NULL ; + +do { +if (dwarf_tag (die_mem) == DW_TAG_inlined_subroutine && +dwarf_haspc (die_mem, addr)) +return die_mem; + +if (die_get_inlinefunc (die_mem, addr, &child_die)) { +memcpy (die_mem, &child_die,sizeof (Dwarf_Die)); +return die_mem; + } + }while (dwarf_siblingof (die_mem, die_mem) ==0 ); + +return NULL ; +} +/* Compare diename and tname */ static bool die_compare_name (Dwarf_Die *dw_die,const char *tname) {
@@ -534,7 +559,7 @@ found: }/* Find line range from its line number */ -static void find_line_range_by_line (struct line_finder *lf) +static void find_line_range_by_line (Dwarf_Die *sp_die,struct line_finder *lf) {Dwarf_Lines *lines;Dwarf_Line *line;
@@ -543,6 +568,7 @@ static void find_line_range_by_line(struct line_finder *lf)int lineno;int ret;const char *src; +Dwarf_Die die_mem;INIT_LIST_HEAD (&lf->lr->line_list); ret =dwarf_getsrclines (&lf->cu_die, &lines, &nlines);
@@ -550,22 +576,28 @@ static void find_line_range_by_line(struct line_finder *lf)for (i =0 ; i < nlines; i++) { line =dwarf_onesrcline (lines, i); -dwarf_lineno (line, &lineno); + ret =dwarf_lineno (line, &lineno); +DIE_IF (ret !=0 );if (lf->lno_s > lineno || lf->lno_e < lineno)continue ; +if (sp_die) { +/* Address filtering 1: does sp_die include addr? */ + ret =dwarf_lineaddr (line, &addr); +DIE_IF (ret !=0 ); +if (!dwarf_haspc (sp_die, addr)) +continue ; + +/* Address filtering 2: No child include addr? */ +if (die_get_inlinefunc (sp_die, addr, &die_mem)) +continue ; + } +/* TODO: Get fileno from line, but how? */ src =dwarf_linesrc (line,NULL ,NULL );if (strtailcmp (src, lf->fname) !=0 )continue ; -/* Filter line in the function address range */ -if (lf->addr_s && lf->addr_e) { - ret =dwarf_lineaddr (line, &addr); -DIE_IF (ret !=0 ); -if (lf->addr_s > addr || lf->addr_e <= addr) -continue ; - }/* Copy real path */ if (!lf->lr->path) lf->lr->path =strdup (src);
@@ -580,24 +612,20 @@ static void find_line_range_by_line(struct line_finder *lf) } } +static int line_range_inline_cb (Dwarf_Die *in_die,void *data) +{ +find_line_range_by_line (in_die, (struct line_finder *)data); +return DWARF_CB_ABORT ;/* No need to find other instances */ +} +/* Search function from function name */ static int line_range_search_cb (Dwarf_Die *sp_die,void *data) {struct line_finder *lf = (struct line_finder *)data;struct line_range *lr = lf->lr; -int ret;if (dwarf_tag (sp_die) == DW_TAG_subprogram &&die_compare_name (sp_die, lr->function) ==0 ) { -/* Get the address range of this function */ - ret =dwarf_highpc (sp_die, &lf->addr_e); -if (ret ==0 ) - ret =dwarf_lowpc (sp_die, &lf->addr_s); -if (ret !=0 ) { - lf->addr_s =0 ; - lf->addr_e =0 ; - } - lf->fname =dwarf_decl_file (sp_die);dwarf_decl_line (sp_die, &lr->offset);pr_debug ("fname: %s, lineno:%d\n" , lf->fname, lr->offset);
@@ -608,7 +636,11 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data) lf->lno_e = lr->offset + lr->end; lr->start = lf->lno_s; lr->end = lf->lno_e; -find_line_range_by_line (lf); +if (dwarf_func_inline (sp_die)) +dwarf_func_inline_instances (sp_die, + line_range_inline_cb, lf); +else +find_line_range_by_line (sp_die, lf);return 1 ; }return 0 ;
@@ -660,7 +692,7 @@ int find_line_range(int fd, struct line_range *lr) lf.lno_e =INT_MAX ; else lf.lno_e = lr->end; -find_line_range_by_line (&lf); +find_line_range_by_line (NULL , &lf); } } off = noff;
tools/perf/util/probe-finder.h +0 -2
@@ -82,8 +82,6 @@ struct line_finder {const char *fname;/* File name */ int lno_s;/* Start line number */ int lno_e;/* End line number */ -Dwarf_Addr addr_s;/* Start address */ -Dwarf_Addr addr_e;/* End address */ Dwarf_Die cu_die;/* Current CU */ int found; };
PATCH 17/18 perf probe: show more lines after last line
In reply to Masami HiramatsuShow 2 more lines after the last probe-able line. This will clearly show the last closed-brace of inline functions.
---
tools/perf/util/probe-event.c | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
tools/perf/util/probe-event.c +7 -0
@@ -718,6 +718,7 @@ void del_trace_kprobe_events(struct strlist *dellist) }#define LINEBUF_SIZE 256 +#define NR_ADDITIONAL_LINES 2static void show_one_line (FILE *fp,unsigned int l,bool skip,bool show_num) {
@@ -778,5 +779,11 @@ void show_line_range(struct line_range *lr)show_one_line (fp, (l++) - lr->offset, false, false);show_one_line (fp, (l++) - lr->offset, false, true); } + +if (lr->end ==INT_MAX ) + lr->end = l +NR_ADDITIONAL_LINES ; +while (l < lr->end && !feof (fp)) +show_one_line (fp, (l++) - lr->offset, false, false); +fclose (fp); }
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Show more lines after last line
Commit-ID: 5c8d1cbbbed39dcab2ecf429d6e56ea548c0fda4 Gitweb: http://git.kernel.org/tip/5c8d1cbbbed39dcab2ecf429d6e56ea548c0fda4 Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:36:04 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:30 +0100
perf probe: Show more lines after last line
Show 2 more lines after the last probe-able line. This will clearly show the last closed-brace of inline functions.
LKML-Reference: <[email protected]>
--- tools/perf/util/probe-event.c | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
tools/perf/util/probe-event.c +7 -0
@@ -716,6 +716,7 @@ void del_trace_kprobe_events(struct strlist *dellist) }#define LINEBUF_SIZE 256 +#define NR_ADDITIONAL_LINES 2static void show_one_line (FILE *fp,unsigned int l,bool skip,bool show_num) {
@@ -776,5 +777,11 @@ void show_line_range(struct line_range *lr)show_one_line (fp, (l++) - lr->offset, false, false);show_one_line (fp, (l++) - lr->offset, false, true); } + +if (lr->end ==INT_MAX ) + lr->end = l +NR_ADDITIONAL_LINES ; +while (l < lr->end && !feof (fp)) +show_one_line (fp, (l++) - lr->offset, false, false); +fclose (fp); }
PATCH 18/18 perf probe: Add lazy line matching support
In reply to Masami HiramatsuAdd lazy line matching support for specifying new probes. This also changes the syntax of perf probe a bit. Now perf probe accepts one of below probe event definitions.
1) Define event based on function name [EVENT=]FUNC[@SRC][:RLN|+OFF|%return|;PTN] [ARG ...]
2) Define event based on source file with line number [EVENT=]SRC:ALN [ARG ...]
3) Define event based on source file with lazy pattern [EVENT=]SRC;PTN [ARG ...]
- New lazy matching pattern(PTN) follows ';' (semicolon). And it must be put the end of the definition.
- So, @SRC is no longer the part which must be put at the end of the definition.
Note that ';' (semicolon) can be interpreted as the end of a command by the shell. This means that you need to quote it. (anyway you will need to quote the lazy pattern itself too, because it may contains other sensitive characters, like '[',']' etc.).
Lazy matching
-------------
The lazy line matching is similar to glob matching except ignoring spaces in both of pattern and target.
e.g.
'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.
This provides some sort of flexibility and robustness to probe point definitions against minor code changes. (for example, actual 10th line of schedule() can be changed
easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist.)
Changes in v3:
- Cast Dwarf_Addr to uintmax_t for printf-formats.
Changes in v2:
- Cast Dwarf_Addr to unsigned long long for printf-formats.
---
tools/perf/Documentation/perf-probe.txt | 30 +++- tools/perf/builtin-probe.c | 12 + tools/perf/util/probe-event.c | 48 ++++-- tools/perf/util/probe-finder.c | 249 ++++++++++++++++++++++++------- tools/perf/util/probe-finder.h | 2 tools/perf/util/string.c | 55 +++++-- tools/perf/util/string.h | 1 7 files changed, 298 insertions(+), 99 deletions(-)
tools/perf/Documentation/perf-probe.txt +27 -3
@@ -61,11 +61,19 @@ PROBE SYNTAX ------------ Probe points are defined by following syntax. - "[EVENT=]FUNC[+OFFS|:RLN|%return][@SRC]|SRC:ALN [ARG ...]" + 1) Define event based on function name + [EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...] + + 2) Define event based on source file with line number + [EVENT=]SRC:ALN [ARG ...] + + 3) Define event based on source file with lazy pattern + [EVENT=]SRC;PTN [ARG ...] + 'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'. -'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, 'RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. In addition, 'SRC' specifies a source file which has that function. -It is also possible to specify a probe point by the source line number by using 'SRC:ALN' syntax, where 'SRC' is the source file path and 'ALN' is the line number. +'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition. In addition, '@SRC' specifies a source file which has that function. +It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern. 'ARG' specifies the arguments of this probe point. You can use the name of local variable, or kprobe-tracer argument format (e.g. $retval, %ax, etc). LINE SYNTAX
@@ -81,6 +89,16 @@ and 'ALN2' is end line number in the file. It is also possible to specify how many lines to show by using 'NUM'. So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function. +LAZY MATCHING +------------- + The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]). + +e.g. + 'a=*' can matches 'a=b', 'a = b', 'a == b' and so on. + +This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.) + + EXAMPLES -------- Display which lines in schedule() can be probed:
@@ -95,6 +113,12 @@ Add a probe on schedule() function 12th line with recording cpu local variable: this will add one or more probes which has the name start with "schedule". + Add probes on lines in schedule() function which calls update_rq_clock(). + + ./perf probe 'schedule;update_rq_clock*' + or + ./perf probe --add='schedule;update_rq_clock*' + Delete all probes on schedule(). ./perf probe --del='schedule*'
tools/perf/builtin-probe.c +7 -5
@@ -175,22 +175,24 @@ static const struct option options[] = { opt_del_probe_event), OPT_CALLBACK('a', "add", NULL,#ifdef NO_DWARF_SUPPORT -"[EVENT=]FUNC[+OFFS|%return] [ARG ...]" , +"[EVENT=]FUNC[+OFF|%return] [ARG ...]" , #else -"[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]" , +"[EVENT=]FUNC[+OFF|%return|:RL|;PT][@SRC]|SRC:AL|SRC;PT" +" [ARG ...]" , #endif"probe point definition, where\n" "\t\tGROUP:\tGroup name (optional)\n" "\t\tEVENT:\tEvent name\n" "\t\tFUNC:\tFunction name\n" -"\t\tOFFS:\tOffset from function entry (in byte)\n" +"\t\tOFF:\tOffset from function entry (in byte)\n" "\t\t%return:\tPut the probe at function return\n" #ifdef NO_DWARF_SUPPORT "\t\tARG:\tProbe argument (only \n"#else "\t\tSRC:\tSource code path\n" -"\t\tRLN:\tRelative line number from function entry.\n" -"\t\tALN:\tAbsolute line number in file.\n" +"\t\tRL:\tRelative line number from function entry.\n" +"\t\tAL:\tAbsolute line number in file.\n" +"\t\tPT:\tLazy expression of line code.\n" "\t\tARG:\tProbe argument (local variable name or\n"#endif "\t\t\tkprobe-tracer argument format.)\n",
tools/perf/util/probe-event.c +30 -18
108 lines not on this page · raw message
tools/perf/util/probe-finder.c +189 -60
360 lines not on this page · raw message
tools/perf/util/probe-finder.h +2 -0
@@ -21,6 +21,7 @@ struct probe_point {/* Inputs */ char *file;/* File name */ int line;/* Line number */ +char *lazy_line;/* Lazy line pattern */ char *function;/* Function name */ int offset;/* Offset bytes */
@@ -74,6 +75,7 @@ struct probe_finder {const char *var;/* Current variable name */ char *buf;/* Current output buffer */ int len;/* Length of output buffer */ +struct list_head lcache;/* Line cache for lazy match */ };struct line_finder {
tools/perf/util/string.c +42 -13
66 lines not on this page · raw message
tools/perf/util/string.h +1 -0
@@ -10,6 +10,7 @@ s64 perf_atoll(const char *str);char **argv_split (const char *str,int *argcp);void argv_free (char **argv);bool strglobmatch (const char *str,const char *pat); +bool strlazymatch (const char *str,const char *pat);#define _STR (x) #x#define STR (x) _STR(x)
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America), Inc. Software Solutions Division e-mail: [email protected]
[tip:perf/probes] perf probe: Add lazy line matching support
Commit-ID: 2a9c8c36092de41c13fdd81fe59556915b080c3e Gitweb: http://git.kernel.org/tip/2a9c8c36092de41c13fdd81fe59556915b080c3e Author: Masami Hiramatsu <[email protected]> AuthorDate: Thu, 25 Feb 2010 08:36:12 -0500 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 25 Feb 2010 17:49:30 +0100
perf probe: Add lazy line matching support
Add lazy line matching support for specifying new probes. This also changes the syntax of perf probe a bit. Now perf probe accepts one of below probe event definitions.
1) Define event based on function name [EVENT=]FUNC[@SRC][:RLN|+OFF|%return|;PTN] [ARG ...]
2) Define event based on source file with line number [EVENT=]SRC:ALN [ARG ...]
3) Define event based on source file with lazy pattern [EVENT=]SRC;PTN [ARG ...]
- New lazy matching pattern(PTN) follows ';' (semicolon). And it must be put the end of the definition.
- So, @SRC is no longer the part which must be put at the end of the definition.
Note that ';' (semicolon) can be interpreted as the end of a command by the shell. This means that you need to quote it. (anyway you will need to quote the lazy pattern itself too, because it may contains other sensitive characters, like '[',']' etc.).
Lazy matching
-------------
The lazy line matching is similar to glob matching except ignoring spaces in both of pattern and target.
e.g.
'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.
This provides some sort of flexibility and robustness to probe point definitions against minor code changes. (for example, actual 10th line of schedule() can be changed
easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist.)
Changes in v3:
- Cast Dwarf_Addr to uintmax_t for printf-formats.
Changes in v2:
- Cast Dwarf_Addr to unsigned long long for printf-formats.
LKML-Reference: <[email protected]>
--- tools/perf/Documentation/perf-probe.txt | 30 ++++- tools/perf/builtin-probe.c | 12 +- tools/perf/util/probe-event.c | 48 ++++--- tools/perf/util/probe-finder.c | 249 +++++++++++++++++++++++-------- tools/perf/util/probe-finder.h | 2 + tools/perf/util/string.c | 55 +++++-- tools/perf/util/string.h | 1 + 7 files changed, 298 insertions(+), 99 deletions(-)
tools/perf/Documentation/perf-probe.txt +27 -3
@@ -61,11 +61,19 @@ PROBE SYNTAX ------------ Probe points are defined by following syntax. - "[EVENT=]FUNC[+OFFS|:RLN|%return][@SRC]|SRC:ALN [ARG ...]" + 1) Define event based on function name + [EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...] + + 2) Define event based on source file with line number + [EVENT=]SRC:ALN [ARG ...] + + 3) Define event based on source file with lazy pattern + [EVENT=]SRC;PTN [ARG ...] + 'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'. -'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, 'RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. In addition, 'SRC' specifies a source file which has that function. -It is also possible to specify a probe point by the source line number by using 'SRC:ALN' syntax, where 'SRC' is the source file path and 'ALN' is the line number. +'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition. In addition, '@SRC' specifies a source file which has that function. +It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern. 'ARG' specifies the arguments of this probe point. You can use the name of local variable, or kprobe-tracer argument format (e.g. $retval, %ax, etc). LINE SYNTAX
@@ -81,6 +89,16 @@ and 'ALN2' is end line number in the file. It is also possible to specify how many lines to show by using 'NUM'. So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function. +LAZY MATCHING +------------- + The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]). + +e.g. + 'a=*' can matches 'a=b', 'a = b', 'a == b' and so on. + +This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.) + + EXAMPLES -------- Display which lines in schedule() can be probed:
@@ -95,6 +113,12 @@ Add a probe on schedule() function 12th line with recording cpu local variable: this will add one or more probes which has the name start with "schedule". + Add probes on lines in schedule() function which calls update_rq_clock(). + + ./perf probe 'schedule;update_rq_clock*' + or + ./perf probe --add='schedule;update_rq_clock*' + Delete all probes on schedule(). ./perf probe --del='schedule*'
tools/perf/builtin-probe.c +7 -5
@@ -175,22 +175,24 @@ static const struct option options[] = { opt_del_probe_event), OPT_CALLBACK('a', "add", NULL,#ifdef NO_DWARF_SUPPORT -"[EVENT=]FUNC[+OFFS|%return] [ARG ...]" , +"[EVENT=]FUNC[+OFF|%return] [ARG ...]" , #else -"[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]" , +"[EVENT=]FUNC[+OFF|%return|:RL|;PT][@SRC]|SRC:AL|SRC;PT" +" [ARG ...]" , #endif"probe point definition, where\n" "\t\tGROUP:\tGroup name (optional)\n" "\t\tEVENT:\tEvent name\n" "\t\tFUNC:\tFunction name\n" -"\t\tOFFS:\tOffset from function entry (in byte)\n" +"\t\tOFF:\tOffset from function entry (in byte)\n" "\t\t%return:\tPut the probe at function return\n" #ifdef NO_DWARF_SUPPORT "\t\tARG:\tProbe argument (only \n"#else "\t\tSRC:\tSource code path\n" -"\t\tRLN:\tRelative line number from function entry.\n" -"\t\tALN:\tAbsolute line number in file.\n" +"\t\tRL:\tRelative line number from function entry.\n" +"\t\tAL:\tAbsolute line number in file.\n" +"\t\tPT:\tLazy expression of line code.\n" "\t\tARG:\tProbe argument (local variable name or\n"#endif "\t\t\tkprobe-tracer argument format.)\n",
tools/perf/util/probe-event.c +30 -18
108 lines not on this page · raw message
tools/perf/util/probe-finder.c +189 -60
360 lines not on this page · raw message
tools/perf/util/probe-finder.h +2 -0
@@ -21,6 +21,7 @@ struct probe_point {/* Inputs */ char *file;/* File name */ int line;/* Line number */ +char *lazy_line;/* Lazy line pattern */ char *function;/* Function name */ int offset;/* Offset bytes */
@@ -74,6 +75,7 @@ struct probe_finder {const char *var;/* Current variable name */ char *buf;/* Current output buffer */ int len;/* Length of output buffer */ +struct list_head lcache;/* Line cache for lazy match */ };struct line_finder {
tools/perf/util/string.c +42 -13
66 lines not on this page · raw message
tools/perf/util/string.h +1 -0
@@ -10,6 +10,7 @@ s64 perf_atoll(const char *str);char **argv_split (const char *str,int *argcp);void argv_free (char **argv);bool strglobmatch (const char *str,const char *pat); +bool strlazymatch (const char *str,const char *pat);#define _STR (x) #x#define STR (x) _STR(x)