| #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 <linux/percpu.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 |
| |
| /* Attach to insert probes on any functions which should be ignored*/ |
| #define __kprobes __attribute__((__section__(".kprobes.text"))) |
| |
| 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 */ |
| }; |
| |
| DECLARE_PER_CPU(struct kprobe *, current_kprobe); |
| DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk); |
| |
| #ifdef ARCH_SUPPORTS_KRETPROBES |
| extern void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs); |
| #else /* ARCH_SUPPORTS_KRETPROBES */ |
| static inline void arch_prepare_kretprobe(struct kretprobe *rp, |
| struct pt_regs *regs) |
| { |
| } |
| #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; |
| kprobe_opcode_t *ret_addr; |
| struct task_struct *task; |
| }; |
| |
| #ifdef CONFIG_KPROBES |
| /* Locks kprobe: irq must be disabled */ |
| void lock_kprobes(void); |
| void unlock_kprobes(void); |
| |
| 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 int arch_init_kprobes(void); |
| extern void show_registers(struct pt_regs *regs); |
| extern kprobe_opcode_t *get_insn_slot(void); |
| extern void free_insn_slot(kprobe_opcode_t *slot); |
| |
| /* 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); |
| |
| /* kprobe_running() will just return the current_kprobe on this CPU */ |
| static inline struct kprobe *kprobe_running(void) |
| { |
| return (__get_cpu_var(current_kprobe)); |
| } |
| |
| static inline void reset_current_kprobe(void) |
| { |
| __get_cpu_var(current_kprobe) = NULL; |
| } |
| |
| static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void) |
| { |
| return (&__get_cpu_var(kprobe_ctlblk)); |
| } |
| |
| 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); |
| 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 struct kprobe *kprobe_running(void) |
| { |
| return NULL; |
| } |
| 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 */ |