[linux.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

extern int __init init_hw_breakpoint(void);

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 int __init init_hw_breakpoint(void) { return 0; }

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
3c502e7a JW	36	extern int __init init_hw_breakpoint(void);
3c502e7a JW	37
dd1853c3 FW	38	static inline void hw_breakpoint_init(struct perf_event_attr *attr)
dd1853c3 FW	39	{
ed872d09 FW	40	memset(attr, 0, sizeof(*attr));
ed872d09 FW	41
dd1853c3 FW	42	attr->type = PERF_TYPE_BREAKPOINT;
dd1853c3 FW	43	attr->size = sizeof(*attr);
b326e956 FW	44	/*
	45	* As it's for in-kernel or ptrace use, we want it to be pinned
	46	* and to call its callback every hits.
	47	*/
dd1853c3	48	attr->pinned = 1;
b326e956	49	attr->sample_period = 1;
73266fc1 FW	50	}
	51
	52	static inline void ptrace_breakpoint_init(struct perf_event_attr *attr)
	53	{
	54	hw_breakpoint_init(attr);
	55	attr->exclude_kernel = 1;
dd1853c3 FW	56	}
dd1853c3 FW	57
24f1e32c FW	58	static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
	59	{
	60	return bp->attr.bp_addr;
	61	}
	62
	63	static inline int hw_breakpoint_type(struct perf_event *bp)
	64	{
	65	return bp->attr.bp_type;
	66	}
	67
cd757645	68	static inline unsigned long hw_breakpoint_len(struct perf_event *bp)
24f1e32c FW	69	{
	70	return bp->attr.bp_len;
	71	}
	72
24f1e32c	73	extern struct perf_event *
5fa10b28	74	register_user_hw_breakpoint(struct perf_event_attr *attr,
b326e956	75	perf_overflow_handler_t triggered,
5fa10b28	76	struct task_struct *tsk);
24f1e32c FW	77
24f1e32c FW	78	/* FIXME: only change from the attr, and don't unregister */
44234adc	79	extern int
2f0993e0	80	modify_user_hw_breakpoint(struct perf_event bp, struct perf_event_attr attr);
b332828c	81
b332828c P	82	/*
	83	* Kernel breakpoints are not associated with any particular thread.
	84	*/
24f1e32c	85	extern struct perf_event *
dd1853c3	86	register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
b326e956	87	perf_overflow_handler_t triggered,
dd1853c3	88	int cpu);
24f1e32c	89
44ee6358	90	extern struct perf_event * __percpu *
dd1853c3	91	register_wide_hw_breakpoint(struct perf_event_attr *attr,
b326e956	92	perf_overflow_handler_t triggered);
24f1e32c FW	93
	94	extern int register_perf_hw_breakpoint(struct perf_event *bp);
	95	extern int __register_perf_hw_breakpoint(struct perf_event *bp);
	96	extern void unregister_hw_breakpoint(struct perf_event *bp);
44ee6358	97	extern void unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events);
24f1e32c	98
5352ae63 JW	99	extern int dbg_reserve_bp_slot(struct perf_event *bp);
5352ae63 JW	100	extern int dbg_release_bp_slot(struct perf_event *bp);
24f1e32c FW	101	extern int reserve_bp_slot(struct perf_event *bp);
	102	extern void release_bp_slot(struct perf_event *bp);
	103
	104	extern void flush_ptrace_hw_breakpoint(struct task_struct *tsk);
	105
687b16fb FW	106	static inline struct arch_hw_breakpoint counter_arch_bp(struct perf_event bp)
	107	{
	108	return &bp->hw.info;
	109	}
	110
24f1e32c FW	111	#else /* !CONFIG_HAVE_HW_BREAKPOINT */
24f1e32c FW	112
3c502e7a JW	113	static inline int __init init_hw_breakpoint(void) { return 0; }
3c502e7a JW	114
24f1e32c	115	static inline struct perf_event *
5fa10b28	116	register_user_hw_breakpoint(struct perf_event_attr *attr,
b326e956	117	perf_overflow_handler_t triggered,
5fa10b28	118	struct task_struct *tsk) { return NULL; }
44234adc	119	static inline int
24f1e32c	120	modify_user_hw_breakpoint(struct perf_event *bp,
99ac64c8	121	struct perf_event_attr *attr) { return -ENOSYS; }
24f1e32c	122	static inline struct perf_event *
dd1853c3	123	register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
b326e956	124	perf_overflow_handler_t triggered,
dd1853c3	125	int cpu) { return NULL; }
44ee6358	126	static inline struct perf_event * __percpu *
dd1853c3	127	register_wide_hw_breakpoint(struct perf_event_attr *attr,
b326e956	128	perf_overflow_handler_t triggered) { return NULL; }
24f1e32c FW	129	static inline int
	130	register_perf_hw_breakpoint(struct perf_event *bp) { return -ENOSYS; }
	131	static inline int
	132	__register_perf_hw_breakpoint(struct perf_event *bp) { return -ENOSYS; }
	133	static inline void unregister_hw_breakpoint(struct perf_event *bp) { }
	134	static inline void
44ee6358	135	unregister_wide_hw_breakpoint(struct perf_event * __percpu *cpu_events) { }
24f1e32c FW	136	static inline int
	137	reserve_bp_slot(struct perf_event *bp) {return -ENOSYS; }
	138	static inline void release_bp_slot(struct perf_event *bp) { }
	139
	140	static inline void flush_ptrace_hw_breakpoint(struct task_struct *tsk) { }
b332828c	141
687b16fb FW	142	static inline struct arch_hw_breakpoint counter_arch_bp(struct perf_event bp)
	143	{
	144	return NULL;
	145	}
	146
24f1e32c	147	#endif /* CONFIG_HAVE_HW_BREAKPOINT */
5093ebad	148	#endif /* __KERNEL__ */
b332828c	149
24f1e32c	150	#endif /* _LINUX_HW_BREAKPOINT_H */