[deliverable/linux.git] / include / linux / kprobes.h

#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/linkage.h>
#include <linux/list.h>
#include <linux/notifier.h>
#include <linux/smp.h>
#include <linux/bug.h>
#include <linux/percpu.h>
#include <linux/spinlock.h>
#include <linux/rcupdate.h>
#include <linux/mutex.h>
#include <linux/ftrace.h>

#ifdef CONFIG_KPROBES
#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")))

#else /* CONFIG_KPROBES */
typedef int kprobe_opcode_t;
struct arch_specific_insn {
	int dummy;
};
#define __kprobes

#endif /* CONFIG_KPROBES */

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;

	/* Allow user to indicate symbol name of the probe point */
	const char *symbol_name;

	/* Offset into the symbol */
	unsigned int offset;

	/* 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;

	/*
	 * Indicates various status flags.
	 * Protected by kprobe_mutex after this kprobe is registered.
	 */
	u32 flags;
};

/* 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.
				   */
#define KPROBE_FLAG_FTRACE	8 /* probe is using ftrace */

/* Has this kprobe gone ? */
static inline int kprobe_gone(struct kprobe *p)
{
	return p->flags & KPROBE_FLAG_GONE;
}

/* Is this kprobe disabled ? */
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;
}

/* Is this kprobe uses ftrace ? */
static inline int kprobe_ftrace(struct kprobe *p)
{
	return p->flags & KPROBE_FLAG_FTRACE;
}

/*
 * 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;
	void *entry;	/* probe handling code to jump to */
};

/* For backward compatibility with old code using JPROBE_ENTRY() */
#define JPROBE_ENTRY(handler)	(handler)

/*
 * 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;
	kretprobe_handler_t entry_handler;
	int maxactive;
	int nmissed;
	size_t data_size;
	struct hlist_head free_instances;
	raw_spinlock_t lock;
};

struct kretprobe_instance {
	struct hlist_node hlist;
	struct kretprobe *rp;
	kprobe_opcode_t *ret_addr;
	struct task_struct *task;
	char data[0];
};

struct kretprobe_blackpoint {
	const char *name;
	void *addr;
};

struct kprobe_blackpoint {
	const char *name;
	unsigned long start_addr;
	unsigned long range;
};

#ifdef CONFIG_KPROBES
DECLARE_PER_CPU(struct kprobe *, current_kprobe);
DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);

/*
 * For #ifdef avoidance:
 */
static inline int kprobes_built_in(void)
{
	return 1;
}

#ifdef CONFIG_KRETPROBES
extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
				   struct pt_regs *regs);
extern int arch_trampoline_kprobe(struct kprobe *p);
#else /* CONFIG_KRETPROBES */
static inline void arch_prepare_kretprobe(struct kretprobe *rp,
					struct pt_regs *regs)
{
}
static inline int arch_trampoline_kprobe(struct kprobe *p)
{
	return 0;
}
#endif /* CONFIG_KRETPROBES */

extern struct kretprobe_blackpoint kretprobe_blacklist[];

static inline void kretprobe_assert(struct kretprobe_instance *ri,
	unsigned long orig_ret_address, unsigned long trampoline_address)
{
	if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
		printk("kretprobe BUG!: Processing kretprobe %p @ %p\n",
				ri->rp, ri->rp->kp.addr);
		BUG();
	}
}

#ifdef CONFIG_KPROBES_SANITY_TEST
extern int init_test_probes(void);
#else
static inline int init_test_probes(void)
{
	return 0;
}
#endif /* CONFIG_KPROBES_SANITY_TEST */

extern int arch_prepare_kprobe(struct kprobe *p);
extern void arch_arm_kprobe(struct kprobe *p);
extern void arch_disarm_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, 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 void arch_optimize_kprobes(struct list_head *oplist);
extern void arch_unoptimize_kprobes(struct list_head *oplist,
				    struct list_head *done_list);
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);

#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 */
#ifdef CONFIG_KPROBES_ON_FTRACE
extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
				  struct ftrace_ops *ops, struct pt_regs *regs);
extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
#endif


/* 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,
			 struct hlist_head **head, unsigned long *flags);
void kretprobe_hash_unlock(struct task_struct *tsk, unsigned long *flags);
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 (__this_cpu_read(current_kprobe));
}

static inline void reset_current_kprobe(void)
{
	__this_cpu_write(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 register_kprobes(struct kprobe **kps, int num);
void unregister_kprobes(struct kprobe **kps, int num);
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);
int register_jprobes(struct jprobe **jps, int num);
void unregister_jprobes(struct jprobe **jps, int num);
void jprobe_return(void);
unsigned long arch_deref_entry_point(void *);

int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
int register_kretprobes(struct kretprobe **rps, int num);
void unregister_kretprobes(struct kretprobe **rps, int num);

void kprobe_flush_task(struct task_struct *tk);
void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);

int disable_kprobe(struct kprobe *kp);
int enable_kprobe(struct kprobe *kp);

void dump_kprobe(struct kprobe *kp);

#else /* !CONFIG_KPROBES: */

static inline int kprobes_built_in(void)
{
	return 0;
}
static inline int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
{
	return 0;
}
static inline struct kprobe *get_kprobe(void *addr)
{
	return NULL;
}
static inline struct kprobe *kprobe_running(void)
{
	return NULL;
}
static inline int register_kprobe(struct kprobe *p)
{
	return -ENOSYS;
}
static inline int register_kprobes(struct kprobe **kps, int num)
{
	return -ENOSYS;
}
static inline void unregister_kprobe(struct kprobe *p)
{
}
static inline void unregister_kprobes(struct kprobe **kps, int num)
{
}
static inline int register_jprobe(struct jprobe *p)
{
	return -ENOSYS;
}
static inline int register_jprobes(struct jprobe **jps, int num)
{
	return -ENOSYS;
}
static inline void unregister_jprobe(struct jprobe *p)
{
}
static inline void unregister_jprobes(struct jprobe **jps, int num)
{
}
static inline void jprobe_return(void)
{
}
static inline int register_kretprobe(struct kretprobe *rp)
{
	return -ENOSYS;
}
static inline int register_kretprobes(struct kretprobe **rps, int num)
{
	return -ENOSYS;
}
static inline void unregister_kretprobe(struct kretprobe *rp)
{
}
static inline void unregister_kretprobes(struct kretprobe **rps, int num)
{
}
static inline void kprobe_flush_task(struct task_struct *tk)
{
}
static inline int disable_kprobe(struct kprobe *kp)
{
	return -ENOSYS;
}
static inline int enable_kprobe(struct kprobe *kp)
{
	return -ENOSYS;
}
#endif /* CONFIG_KPROBES */
static inline int disable_kretprobe(struct kretprobe *rp)
{
	return disable_kprobe(&rp->kp);
}
static inline int enable_kretprobe(struct kretprobe *rp)
{
	return enable_kprobe(&rp->kp);
}
static inline int disable_jprobe(struct jprobe *jp)
{
	return disable_kprobe(&jp->kp);
}
static inline int enable_jprobe(struct jprobe *jp)
{
	return enable_kprobe(&jp->kp);
}

