[net-next-2.6.git] / include / linux / hw_breakpoint.h

#ifndef _LINUX_HW_BREAKPOINT_H
#define _LINUX_HW_BREAKPOINT_H

enum {
	HW_BREAKPOINT_LEN_1 = 1,
	HW_BREAKPOINT_LEN_2 = 2,
	HW_BREAKPOINT_LEN_4 = 4,
	HW_BREAKPOINT_LEN_8 = 8,
};

enum {
	HW_BREAKPOINT_EMPTY	= 0,
	HW_BREAKPOINT_R		= 1,
	HW_BREAKPOINT_W		= 2,
	HW_BREAKPOINT_RW	= HW_BREAKPOINT_R | HW_BREAKPOINT_W,
	HW_BREAKPOINT_X		= 4,
	HW_BREAKPOINT_INVALID   = HW_BREAKPOINT_RW | HW_BREAKPOINT_X,
};

enum bp_type_idx {
	TYPE_INST 	= 0,
#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
	TYPE_DATA	= 0,
#else
	TYPE_DATA	= 1,
#endif
	TYPE_MAX
};

#ifdef __KERNEL__

#include <linux/perf_event.h>

#ifdef CONFIG_HAVE_HW_BREAKPOINT

static inline void hw_breakpoint_init(struct perf_event_attr *attr)
{
	memset(attr, 0, sizeof(*attr));

	attr->type = PERF_TYPE_BREAKPOINT;
	attr->size = sizeof(*attr);
	/*
	 * As it's for in-kernel or ptrace use, we want it to be pinned
	 * and to call its callback every hits.
	 */
	attr->pinned = 1;
	attr->sample_period = 1;
}

static inline void ptrace_breakpoint_init(struct perf_event_attr *attr)
{
	hw_breakpoint_init(attr);
	attr->exclude_kernel = 1;
}

static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
{
	return bp->attr.bp_addr;
}

static inline int hw_breakpoint_type(struct perf_event *bp)
{
	return bp->attr.bp_type;
}

static inline unsigned long hw_breakpoint_len(struct perf_event *bp)
{
	return bp->attr.bp_len;
}

extern struct perf_event *
register_user_hw_breakpoint(struct perf_event_attr *attr,
			    perf_overflow_handler_t triggered,
			    struct task_struct *tsk);

/* FIXME: only change from the attr, and don't unregister */
extern int
modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr);

/*
 * Kernel breakpoints are not associated with any particular thread.
 */
extern struct perf_event *
register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
				perf_overflow_handler_t	triggered,
				int cpu);

extern struct perf_event * __percpu *
register_wide_hw_breakpoint(struct perf_event_attr *attr,
			    perf_overflow_handler_t triggered);

extern int register_perf_hw_breakpoint(struct perf_event *bp);
extern int __register_perf_hw_breakpoint(struct perf_event *bp);
extern void unregister_hw_breakpoint(struct perf_event *bp);
extern void unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events);

extern int dbg_reserve_bp_slot(struct perf_event *bp);
extern int dbg_release_bp_slot(struct perf_event *bp);
extern int reserve_bp_slot(struct perf_event *bp);
extern void release_bp_slot(struct perf_event *bp);

extern void flush_ptrace_hw_breakpoint(struct task_struct *tsk);

static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
{
	return &bp->hw.info;
}

#else /* !CONFIG_HAVE_HW_BREAKPOINT */

static inline struct perf_event *
register_user_hw_breakpoint(struct perf_event_attr *attr,
			    perf_overflow_handler_t triggered,
			    struct task_struct *tsk)	{ return NULL; }
static inline int
modify_user_hw_breakpoint(struct perf_event *bp,
			  struct perf_event_attr *attr)	{ return -ENOSYS; }
static inline struct perf_event *
register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
				perf_overflow_handler_t	 triggered,
				int cpu)		{ return NULL; }
static inline struct perf_event * __percpu *
register_wide_hw_breakpoint(struct perf_event_attr *attr,
			    perf_overflow_handler_t triggered)	{ return NULL; }
