* [patch 1/5] [kprobes] Tweak to the function return probe design - take 2
2005-06-16 22:31 [patch 0/5] [kprobes] Tweak to the function return probe design - take 2 rusty.lynch
@ 2005-06-16 22:31 ` rusty.lynch
2005-06-16 22:31 ` [patch 2/5] " rusty.lynch
` (3 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: rusty.lynch @ 2005-06-16 22:31 UTC (permalink / raw)
To: akpm
Cc: systemtap, linux-ia64, linux-kernel, Hien Nguyen,
Prasanna S Panchamukhi, Andi Kleen, Ananth N Mavinakayanahalli,
linuxppc64-dev
[-- Attachment #1: kprobes-return-probes-redux-base.patch --]
[-- Type: text/plain, Size: 6334 bytes --]
This patch provides the architecture independant changes for the tweaks
to the function return probe design.
--rusty
signed-off-by: Rusty Lynch <Rusty.lynch@intel.com>
include/linux/kprobes.h | 28 ++-----------------
kernel/kprobes.c | 69 +++++++++++++-----------------------------------
2 files changed, 22 insertions(+), 75 deletions(-)
Index: linux-2.6.12-rc6/include/linux/kprobes.h
===================================================================
--- linux-2.6.12-rc6.orig/include/linux/kprobes.h
+++ linux-2.6.12-rc6/include/linux/kprobes.h
@@ -104,33 +104,12 @@ struct jprobe {
};
#ifdef ARCH_SUPPORTS_KRETPROBES
-extern int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs);
-extern void trampoline_post_handler(struct kprobe *p, struct pt_regs *regs,
- unsigned long flags);
-extern struct task_struct *arch_get_kprobe_task(void *ptr);
extern void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs);
-extern void arch_kprobe_flush_task(struct task_struct *tk);
#else /* ARCH_SUPPORTS_KRETPROBES */
-static inline void kretprobe_trampoline(void)
-{
-}
-static inline int trampoline_probe_handler(struct kprobe *p,
- struct pt_regs *regs)
-{
- return 0;
-}
-static inline void trampoline_post_handler(struct kprobe *p,
- struct pt_regs *regs, unsigned long flags)
-{
-}
static inline void arch_prepare_kretprobe(struct kretprobe *rp,
struct pt_regs *regs)
{
}
-static inline void arch_kprobe_flush_task(struct task_struct *tk)
-{
-}
-#define arch_get_kprobe_task(ptr) ((struct task_struct *)NULL)
#endif /* ARCH_SUPPORTS_KRETPROBES */
/*
* Function-return probe -
@@ -155,8 +134,8 @@ struct kretprobe_instance {
struct hlist_node uflist; /* either on free list or used list */
struct hlist_node hlist;
struct kretprobe *rp;
- void *ret_addr;
- void *stack_addr;
+ kprobe_opcode_t *ret_addr;
+ struct task_struct *task;
};
#ifdef CONFIG_KPROBES
@@ -176,6 +155,7 @@ extern void arch_copy_kprobe(struct kpro
extern void arch_arm_kprobe(struct kprobe *p);
extern void arch_disarm_kprobe(struct kprobe *p);
extern void arch_remove_kprobe(struct kprobe *p);
+extern int arch_init(void);
extern void show_registers(struct pt_regs *regs);
/* Get the kprobe at this addr (if any). Must have called lock_kprobes */
@@ -194,8 +174,6 @@ int register_kretprobe(struct kretprobe
void unregister_kretprobe(struct kretprobe *rp);
struct kretprobe_instance *get_free_rp_inst(struct kretprobe *rp);
-struct kretprobe_instance *get_rp_inst(void *sara);
-struct kretprobe_instance *get_rp_inst_tsk(struct task_struct *tk);
void add_rp_inst(struct kretprobe_instance *ri);
void kprobe_flush_task(struct task_struct *tk);
void recycle_rp_inst(struct kretprobe_instance *ri);
Index: linux-2.6.12-rc6/kernel/kprobes.c
===================================================================
--- linux-2.6.12-rc6.orig/kernel/kprobes.c
+++ linux-2.6.12-rc6/kernel/kprobes.c
@@ -138,12 +138,6 @@ static int aggr_break_handler(struct kpr
return 0;
}
-struct kprobe trampoline_p = {
- .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
- .pre_handler = trampoline_probe_handler,
- .post_handler = trampoline_post_handler
-};
-
struct kretprobe_instance *get_free_rp_inst(struct kretprobe *rp)
{
struct hlist_node *node;
@@ -162,35 +156,18 @@ struct kretprobe_instance *get_used_rp_i
return NULL;
}
-struct kretprobe_instance *get_rp_inst(void *sara)
-{
- struct hlist_head *head;
- struct hlist_node *node;
- struct task_struct *tsk;
- struct kretprobe_instance *ri;
-
- tsk = arch_get_kprobe_task(sara);
- head = &kretprobe_inst_table[hash_ptr(tsk, KPROBE_HASH_BITS)];
- hlist_for_each_entry(ri, node, head, hlist) {
- if (ri->stack_addr == sara)
- return ri;
- }
- return NULL;
-}
-
void add_rp_inst(struct kretprobe_instance *ri)
{
- struct task_struct *tsk;
/*
* Remove rp inst off the free list -
* Add it back when probed function returns
*/
hlist_del(&ri->uflist);
- tsk = arch_get_kprobe_task(ri->stack_addr);
+
/* Add rp inst onto table */
INIT_HLIST_NODE(&ri->hlist);
hlist_add_head(&ri->hlist,
- &kretprobe_inst_table[hash_ptr(tsk, KPROBE_HASH_BITS)]);
+ &kretprobe_inst_table[hash_ptr(ri->task, KPROBE_HASH_BITS)]);
/* Also add this rp inst to the used list. */
INIT_HLIST_NODE(&ri->uflist);
@@ -217,34 +194,25 @@ struct hlist_head * kretprobe_inst_table
return &kretprobe_inst_table[hash_ptr(tsk, KPROBE_HASH_BITS)];
}
-struct kretprobe_instance *get_rp_inst_tsk(struct task_struct *tk)
-{
- struct task_struct *tsk;
- struct hlist_head *head;
- struct hlist_node *node;
- struct kretprobe_instance *ri;
-
- head = &kretprobe_inst_table[hash_ptr(tk, KPROBE_HASH_BITS)];
-
- hlist_for_each_entry(ri, node, head, hlist) {
- tsk = arch_get_kprobe_task(ri->stack_addr);
- if (tsk == tk)
- return ri;
- }
- return NULL;
-}
-
/*
- * This function is called from do_exit or do_execv when task tk's stack is
- * about to be recycled. Recycle any function-return probe instances
- * associated with this task. These represent probed functions that have
- * been called but may never return.
+ * This function is called from exit_thread or flush_thread when task tk's
+ * stack is being recycled so that we can recycle any function-return probe
+ * instances associated with this task. These left over instances represent
+ * probed functions that have been called but will never return.
*/
void kprobe_flush_task(struct task_struct *tk)
{
+ struct kretprobe_instance *ri;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
unsigned long flags = 0;
+
spin_lock_irqsave(&kprobe_lock, flags);
- arch_kprobe_flush_task(tk);
+ head = kretprobe_inst_table_head(current);
+ hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+ if (ri->task == tk)
+ recycle_rp_inst(ri);
+ }
spin_unlock_irqrestore(&kprobe_lock, flags);
}
@@ -504,9 +472,10 @@ static int __init init_kprobes(void)
INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
}
- err = register_die_notifier(&kprobe_exceptions_nb);
- /* Register the trampoline probe for return probe */
- register_kprobe(&trampoline_p);
+ err = arch_init();
+ if (!err)
+ err = register_die_notifier(&kprobe_exceptions_nb);
+
return err;
}
--
^ permalink raw reply [flat|nested] 6+ messages in thread
* [patch 2/5] [kprobes] Tweak to the function return probe design - take 2
2005-06-16 22:31 [patch 0/5] [kprobes] Tweak to the function return probe design - take 2 rusty.lynch
2005-06-16 22:31 ` [patch 1/5] " rusty.lynch
@ 2005-06-16 22:31 ` rusty.lynch
2005-06-16 22:31 ` [patch 3/5] " rusty.lynch
` (2 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: rusty.lynch @ 2005-06-16 22:31 UTC (permalink / raw)
To: akpm
Cc: systemtap, linux-ia64, linux-kernel, Hien Nguyen,
Prasanna S Panchamukhi, Andi Kleen, Ananth N Mavinakayanahalli,
linuxppc64-dev
[-- Attachment #1: kprobes-return-probes-redux-i386.patch --]
[-- Type: text/plain, Size: 5542 bytes --]
The following patch contains the i386 specific changes for the new
return probe design.
signed-off-by: Rusty Lynch <Rusty.lynch@intel.com>
arch/i386/kernel/kprobes.c | 130 +++++++++++++++++++++++----------------------
1 files changed, 68 insertions(+), 62 deletions(-)
Index: linux-2.6.12-rc6-mm1/arch/i386/kernel/kprobes.c
===================================================================
--- linux-2.6.12-rc6-mm1.orig/arch/i386/kernel/kprobes.c
+++ linux-2.6.12-rc6-mm1/arch/i386/kernel/kprobes.c
@@ -127,48 +127,23 @@ static inline void prepare_singlestep(st
regs->eip = (unsigned long)&p->ainsn.insn;
}
-struct task_struct *arch_get_kprobe_task(void *ptr)
-{
- return ((struct thread_info *) (((unsigned long) ptr) &
- (~(THREAD_SIZE -1))))->task;
-}
-
void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs)
{
unsigned long *sara = (unsigned long *)®s->esp;
- struct kretprobe_instance *ri;
- static void *orig_ret_addr;
+ struct kretprobe_instance *ri;
- /*
- * Save the return address when the return probe hits
- * the first time, and use it to populate the (krprobe
- * instance)->ret_addr for subsequent return probes at
- * the same addrress since stack address would have
- * the kretprobe_trampoline by then.
- */
- if (((void*) *sara) != kretprobe_trampoline)
- orig_ret_addr = (void*) *sara;
+ if ((ri = get_free_rp_inst(rp)) != NULL) {
+ ri->rp = rp;
+ ri->task = current;
+ ri->ret_addr = (kprobe_opcode_t *) *sara;
- if ((ri = get_free_rp_inst(rp)) != NULL) {
- ri->rp = rp;
- ri->stack_addr = sara;
- ri->ret_addr = orig_ret_addr;
- add_rp_inst(ri);
/* Replace the return addr with trampoline addr */
*sara = (unsigned long) &kretprobe_trampoline;
- } else {
- rp->nmissed++;
- }
-}
-void arch_kprobe_flush_task(struct task_struct *tk)
-{
- struct kretprobe_instance *ri;
- while ((ri = get_rp_inst_tsk(tk)) != NULL) {
- *((unsigned long *)(ri->stack_addr)) =
- (unsigned long) ri->ret_addr;
- recycle_rp_inst(ri);
- }
+ add_rp_inst(ri);
+ } else {
+ rp->nmissed++;
+ }
}
/*
@@ -286,36 +261,59 @@ no_kprobe:
*/
int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
{
- struct task_struct *tsk;
- struct kretprobe_instance *ri;
- struct hlist_head *head;
- struct hlist_node *node;
- unsigned long *sara = ((unsigned long *) ®s->esp) - 1;
-
- tsk = arch_get_kprobe_task(sara);
- head = kretprobe_inst_table_head(tsk);
-
- hlist_for_each_entry(ri, node, head, hlist) {
- if (ri->stack_addr == sara && ri->rp) {
- if (ri->rp->handler)
- ri->rp->handler(ri, regs);
- }
- }
- return 0;
-}
+ struct kretprobe_instance *ri = NULL;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
+ unsigned long orig_ret_address = 0;
+ unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
-void trampoline_post_handler(struct kprobe *p, struct pt_regs *regs,
- unsigned long flags)
-{
- struct kretprobe_instance *ri;
- /* RA already popped */
- unsigned long *sara = ((unsigned long *)®s->esp) - 1;
+ head = kretprobe_inst_table_head(current);
+
+ /*
+ * It is possible to have multiple instances associated with a given
+ * task either because an multiple functions in the call path
+ * have a return probe installed on them, and/or more then one return
+ * return probe was registered for a target function.
+ *
+ * We can handle this because:
+ * - instances are always inserted at the head of the list
+ * - when multiple return probes are registered for the same
+ * function, the first instance's ret_addr will point to the
+ * real return address, and all the rest will point to
+ * kretprobe_trampoline
+ */
+ hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+ if (ri->task != current)
+ /* another task is sharing our hash bucket */
+ continue;
+
+ if (ri->rp && ri->rp->handler)
+ ri->rp->handler(ri, regs);
- while ((ri = get_rp_inst(sara))) {
- regs->eip = (unsigned long)ri->ret_addr;
+ orig_ret_address = (unsigned long)ri->ret_addr;
recycle_rp_inst(ri);
+
+ if (orig_ret_address != trampoline_address)
+ /*
+ * This is the real return address. Any other
+ * instances associated with this task are for
+ * other calls deeper on the call stack
+ */
+ break;
}
- regs->eflags &= ~TF_MASK;
+
+ BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+ regs->eip = orig_ret_address;
+
+ unlock_kprobes();
+ preempt_enable_no_resched();
+
+ /*
+ * By returning a non-zero value, we are telling
+ * kprobe_handler() that we have handled unlocking
+ * and re-enabling preemption.
+ */
+ return 1;
}
/*
@@ -403,8 +401,7 @@ static inline int post_kprobe_handler(st
current_kprobe->post_handler(current_kprobe, regs, 0);
}
- if (current_kprobe->post_handler != trampoline_post_handler)
- resume_execution(current_kprobe, regs);
+ resume_execution(current_kprobe, regs);
regs->eflags |= kprobe_saved_eflags;
/*Restore back the original saved kprobes variables and continue. */
@@ -534,3 +531,13 @@ int longjmp_break_handler(struct kprobe
}
return 0;
}
+
+static struct kprobe trampoline_p = {
+ .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
+ .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init(void)
+{
+ return register_kprobe(&trampoline_p);
+}
--
^ permalink raw reply [flat|nested] 6+ messages in thread
* [patch 3/5] [kprobes] Tweak to the function return probe design - take 2
2005-06-16 22:31 [patch 0/5] [kprobes] Tweak to the function return probe design - take 2 rusty.lynch
2005-06-16 22:31 ` [patch 1/5] " rusty.lynch
2005-06-16 22:31 ` [patch 2/5] " rusty.lynch
@ 2005-06-16 22:31 ` rusty.lynch
2005-06-16 22:31 ` [patch 4/5] " rusty.lynch
2005-06-16 22:31 ` [patch 5/5] " rusty.lynch
4 siblings, 0 replies; 6+ messages in thread
From: rusty.lynch @ 2005-06-16 22:31 UTC (permalink / raw)
To: akpm
Cc: systemtap, linux-ia64, linux-kernel, Hien Nguyen,
Prasanna S Panchamukhi, Andi Kleen, Ananth N Mavinakayanahalli,
linuxppc64-dev
[-- Attachment #1: kprobes-return-probes-redux-x86_64.patch --]
[-- Type: text/plain, Size: 5749 bytes --]
The following provides the x86_64 specific changes for the new
return probe design. Note that with this new design, the dependency
on calculating a pointer to the task off the stack pointer no longer
exist (resolving the problem of interruption stacks as pointed out
in the original feedback to this port.)
signed-off-by: Rusty Lynch <Rusty.lynch@intel.com>
arch/x86_64/kernel/kprobes.c | 131 ++++++++++++++++++++++---------------------
1 files changed, 69 insertions(+), 62 deletions(-)
Index: linux-2.6.12-rc6-mm1/arch/x86_64/kernel/kprobes.c
===================================================================
--- linux-2.6.12-rc6-mm1.orig/arch/x86_64/kernel/kprobes.c
+++ linux-2.6.12-rc6-mm1/arch/x86_64/kernel/kprobes.c
@@ -274,48 +274,23 @@ static void prepare_singlestep(struct kp
regs->rip = (unsigned long)p->ainsn.insn;
}
-struct task_struct *arch_get_kprobe_task(void *ptr)
-{
- return ((struct thread_info *) (((unsigned long) ptr) &
- (~(THREAD_SIZE -1))))->task;
-}
-
void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs)
{
unsigned long *sara = (unsigned long *)regs->rsp;
- struct kretprobe_instance *ri;
- static void *orig_ret_addr;
+ struct kretprobe_instance *ri;
- /*
- * Save the return address when the return probe hits
- * the first time, and use it to populate the (krprobe
- * instance)->ret_addr for subsequent return probes at
- * the same addrress since stack address would have
- * the kretprobe_trampoline by then.
- */
- if (((void*) *sara) != kretprobe_trampoline)
- orig_ret_addr = (void*) *sara;
+ if ((ri = get_free_rp_inst(rp)) != NULL) {
+ ri->rp = rp;
+ ri->task = current;
+ ri->ret_addr = (kprobe_opcode_t *) *sara;
- if ((ri = get_free_rp_inst(rp)) != NULL) {
- ri->rp = rp;
- ri->stack_addr = sara;
- ri->ret_addr = orig_ret_addr;
- add_rp_inst(ri);
/* Replace the return addr with trampoline addr */
*sara = (unsigned long) &kretprobe_trampoline;
- } else {
- rp->nmissed++;
- }
-}
-void arch_kprobe_flush_task(struct task_struct *tk)
-{
- struct kretprobe_instance *ri;
- while ((ri = get_rp_inst_tsk(tk)) != NULL) {
- *((unsigned long *)(ri->stack_addr)) =
- (unsigned long) ri->ret_addr;
- recycle_rp_inst(ri);
- }
+ add_rp_inst(ri);
+ } else {
+ rp->nmissed++;
+ }
}
/*
@@ -428,36 +403,59 @@ no_kprobe:
*/
int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
{
- struct task_struct *tsk;
- struct kretprobe_instance *ri;
- struct hlist_head *head;
- struct hlist_node *node;
- unsigned long *sara = (unsigned long *)regs->rsp - 1;
-
- tsk = arch_get_kprobe_task(sara);
- head = kretprobe_inst_table_head(tsk);
-
- hlist_for_each_entry(ri, node, head, hlist) {
- if (ri->stack_addr == sara && ri->rp) {
- if (ri->rp->handler)
- ri->rp->handler(ri, regs);
- }
- }
- return 0;
-}
+ struct kretprobe_instance *ri = NULL;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
+ unsigned long orig_ret_address = 0;
+ unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
-void trampoline_post_handler(struct kprobe *p, struct pt_regs *regs,
- unsigned long flags)
-{
- struct kretprobe_instance *ri;
- /* RA already popped */
- unsigned long *sara = ((unsigned long *)regs->rsp) - 1;
+ head = kretprobe_inst_table_head(current);
+
+ /*
+ * It is possible to have multiple instances associated with a given
+ * task either because an multiple functions in the call path
+ * have a return probe installed on them, and/or more then one return
+ * return probe was registered for a target function.
+ *
+ * We can handle this because:
+ * - instances are always inserted at the head of the list
+ * - when multiple return probes are registered for the same
+ * function, the first instance's ret_addr will point to the
+ * real return address, and all the rest will point to
+ * kretprobe_trampoline
+ */
+ hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+ if (ri->task != current)
+ /* another task is sharing our hash bucket */
+ continue;
+
+ if (ri->rp && ri->rp->handler)
+ ri->rp->handler(ri, regs);
- while ((ri = get_rp_inst(sara))) {
- regs->rip = (unsigned long)ri->ret_addr;
+ orig_ret_address = (unsigned long)ri->ret_addr;
recycle_rp_inst(ri);
+
+ if (orig_ret_address != trampoline_address)
+ /*
+ * This is the real return address. Any other
+ * instances associated with this task are for
+ * other calls deeper on the call stack
+ */
+ break;
}
- regs->eflags &= ~TF_MASK;
+
+ BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+ regs->rip = orig_ret_address;
+
+ unlock_kprobes();
+ preempt_enable_no_resched();
+
+ /*
+ * By returning a non-zero value, we are telling
+ * kprobe_handler() that we have handled unlocking
+ * and re-enabling preemption.
+ */
+ return 1;
}
/*
@@ -550,8 +548,7 @@ int post_kprobe_handler(struct pt_regs *
current_kprobe->post_handler(current_kprobe, regs, 0);
}
- if (current_kprobe->post_handler != trampoline_post_handler)
- resume_execution(current_kprobe, regs);
+ resume_execution(current_kprobe, regs);
regs->eflags |= kprobe_saved_rflags;
/* Restore the original saved kprobes variables and continue. */
@@ -790,3 +787,13 @@ static void free_insn_slot(kprobe_opcode
}
}
}
+
+static struct kprobe trampoline_p = {
+ .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
+ .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init(void)
+{
+ return register_kprobe(&trampoline_p);
+}
--
^ permalink raw reply [flat|nested] 6+ messages in thread
* [patch 4/5] [kprobes] Tweak to the function return probe design - take 2
2005-06-16 22:31 [patch 0/5] [kprobes] Tweak to the function return probe design - take 2 rusty.lynch
` (2 preceding siblings ...)
2005-06-16 22:31 ` [patch 3/5] " rusty.lynch
@ 2005-06-16 22:31 ` rusty.lynch
2005-06-16 22:31 ` [patch 5/5] " rusty.lynch
4 siblings, 0 replies; 6+ messages in thread
From: rusty.lynch @ 2005-06-16 22:31 UTC (permalink / raw)
To: akpm
Cc: systemtap, linux-ia64, linux-kernel, Hien Nguyen,
Prasanna S Panchamukhi, Andi Kleen, Ananth N Mavinakayanahalli,
linuxppc64-dev
[-- Attachment #1: kprobes-return-probes-redux-ia64.patch --]
[-- Type: text/plain, Size: 6975 bytes --]
The following patch implements function return probes for ia64 using
the revised design. With this new design we no longer need to do some
of the odd hacks previous required on the last ia64 return probe port
that I sent out for comments.
Note that this new implementation still does not resolve the problem noted
by Keith Owens where backtrace data is lost after a return probe is hit.
--rusty
signed-off-by: Rusty Lynch <Rusty.lynch@intel.com>
arch/ia64/kernel/kprobes.c | 103 ++++++++++++++++++++++++++++++++++++++++++++-
arch/ia64/kernel/process.c | 16 ++++++
include/asm-ia64/kprobes.h | 13 +++--
3 files changed, 125 insertions(+), 7 deletions(-)
Index: linux-2.6.12-rc6/arch/ia64/kernel/kprobes.c
===================================================================
--- linux-2.6.12-rc6.orig/arch/ia64/kernel/kprobes.c
+++ linux-2.6.12-rc6/arch/ia64/kernel/kprobes.c
@@ -290,6 +290,94 @@ static inline void set_current_kprobe(st
current_kprobe = p;
}
+static void kretprobe_trampoline(void)
+{
+}
+
+/*
+ * At this point the target function has been tricked into
+ * returning into our trampoline. Lookup the associated instance
+ * and then:
+ * - call the handler function
+ * - cleanup by marking the instance as unused
+ * - long jump back to the original return address
+ */
+int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
+{
+ struct kretprobe_instance *ri = NULL;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
+ unsigned long orig_ret_address = 0;
+ unsigned long trampoline_address =
+ ((struct fnptr *)kretprobe_trampoline)->ip;
+
+ head = kretprobe_inst_table_head(current);
+
+ /*
+ * It is possible to have multiple instances associated with a given
+ * task either because an multiple functions in the call path
+ * have a return probe installed on them, and/or more then one return
+ * return probe was registered for a target function.
+ *
+ * We can handle this because:
+ * - instances are always inserted at the head of the list
+ * - when multiple return probes are registered for the same
+ * function, the first instance's ret_addr will point to the
+ * real return address, and all the rest will point to
+ * kretprobe_trampoline
+ */
+ hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+ if (ri->task != current)
+ /* another task is sharing our hash bucket */
+ continue;
+
+ if (ri->rp && ri->rp->handler)
+ ri->rp->handler(ri, regs);
+
+ orig_ret_address = (unsigned long)ri->ret_addr;
+ recycle_rp_inst(ri);
+
+ if (orig_ret_address != trampoline_address)
+ /*
+ * This is the real return address. Any other
+ * instances associated with this task are for
+ * other calls deeper on the call stack
+ */
+ break;
+ }
+
+ BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+ regs->cr_iip = orig_ret_address;
+
+ unlock_kprobes();
+ preempt_enable_no_resched();
+
+ /*
+ * By returning a non-zero value, we are telling
+ * kprobe_handler() that we have handled unlocking
+ * and re-enabling preemption.
+ */
+ return 1;
+}
+
+void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs)
+{
+ struct kretprobe_instance *ri;
+
+ if ((ri = get_free_rp_inst(rp)) != NULL) {
+ ri->rp = rp;
+ ri->task = current;
+ ri->ret_addr = (kprobe_opcode_t *)regs->b0;
+
+ /* Replace the return addr with trampoline addr */
+ regs->b0 = ((struct fnptr *)kretprobe_trampoline)->ip;
+
+ add_rp_inst(ri);
+ } else {
+ rp->nmissed++;
+ }
+}
+
int arch_prepare_kprobe(struct kprobe *p)
{
unsigned long addr = (unsigned long) p->addr;
@@ -492,8 +580,8 @@ static int pre_kprobes_handler(struct di
if (p->pre_handler && p->pre_handler(p, regs))
/*
* Our pre-handler is specifically requesting that we just
- * do a return. This is handling the case where the
- * pre-handler is really our special jprobe pre-handler.
+ * do a return. This is used for both the jprobe pre-handler
+ * and the kretprobe trampoline
*/
return 1;
@@ -599,3 +687,14 @@ int longjmp_break_handler(struct kprobe
*regs = jprobe_saved_regs;
return 1;
}
+
+static struct kprobe trampoline_p = {
+ .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init(void)
+{
+ trampoline_p.addr =
+ (kprobe_opcode_t *)((struct fnptr *)kretprobe_trampoline)->ip;
+ return register_kprobe(&trampoline_p);
+}
Index: linux-2.6.12-rc6/include/asm-ia64/kprobes.h
===================================================================
--- linux-2.6.12-rc6.orig/include/asm-ia64/kprobes.h
+++ linux-2.6.12-rc6/include/asm-ia64/kprobes.h
@@ -63,6 +63,8 @@ typedef struct _bundle {
#define JPROBE_ENTRY(pentry) (kprobe_opcode_t *)pentry
+#define ARCH_SUPPORTS_KRETPROBES
+
#define SLOT0_OPCODE_SHIFT (37)
#define SLOT1_p1_OPCODE_SHIFT (37 - (64-46))
#define SLOT2_OPCODE_SHIFT (37)
@@ -94,11 +96,6 @@ struct arch_specific_insn {
};
/* ia64 does not need this */
-static inline void jprobe_return(void)
-{
-}
-
-/* ia64 does not need this */
static inline void arch_copy_kprobe(struct kprobe *p)
{
}
@@ -106,6 +103,12 @@ static inline void arch_copy_kprobe(stru
#ifdef CONFIG_KPROBES
extern int kprobe_exceptions_notify(struct notifier_block *self,
unsigned long val, void *data);
+
+/* ia64 does not need this */
+static inline void jprobe_return(void)
+{
+}
+
#else /* !CONFIG_KPROBES */
static inline int kprobe_exceptions_notify(struct notifier_block *self,
unsigned long val, void *data)
Index: linux-2.6.12-rc6/arch/ia64/kernel/process.c
===================================================================
--- linux-2.6.12-rc6.orig/arch/ia64/kernel/process.c
+++ linux-2.6.12-rc6/arch/ia64/kernel/process.c
@@ -27,6 +27,7 @@
#include <linux/efi.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
+#include <linux/kprobes.h>
#include <asm/cpu.h>
#include <asm/delay.h>
@@ -707,6 +708,13 @@ kernel_thread_helper (int (*fn)(void *),
void
flush_thread (void)
{
+ /*
+ * Remove function-return probe instances associated with this task
+ * and put them back on the free list. Do not insert an exit probe for
+ * this function, it will be disabled by kprobe_flush_task if you do.
+ */
+ kprobe_flush_task(current);
+
/* drop floating-point and debug-register state if it exists: */
current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
ia64_drop_fpu(current);
@@ -721,6 +729,14 @@ flush_thread (void)
void
exit_thread (void)
{
+
+ /*
+ * Remove function-return probe instances associated with this task
+ * and put them back on the free list. Do not insert an exit probe for
+ * this function, it will be disabled by kprobe_flush_task if you do.
+ */
+ kprobe_flush_task(current);
+
ia64_drop_fpu(current);
#ifdef CONFIG_PERFMON
/* if needed, stop monitoring and flush state to perfmon context */
--
^ permalink raw reply [flat|nested] 6+ messages in thread
* [patch 5/5] [kprobes] Tweak to the function return probe design - take 2
2005-06-16 22:31 [patch 0/5] [kprobes] Tweak to the function return probe design - take 2 rusty.lynch
` (3 preceding siblings ...)
2005-06-16 22:31 ` [patch 4/5] " rusty.lynch
@ 2005-06-16 22:31 ` rusty.lynch
4 siblings, 0 replies; 6+ messages in thread
From: rusty.lynch @ 2005-06-16 22:31 UTC (permalink / raw)
To: akpm
Cc: systemtap, linux-ia64, linux-kernel, Hien Nguyen,
Prasanna S Panchamukhi, Andi Kleen, Ananth N Mavinakayanahalli,
linuxppc64-dev
[-- Attachment #1: kprobes-return-probes-redux-ppc64.patch --]
[-- Type: text/plain, Size: 5872 bytes --]
The following is a patch provided by Ananth Mavinakayanahalli that implements
the new PPC64 specific parts of the new function return probe design.
NOTE: Since getting Ananth's patch, I changed trampoline_probe_handler()
to consume each of the outstanding return probem instances (feedback
on my original RFC after Ananth cut a patch), and also added the
arch_init() function (adding arch specific initialization.) I have
cross compiled but have not testing this on a PPC64 machine.
--rusty
signed-off-by: Rusty Lynch <Rusty.lynch@intel.com>
arch/ppc64/kernel/kprobes.c | 99 ++++++++++++++++++++++++++++++++++++++++++++
arch/ppc64/kernel/process.c | 4 +
include/asm-ppc64/kprobes.h | 3 +
3 files changed, 106 insertions(+)
Index: ppc64-2.6.12-rc6-mm1/arch/ppc64/kernel/kprobes.c
===================================================================
--- ppc64-2.6.12-rc6-mm1.orig/arch/ppc64/kernel/kprobes.c
+++ ppc64-2.6.12-rc6-mm1/arch/ppc64/kernel/kprobes.c
@@ -100,6 +100,23 @@ static inline void restore_previous_kpro
kprobe_saved_msr = kprobe_saved_msr_prev;
}
+void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs)
+{
+ struct kretprobe_instance *ri;
+
+ if ((ri = get_free_rp_inst(rp)) != NULL) {
+ ri->rp = rp;
+ ri->task = current;
+ ri->ret_addr = (kprobe_opcode_t *)regs->link;
+
+ /* Replace the return addr with trampoline addr */
+ regs->link = (unsigned long)kretprobe_trampoline;
+ add_rp_inst(ri);
+ } else {
+ rp->nmissed++;
+ }
+}
+
static inline int kprobe_handler(struct pt_regs *regs)
{
struct kprobe *p;
@@ -190,6 +207,78 @@ no_kprobe:
}
/*
+ * Function return probe trampoline:
+ * - init_kprobes() establishes a probepoint here
+ * - When the probed function returns, this probe
+ * causes the handlers to fire
+ */
+void kretprobe_trampoline_holder(void)
+{
+ asm volatile(".global kretprobe_trampoline\n"
+ "kretprobe_trampoline:\n"
+ "nop\n");
+}
+
+/*
+ * Called when the probe at kretprobe trampoline is hit
+ */
+int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
+{
+ struct kretprobe_instance *ri = NULL;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
+ unsigned long orig_ret_address = 0;
+ unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
+
+ head = kretprobe_inst_table_head(current);
+
+ /*
+ * It is possible to have multiple instances associated with a given
+ * task either because an multiple functions in the call path
+ * have a return probe installed on them, and/or more then one return
+ * return probe was registered for a target function.
+ *
+ * We can handle this because:
+ * - instances are always inserted at the head of the list
+ * - when multiple return probes are registered for the same
+ * function, the first instance's ret_addr will point to the
+ * real return address, and all the rest will point to
+ * kretprobe_trampoline
+ */
+ hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+ if (ri->task != current)
+ /* another task is sharing our hash bucket */
+ continue;
+
+ if (ri->rp && ri->rp->handler)
+ ri->rp->handler(ri, regs);
+
+ orig_ret_address = (unsigned long)ri->ret_addr;
+ recycle_rp_inst(ri);
+
+ if (orig_ret_address != trampoline_address)
+ /*
+ * This is the real return address. Any other
+ * instances associated with this task are for
+ * other calls deeper on the call stack
+ */
+ break;
+ }
+
+ BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+ regs->nip = orig_ret_address;
+
+ unlock_kprobes();
+
+ /*
+ * By returning a non-zero value, we are telling
+ * kprobe_handler() that we have handled unlocking
+ * and re-enabling preemption.
+ */
+ return 1;
+}
+
+/*
* Called after single-stepping. p->addr is the address of the
* instruction whose first byte has been replaced by the "breakpoint"
* instruction. To avoid the SMP problems that can occur when we
@@ -329,3 +418,13 @@ int longjmp_break_handler(struct kprobe
memcpy(regs, &jprobe_saved_regs, sizeof(struct pt_regs));
return 1;
}
+
+static struct kprobe trampoline_p = {
+ .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
+ .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init(void)
+{
+ return register_kprobe(&trampoline_p);
+}
Index: ppc64-2.6.12-rc6-mm1/arch/ppc64/kernel/process.c
===================================================================
--- ppc64-2.6.12-rc6-mm1.orig/arch/ppc64/kernel/process.c
+++ ppc64-2.6.12-rc6-mm1/arch/ppc64/kernel/process.c
@@ -37,6 +37,7 @@
#include <linux/interrupt.h>
#include <linux/utsname.h>
#include <linux/perfctr.h>
+#include <linux/kprobes.h>
#include <asm/pgtable.h>
#include <asm/uaccess.h>
@@ -310,6 +311,8 @@ void show_regs(struct pt_regs * regs)
void exit_thread(void)
{
+ kprobe_flush_task(current);
+
#ifndef CONFIG_SMP
if (last_task_used_math == current)
last_task_used_math = NULL;
@@ -325,6 +328,7 @@ void flush_thread(void)
{
struct thread_info *t = current_thread_info();
+ kprobe_flush_task(current);
if (t->flags & _TIF_ABI_PENDING)
t->flags ^= (_TIF_ABI_PENDING | _TIF_32BIT);
Index: ppc64-2.6.12-rc6-mm1/include/asm-ppc64/kprobes.h
===================================================================
--- ppc64-2.6.12-rc6-mm1.orig/include/asm-ppc64/kprobes.h
+++ ppc64-2.6.12-rc6-mm1/include/asm-ppc64/kprobes.h
@@ -42,6 +42,9 @@ typedef unsigned int kprobe_opcode_t;
#define JPROBE_ENTRY(pentry) (kprobe_opcode_t *)((func_descr_t *)pentry)
+#define ARCH_SUPPORTS_KRETPROBES
+void kretprobe_trampoline(void);
+
/* Architecture specific copy of original instruction */
struct arch_specific_insn {
/* copy of original instruction */
--
^ permalink raw reply [flat|nested] 6+ messages in thread