#endif /* _LINUX_KPROBES_H */
Commit	Line	Data
	1	#ifndef _LINUX_KPROBES_H
	2	#define _LINUX_KPROBES_H
	3	/*
	4	* Kernel Probes (KProbes)
	5	* include/linux/kprobes.h
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	20	*
	21	* Copyright (C) IBM Corporation, 2002, 2004
	22	*
	23	* 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
	24	* Probes initial implementation ( includes suggestions from
	25	* Rusty Russell).
	26	* 2004-July Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
	27	* interface to access function arguments.
	28	* 2005-May Hien Nguyen <hien@us.ibm.com> and Jim Keniston
	29	* <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
	30	* <prasanna@in.ibm.com> added function-return probes.
	31	*/
	32	#include <linux/linkage.h>
	33	#include <linux/list.h>
	34	#include <linux/notifier.h>
	35	#include <linux/smp.h>
	36	#include <linux/bug.h>
	37	#include <linux/percpu.h>
	38	#include <linux/spinlock.h>
	39	#include <linux/rcupdate.h>
	40	#include <linux/mutex.h>
	41	#include <linux/ftrace.h>
	42
	43	#ifdef CONFIG_KPROBES
	44	#include <asm/kprobes.h>
	45
	46	/* kprobe_status settings */
	47	#define KPROBE_HIT_ACTIVE 0x00000001
	48	#define KPROBE_HIT_SS 0x00000002
	49	#define KPROBE_REENTER 0x00000004
	50	#define KPROBE_HIT_SSDONE 0x00000008
	51
	52	/* Attach to insert probes on any functions which should be ignored*/
	53	#define __kprobes __attribute__((__section__(".kprobes.text")))
	54
	55	#else /* CONFIG_KPROBES */
	56	typedef int kprobe_opcode_t;
	57	struct arch_specific_insn {
	58	int dummy;
	59	};
	60	#define __kprobes
	61
	62	#endif /* CONFIG_KPROBES */
	63
	64	struct kprobe;
	65	struct pt_regs;
	66	struct kretprobe;
	67	struct kretprobe_instance;
	68	typedef int (kprobe_pre_handler_t) (struct kprobe , struct pt_regs *);
	69	typedef int (kprobe_break_handler_t) (struct kprobe , struct pt_regs *);
	70	typedef void (kprobe_post_handler_t) (struct kprobe , struct pt_regs *,
	71	unsigned long flags);
	72	typedef int (kprobe_fault_handler_t) (struct kprobe , struct pt_regs *,
	73	int trapnr);
	74	typedef int (kretprobe_handler_t) (struct kretprobe_instance ,
	75	struct pt_regs *);
	76
	77	struct kprobe {
	78	struct hlist_node hlist;
	79
	80	/* list of kprobes for multi-handler support */
	81	struct list_head list;
	82
	83	/count the number of times this probe was temporarily disarmed /
	84	unsigned long nmissed;
	85
	86	/* location of the probe point */
	87	kprobe_opcode_t *addr;
	88
	89	/* Allow user to indicate symbol name of the probe point */
	90	const char *symbol_name;
	91
	92	/* Offset into the symbol */
	93	unsigned int offset;
	94
	95	/* Called before addr is executed. */
	96	kprobe_pre_handler_t pre_handler;
	97
	98	/* Called after addr is executed, unless... */
	99	kprobe_post_handler_t post_handler;
	100
	101	/*
	102	* ... called if executing addr causes a fault (eg. page fault).
	103	* Return 1 if it handled fault, otherwise kernel will see it.
	104	*/
	105	kprobe_fault_handler_t fault_handler;
	106
	107	/*
	108	* ... called if breakpoint trap occurs in probe handler.
	109	* Return 1 if it handled break, otherwise kernel will see it.
	110	*/
	111	kprobe_break_handler_t break_handler;
	112
	113	/* Saved opcode (which has been replaced with breakpoint) */
	114	kprobe_opcode_t opcode;
	115
	116	/* copy of the original instruction */
	117	struct arch_specific_insn ainsn;
	118
	119	/*
	120	* Indicates various status flags.
	121	* Protected by kprobe_mutex after this kprobe is registered.
	122	*/
	123	u32 flags;
	124	};
	125
	126	/* Kprobe status flags */
	127	#define KPROBE_FLAG_GONE 1 /* breakpoint has already gone */
	128	#define KPROBE_FLAG_DISABLED 2 /* probe is temporarily disabled */
	129	#define KPROBE_FLAG_OPTIMIZED 4 /*
	130	* probe is really optimized.
	131	* NOTE:
	132	* this flag is only for optimized_kprobe.
	133	*/
	134	#define KPROBE_FLAG_FTRACE 8 /* probe is using ftrace */
	135
	136	/* Has this kprobe gone ? */
	137	static inline int kprobe_gone(struct kprobe *p)
	138	{
	139	return p->flags & KPROBE_FLAG_GONE;
	140	}
	141
	142	/* Is this kprobe disabled ? */
	143	static inline int kprobe_disabled(struct kprobe *p)
	144	{
	145	return p->flags & (KPROBE_FLAG_DISABLED \| KPROBE_FLAG_GONE);
	146	}
	147
	148	/* Is this kprobe really running optimized path ? */
	149	static inline int kprobe_optimized(struct kprobe *p)
	150	{
	151	return p->flags & KPROBE_FLAG_OPTIMIZED;
	152	}
	153
	154	/* Is this kprobe uses ftrace ? */
	155	static inline int kprobe_ftrace(struct kprobe *p)
	156	{
	157	return p->flags & KPROBE_FLAG_FTRACE;
	158	}
	159
	160	/*
	161	* Special probe type that uses setjmp-longjmp type tricks to resume
	162	* execution at a specified entry with a matching prototype corresponding
	163	* to the probed function - a trick to enable arguments to become
	164	* accessible seamlessly by probe handling logic.
	165	* Note:
	166	* Because of the way compilers allocate stack space for local variables
	167	* etc upfront, regardless of sub-scopes within a function, this mirroring
	168	* principle currently works only for probes placed on function entry points.
	169	*/
	170	struct jprobe {
	171	struct kprobe kp;
	172	void entry; / probe handling code to jump to */
	173	};
	174
	175	/* For backward compatibility with old code using JPROBE_ENTRY() */
	176	#define JPROBE_ENTRY(handler) (handler)
	177
	178	/*
	179	* Function-return probe -
	180	* Note:
	181	* User needs to provide a handler function, and initialize maxactive.
	182	* maxactive - The maximum number of instances of the probed function that
	183	* can be active concurrently.
	184	* nmissed - tracks the number of times the probed function's return was
	185	* ignored, due to maxactive being too low.
	186	*
	187	*/
	188	struct kretprobe {
	189	struct kprobe kp;
	190	kretprobe_handler_t handler;
	191	kretprobe_handler_t entry_handler;
	192	int maxactive;
	193	int nmissed;
	194	size_t data_size;
	195	struct hlist_head free_instances;
	196	raw_spinlock_t lock;
	197	};
	198
	199	struct kretprobe_instance {
	200	struct hlist_node hlist;
	201	struct kretprobe *rp;
	202	kprobe_opcode_t *ret_addr;
	203	struct task_struct *task;
	204	char data[0];
	205	};
	206
	207	struct kretprobe_blackpoint {
	208	const char *name;
	209	void *addr;
	210	};
	211
	212	struct kprobe_blackpoint {
	213	const char *name;
	214	unsigned long start_addr;
	215	unsigned long range;
	216	};
	217
	218	#ifdef CONFIG_KPROBES
	219	DECLARE_PER_CPU(struct kprobe *, current_kprobe);
	220	DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
	221
	222	/*
	223	* For #ifdef avoidance:
	224	*/
	225	static inline int kprobes_built_in(void)
	226	{
	227	return 1;
	228	}
	229
	230	#ifdef CONFIG_KRETPROBES
	231	extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
	232	struct pt_regs *regs);
	233	extern int arch_trampoline_kprobe(struct kprobe *p);
	234	#else /* CONFIG_KRETPROBES */
	235	static inline void arch_prepare_kretprobe(struct kretprobe *rp,
	236	struct pt_regs *regs)
	237	{
	238	}
	239	static inline int arch_trampoline_kprobe(struct kprobe *p)
	240	{
	241	return 0;
	242	}
	243	#endif /* CONFIG_KRETPROBES */
	244
	245	extern struct kretprobe_blackpoint kretprobe_blacklist[];
	246
	247	static inline void kretprobe_assert(struct kretprobe_instance *ri,
	248	unsigned long orig_ret_address, unsigned long trampoline_address)
	249	{
	250	if (!orig_ret_address \|\| (orig_ret_address == trampoline_address)) {
	251	printk("kretprobe BUG!: Processing kretprobe %p @ %p\n",
	252	ri->rp, ri->rp->kp.addr);
	253	BUG();
	254	}
	255	}
	256
	257	#ifdef CONFIG_KPROBES_SANITY_TEST
	258	extern int init_test_probes(void);
	259	#else
	260	static inline int init_test_probes(void)
	261	{
	262	return 0;
	263	}
	264	#endif /* CONFIG_KPROBES_SANITY_TEST */
	265
	266	extern int arch_prepare_kprobe(struct kprobe *p);
	267	extern void arch_arm_kprobe(struct kprobe *p);
	268	extern void arch_disarm_kprobe(struct kprobe *p);
	269	extern int arch_init_kprobes(void);
	270	extern void show_registers(struct pt_regs *regs);
	271	extern kprobe_opcode_t *get_insn_slot(void);
	272	extern void free_insn_slot(kprobe_opcode_t *slot, int dirty);
	273	extern void kprobes_inc_nmissed_count(struct kprobe *p);
	274
	275	#ifdef CONFIG_OPTPROBES
	276	/*
	277	* Internal structure for direct jump optimized probe
	278	*/
	279	struct optimized_kprobe {
	280	struct kprobe kp;
	281	struct list_head list; /* list for optimizing queue */
	282	struct arch_optimized_insn optinsn;
	283	};
	284
	285	/* Architecture dependent functions for direct jump optimization */
	286	extern int arch_prepared_optinsn(struct arch_optimized_insn *optinsn);
	287	extern int arch_check_optimized_kprobe(struct optimized_kprobe *op);
	288	extern int arch_prepare_optimized_kprobe(struct optimized_kprobe *op);
	289	extern void arch_remove_optimized_kprobe(struct optimized_kprobe *op);
	290	extern void arch_optimize_kprobes(struct list_head *oplist);
	291	extern void arch_unoptimize_kprobes(struct list_head *oplist,
	292	struct list_head *done_list);
	293	extern void arch_unoptimize_kprobe(struct optimized_kprobe *op);
	294	extern kprobe_opcode_t *get_optinsn_slot(void);
	295	extern void free_optinsn_slot(kprobe_opcode_t *slot, int dirty);
	296	extern int arch_within_optimized_kprobe(struct optimized_kprobe *op,
	297	unsigned long addr);
	298
	299	extern void opt_pre_handler(struct kprobe p, struct pt_regs regs);
	300
	301	#ifdef CONFIG_SYSCTL
	302	extern int sysctl_kprobes_optimization;
	303	extern int proc_kprobes_optimization_handler(struct ctl_table *table,
	304	int write, void __user *buffer,
	305	size_t length, loff_t ppos);
	306	#endif
	307
	308	#endif /* CONFIG_OPTPROBES */
	309	#ifdef CONFIG_KPROBES_ON_FTRACE
	310	extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
	311	struct ftrace_ops ops, struct pt_regs regs);
	312	extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
	313	#endif
	314
	315
	316	/* Get the kprobe at this addr (if any) - called with preemption disabled */
	317	struct kprobe get_kprobe(void addr);
	318	void kretprobe_hash_lock(struct task_struct *tsk,
	319	struct hlist_head *head, unsigned long flags);
	320	void kretprobe_hash_unlock(struct task_struct tsk, unsigned long flags);
	321	struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
	322
	323	/* kprobe_running() will just return the current_kprobe on this CPU */
	324	static inline struct kprobe *kprobe_running(void)
	325	{
	326	return (__this_cpu_read(current_kprobe));
	327	}
	328
	329	static inline void reset_current_kprobe(void)
	330	{
	331	__this_cpu_write(current_kprobe, NULL);
	332	}
	333
	334	static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
	335	{
	336	return (&__get_cpu_var(kprobe_ctlblk));
	337	}
	338
	339	int register_kprobe(struct kprobe *p);
	340	void unregister_kprobe(struct kprobe *p);
	341	int register_kprobes(struct kprobe **kps, int num);
	342	void unregister_kprobes(struct kprobe **kps, int num);
	343	int setjmp_pre_handler(struct kprobe , struct pt_regs );
	344	int longjmp_break_handler(struct kprobe , struct pt_regs );
	345	int register_jprobe(struct jprobe *p);
	346	void unregister_jprobe(struct jprobe *p);
	347	int register_jprobes(struct jprobe **jps, int num);
	348	void unregister_jprobes(struct jprobe **jps, int num);
	349	void jprobe_return(void);
	350	unsigned long arch_deref_entry_point(void *);
	351
	352	int register_kretprobe(struct kretprobe *rp);
	353	void unregister_kretprobe(struct kretprobe *rp);
	354	int register_kretprobes(struct kretprobe **rps, int num);
	355	void unregister_kretprobes(struct kretprobe **rps, int num);
	356
	357	void kprobe_flush_task(struct task_struct *tk);
	358	void recycle_rp_inst(struct kretprobe_instance ri, struct hlist_head head);
	359
	360	int disable_kprobe(struct kprobe *kp);
	361	int enable_kprobe(struct kprobe *kp);
	362
	363	void dump_kprobe(struct kprobe *kp);
	364
	365	#else /* !CONFIG_KPROBES: */
	366
	367	static inline int kprobes_built_in(void)
	368	{
	369	return 0;
	370	}
	371	static inline int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
	372	{
	373	return 0;
	374	}
	375	static inline struct kprobe get_kprobe(void addr)
	376	{
	377	return NULL;
	378	}
	379	static inline struct kprobe *kprobe_running(void)
	380	{
	381	return NULL;
	382	}
	383	static inline int register_kprobe(struct kprobe *p)
	384	{
	385	return -ENOSYS;
	386	}
	387	static inline int register_kprobes(struct kprobe **kps, int num)
	388	{
	389	return -ENOSYS;
	390	}
	391	static inline void unregister_kprobe(struct kprobe *p)
	392	{
	393	}
	394	static inline void unregister_kprobes(struct kprobe **kps, int num)
	395	{
	396	}
	397	static inline int register_jprobe(struct jprobe *p)
	398	{
	399	return -ENOSYS;
	400	}
	401	static inline int register_jprobes(struct jprobe **jps, int num)
	402	{
	403	return -ENOSYS;
	404	}
	405	static inline void unregister_jprobe(struct jprobe *p)
	406	{
	407	}
	408	static inline void unregister_jprobes(struct jprobe **jps, int num)
	409	{
	410	}
	411	static inline void jprobe_return(void)
	412	{
	413	}
	414	static inline int register_kretprobe(struct kretprobe *rp)
	415	{
	416	return -ENOSYS;
	417	}
	418	static inline int register_kretprobes(struct kretprobe **rps, int num)
	419	{
	420	return -ENOSYS;
	421	}
	422	static inline void unregister_kretprobe(struct kretprobe *rp)
	423	{
	424	}
	425	static inline void unregister_kretprobes(struct kretprobe **rps, int num)
	426	{
	427	}
	428	static inline void kprobe_flush_task(struct task_struct *tk)
	429	{
	430	}
	431	static inline int disable_kprobe(struct kprobe *kp)
	432	{
	433	return -ENOSYS;
	434	}
	435	static inline int enable_kprobe(struct kprobe *kp)
	436	{
	437	return -ENOSYS;
	438	}
	439	#endif /* CONFIG_KPROBES */
	440	static inline int disable_kretprobe(struct kretprobe *rp)
	441	{
	442	return disable_kprobe(&rp->kp);
	443	}
	444	static inline int enable_kretprobe(struct kretprobe *rp)
	445	{
	446	return enable_kprobe(&rp->kp);
	447	}
	448	static inline int disable_jprobe(struct jprobe *jp)
	449	{
	450	return disable_kprobe(&jp->kp);
	451	}
	452	static inline int enable_jprobe(struct jprobe *jp)
	453	{
	454	return enable_kprobe(&jp->kp);
	455	}
	456
	457	#endif /* _LINUX_KPROBES_H */