![Prasanna S Panchamukhi](/assets/img/avatar_default.png)
In situations where a kprobes handler calls a routine which has a probe on it, then kprobes_handler() disarms the new probe forever. This patch removes the above limitation by temporarily disarming the new probe. When the another probe hits while handling the old probe, the kprobes_handler() saves previous kprobes state and handles the new probe without calling the new kprobes registered handlers. kprobe_post_handler() restores back the previous kprobes state and the normal execution continues. However on x86_64 architecture, re-rentrancy is provided only through pre_handler(). If a routine having probe is referenced through post_handler(), then the probes on that routine are disarmed forever, since the exception stack is gets changed after the processor single steps the instruction of the new probe. This patch includes generic changes to support temporary disarming on reentrancy of probes. Signed-of-by: Prasanna S Panchamukhi <prasanna@in.ibm.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
236 lines
7.3 KiB
C
236 lines
7.3 KiB
C
#ifndef _LINUX_KPROBES_H
|
|
#define _LINUX_KPROBES_H
|
|
/*
|
|
* Kernel Probes (KProbes)
|
|
* include/linux/kprobes.h
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* Copyright (C) IBM Corporation, 2002, 2004
|
|
*
|
|
* 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
|
|
* Probes initial implementation ( includes suggestions from
|
|
* Rusty Russell).
|
|
* 2004-July Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
|
|
* interface to access function arguments.
|
|
* 2005-May Hien Nguyen <hien@us.ibm.com> and Jim Keniston
|
|
* <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
|
|
* <prasanna@in.ibm.com> added function-return probes.
|
|
*/
|
|
#include <linux/config.h>
|
|
#include <linux/list.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/smp.h>
|
|
|
|
#include <asm/kprobes.h>
|
|
|
|
/* kprobe_status settings */
|
|
#define KPROBE_HIT_ACTIVE 0x00000001
|
|
#define KPROBE_HIT_SS 0x00000002
|
|
#define KPROBE_REENTER 0x00000004
|
|
#define KPROBE_HIT_SSDONE 0x00000008
|
|
|
|
struct kprobe;
|
|
struct pt_regs;
|
|
struct kretprobe;
|
|
struct kretprobe_instance;
|
|
typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
|
|
typedef int (*kprobe_break_handler_t) (struct kprobe *, struct pt_regs *);
|
|
typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
|
|
unsigned long flags);
|
|
typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
|
|
int trapnr);
|
|
typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
|
|
struct pt_regs *);
|
|
|
|
struct kprobe {
|
|
struct hlist_node hlist;
|
|
|
|
/* list of kprobes for multi-handler support */
|
|
struct list_head list;
|
|
|
|
/*count the number of times this probe was temporarily disarmed */
|
|
unsigned long nmissed;
|
|
|
|
/* location of the probe point */
|
|
kprobe_opcode_t *addr;
|
|
|
|
/* Called before addr is executed. */
|
|
kprobe_pre_handler_t pre_handler;
|
|
|
|
/* Called after addr is executed, unless... */
|
|
kprobe_post_handler_t post_handler;
|
|
|
|
/* ... called if executing addr causes a fault (eg. page fault).
|
|
* Return 1 if it handled fault, otherwise kernel will see it. */
|
|
kprobe_fault_handler_t fault_handler;
|
|
|
|
/* ... called if breakpoint trap occurs in probe handler.
|
|
* Return 1 if it handled break, otherwise kernel will see it. */
|
|
kprobe_break_handler_t break_handler;
|
|
|
|
/* Saved opcode (which has been replaced with breakpoint) */
|
|
kprobe_opcode_t opcode;
|
|
|
|
/* copy of the original instruction */
|
|
struct arch_specific_insn ainsn;
|
|
};
|
|
|
|
/*
|
|
* Special probe type that uses setjmp-longjmp type tricks to resume
|
|
* execution at a specified entry with a matching prototype corresponding
|
|
* to the probed function - a trick to enable arguments to become
|
|
* accessible seamlessly by probe handling logic.
|
|
* Note:
|
|
* Because of the way compilers allocate stack space for local variables
|
|
* etc upfront, regardless of sub-scopes within a function, this mirroring
|
|
* principle currently works only for probes placed on function entry points.
|
|
*/
|
|
struct jprobe {
|
|
struct kprobe kp;
|
|
kprobe_opcode_t *entry; /* probe handling code to jump to */
|
|
};
|
|
|
|
#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 -
|
|
* Note:
|
|
* User needs to provide a handler function, and initialize maxactive.
|
|
* maxactive - The maximum number of instances of the probed function that
|
|
* can be active concurrently.
|
|
* nmissed - tracks the number of times the probed function's return was
|
|
* ignored, due to maxactive being too low.
|
|
*
|
|
*/
|
|
struct kretprobe {
|
|
struct kprobe kp;
|
|
kretprobe_handler_t handler;
|
|
int maxactive;
|
|
int nmissed;
|
|
struct hlist_head free_instances;
|
|
struct hlist_head used_instances;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
#ifdef CONFIG_KPROBES
|
|
/* Locks kprobe: irq must be disabled */
|
|
void lock_kprobes(void);
|
|
void unlock_kprobes(void);
|
|
|
|
/* kprobe running now on this CPU? */
|
|
static inline int kprobe_running(void)
|
|
{
|
|
extern unsigned int kprobe_cpu;
|
|
return kprobe_cpu == smp_processor_id();
|
|
}
|
|
|
|
extern int arch_prepare_kprobe(struct kprobe *p);
|
|
extern void arch_copy_kprobe(struct kprobe *p);
|
|
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 void show_registers(struct pt_regs *regs);
|
|
|
|
/* Get the kprobe at this addr (if any). Must have called lock_kprobes */
|
|
struct kprobe *get_kprobe(void *addr);
|
|
struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
|
|
|
|
int register_kprobe(struct kprobe *p);
|
|
void unregister_kprobe(struct kprobe *p);
|
|
int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
|
|
int longjmp_break_handler(struct kprobe *, struct pt_regs *);
|
|
int register_jprobe(struct jprobe *p);
|
|
void unregister_jprobe(struct jprobe *p);
|
|
void jprobe_return(void);
|
|
|
|
int register_kretprobe(struct kretprobe *rp);
|
|
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);
|
|
#else /* CONFIG_KPROBES */
|
|
static inline int kprobe_running(void)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline int register_kprobe(struct kprobe *p)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
static inline void unregister_kprobe(struct kprobe *p)
|
|
{
|
|
}
|
|
static inline int register_jprobe(struct jprobe *p)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
static inline void unregister_jprobe(struct jprobe *p)
|
|
{
|
|
}
|
|
static inline void jprobe_return(void)
|
|
{
|
|
}
|
|
static inline int register_kretprobe(struct kretprobe *rp)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
static inline void unregister_kretprobe(struct kretprobe *rp)
|
|
{
|
|
}
|
|
static inline void kprobe_flush_task(struct task_struct *tk)
|
|
{
|
|
}
|
|
#endif /* CONFIG_KPROBES */
|
|
#endif /* _LINUX_KPROBES_H */
|