static inline int
register_perf_hw_breakpoint(struct perf_event *bp)	{ return -ENOSYS; }
static inline int
__register_perf_hw_breakpoint(struct perf_event *bp) 	{ return -ENOSYS; }
static inline void unregister_hw_breakpoint(struct perf_event *bp)	{ }
static inline void
unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events)	{ }
static inline int
reserve_bp_slot(struct perf_event *bp)			{return -ENOSYS; }
static inline void release_bp_slot(struct perf_event *bp) 		{ }

static inline void flush_ptrace_hw_breakpoint(struct task_struct *tsk)	{ }

static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
{
	return NULL;
}

#endif /* CONFIG_HAVE_HW_BREAKPOINT */
#endif /* __KERNEL__ */

#endif /* _LINUX_HW_BREAKPOINT_H */
Commit	Line	Data
2da3e160 FW	1	#ifndef _LINUX_HW_BREAKPOINT_H
2da3e160 FW	2	#define _LINUX_HW_BREAKPOINT_H
b332828c	3
24f1e32c FW	4	enum {
	5	HW_BREAKPOINT_LEN_1 = 1,
	6	HW_BREAKPOINT_LEN_2 = 2,
	7	HW_BREAKPOINT_LEN_4 = 4,
	8	HW_BREAKPOINT_LEN_8 = 8,
b332828c P	9	};
b332828c P	10
24f1e32c	11	enum {
0102752e FW	12	HW_BREAKPOINT_EMPTY = 0,
	13	HW_BREAKPOINT_R = 1,
	14	HW_BREAKPOINT_W = 2,
	15	HW_BREAKPOINT_RW = HW_BREAKPOINT_R \| HW_BREAKPOINT_W,
	16	HW_BREAKPOINT_X = 4,
	17	HW_BREAKPOINT_INVALID = HW_BREAKPOINT_RW \| HW_BREAKPOINT_X,
24f1e32c FW	18	};
24f1e32c FW	19
feef47d0 FW	20	enum bp_type_idx {
	21	TYPE_INST = 0,
	22	#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
	23	TYPE_DATA = 0,
	24	#else
	25	TYPE_DATA = 1,
	26	#endif
	27	TYPE_MAX
	28	};
	29
5093ebad	30	#ifdef __KERNEL__
688bcaff	31
e6db4876 FW	32	#include <linux/perf_event.h>
e6db4876 FW	33
fa7c27ee FW	34	#ifdef CONFIG_HAVE_HW_BREAKPOINT
fa7c27ee FW	35
dd1853c3 FW	36	static inline void hw_breakpoint_init(struct perf_event_attr *attr)
dd1853c3 FW	37	{
ed872d09 FW	38	memset(attr, 0, sizeof(*attr));
ed872d09 FW	39
dd1853c3 FW	40	attr->type = PERF_TYPE_BREAKPOINT;
dd1853c3 FW	41	attr->size = sizeof(*attr);
b326e956 FW	42	/*
	43	* As it's for in-kernel or ptrace use, we want it to be pinned
	44	* and to call its callback every hits.
	45	*/
dd1853c3	46	attr->pinned = 1;
b326e956	47	attr->sample_period = 1;
73266fc1 FW	48	}
	49
	50	static inline void ptrace_breakpoint_init(struct perf_event_attr *attr)
	51	{
	52	hw_breakpoint_init(attr);
	53	attr->exclude_kernel = 1;
dd1853c3 FW	54	}
dd1853c3 FW	55
24f1e32c FW	56	static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
	57	{
	58	return bp->attr.bp_addr;
	59	}
	60
	61	static inline int hw_breakpoint_type(struct perf_event *bp)
	62	{
	63	return bp->attr.bp_type;
	64	}
	65
cd757645	66	static inline unsigned long hw_breakpoint_len(struct perf_event *bp)
24f1e32c FW	67	{
	68	return bp->attr.bp_len;
	69	}
	70
24f1e32c	71	extern struct perf_event *
5fa10b28	72	register_user_hw_breakpoint(struct perf_event_attr *attr,
b326e956	73	perf_overflow_handler_t triggered,
5fa10b28	74	struct task_struct *tsk);
24f1e32c FW	75
24f1e32c FW	76	/* FIXME: only change from the attr, and don't unregister */
44234adc	77	extern int
2f0993e0	78	modify_user_hw_breakpoint(struct perf_event bp, struct perf_event_attr attr);
b332828c	79
b332828c P	80	/*
	81	* Kernel breakpoints are not associated with any particular thread.
	82	*/
24f1e32c	83	extern struct perf_event *
dd1853c3	84	register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
b326e956	85	perf_overflow_handler_t triggered,
dd1853c3	86	int cpu);
24f1e32c	87
44ee6358	88	extern struct perf_event * __percpu *
dd1853c3	89	register_wide_hw_breakpoint(struct perf_event_attr *attr,
b326e956	90	perf_overflow_handler_t triggered);
24f1e32c FW	91
	92	extern int register_perf_hw_breakpoint(struct perf_event *bp);
	93	extern int __register_perf_hw_breakpoint(struct perf_event *bp);
	94	extern void unregister_hw_breakpoint(struct perf_event *bp);
44ee6358	95	extern void unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events);
24f1e32c	96
5352ae63 JW	97	extern int dbg_reserve_bp_slot(struct perf_event *bp);
5352ae63 JW	98	extern int dbg_release_bp_slot(struct perf_event *bp);
24f1e32c FW	99	extern int reserve_bp_slot(struct perf_event *bp);
	100	extern void release_bp_slot(struct perf_event *bp);
	101
	102	extern void flush_ptrace_hw_breakpoint(struct task_struct *tsk);
	103
687b16fb FW	104	static inline struct arch_hw_breakpoint counter_arch_bp(struct perf_event bp)
	105	{
	106	return &bp->hw.info;
	107	}
	108
24f1e32c FW	109	#else /* !CONFIG_HAVE_HW_BREAKPOINT */
	110
	111	static inline struct perf_event *
5fa10b28	112	register_user_hw_breakpoint(struct perf_event_attr *attr,
b326e956	113	perf_overflow_handler_t triggered,
5fa10b28	114	struct task_struct *tsk) { return NULL; }
44234adc	115	static inline int
24f1e32c	116	modify_user_hw_breakpoint(struct perf_event *bp,
99ac64c8	117	struct perf_event_attr *attr) { return -ENOSYS; }
24f1e32c	118	static inline struct perf_event *
dd1853c3	119	register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
b326e956	120	perf_overflow_handler_t triggered,
dd1853c3	121	int cpu) { return NULL; }
44ee6358	122	static inline struct perf_event * __percpu *
dd1853c3	123	register_wide_hw_breakpoint(struct perf_event_attr *attr,
b326e956	124	perf_overflow_handler_t triggered) { return NULL; }
24f1e32c FW	125	static inline int
	126	register_perf_hw_breakpoint(struct perf_event *bp) { return -ENOSYS; }
	127	static inline int
	128	__register_perf_hw_breakpoint(struct perf_event *bp) { return -ENOSYS; }
	129	static inline void unregister_hw_breakpoint(struct perf_event *bp) { }
	130	static inline void
44ee6358	131	unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events) { }
24f1e32c FW	132	static inline int
	133	reserve_bp_slot(struct perf_event *bp) {return -ENOSYS; }
	134	static inline void release_bp_slot(struct perf_event *bp) { }
	135
	136	static inline void flush_ptrace_hw_breakpoint(struct task_struct *tsk) { }
b332828c	137
687b16fb FW	138	static inline struct arch_hw_breakpoint counter_arch_bp(struct perf_event bp)
	139	{
	140	return NULL;
	141	}
	142
24f1e32c	143	#endif /* CONFIG_HAVE_HW_BREAKPOINT */
5093ebad	144	#endif /* __KERNEL__ */
b332828c	145
24f1e32c	146	#endif /* _LINUX_HW_BREAKPOINT_H */