hw-breakpoints: Use struct perf_event_attr to define user breakpoints
Subsystems (3)
PATCH 1/2 hw-breakpoints: Use struct perf_event_attr to define user breakpoints
In-kernel user breakpoints are created using functions in which we pass breakpoint parameters as individual variables: address, length and type.
Although it fits well for x86, this just does not scale across archictectures that may support this api later as these may have more or different needs. Pass in a perf_event_attr structure instead because it is meant to evolve as much as possible into a generic hardware breakpoint parameter structure.
--- arch/x86/kernel/ptrace.c | 74 +++++++++++++++++++--------------- include/linux/hw_breakpoint.h | 36 +++++++--------- kernel/hw_breakpoint.c | 87 ++++++++-------------------------------- 3 files changed, 75 insertions(+), 122 deletions(-)
arch/x86/kernel/ptrace.c +41 -33
@@ -593,6 +593,34 @@ static unsigned long ptrace_get_dr7(struct perf_event *bp[])return dr7; } +static struct perf_event * +ptrace_modify_breakpoint (struct perf_event *bp,int len,int type, +struct task_struct *tsk) +{ +int err; +int gen_len, gen_type; +DEFINE_BREAKPOINT_ATTR (attr); + +/* +* We shoud have at least an inactive breakpoint at this +* slot. It means the user is writing dr7 without having +* written the address register first +*/ +if (!bp) +return ERR_PTR (-EINVAL ); + + err =arch_bp_generic_fields (len, type, &gen_len, &gen_type); +if (err) +return ERR_PTR (err); + + attr = bp->attr; + attr.bp_len = gen_len; + attr.bp_type = gen_type; + attr.disabled =0 ; + +return modify_user_hw_breakpoint (bp, &attr, bp->callback, tsk); +} +/* * Handle ptrace writes to debug register 7. */
@@ -603,7 +631,6 @@ static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)int i, orig_ret =0 , rc =0 ;int enabled, second_pass =0 ;unsigned len, type; -int gen_len, gen_type;struct perf_event *bp; data &= ~DR_CONTROL_RESERVED ;
@@ -634,33 +661,12 @@ restore:continue ; } -/* -* We shoud have at least an inactive breakpoint at this -* slot. It means the user is writing dr7 without having -* written the address register first -*/ -if (!bp) { - rc = -EINVAL ; -break ; - } - - rc =arch_bp_generic_fields (len, type, &gen_len, &gen_type); -if (rc) -break ; - -/* -* This is a temporary thing as bp is unregistered/registered -* to simulate modification -*/ - bp =modify_user_hw_breakpoint (bp, bp->attr.bp_addr, gen_len, - gen_type, bp->callback, - tsk, true); - thread->ptrace_bps[i] =NULL ; + bp =ptrace_modify_breakpoint (bp, len, type, tsk);/* Incorrect bp, or we have a bug in bp API */ if (IS_ERR (bp)) { rc =PTR_ERR (bp); - bp =NULL ; + thread->ptrace_bps[i] =NULL ;break ; } thread->ptrace_bps[i] = bp;
@@ -707,24 +713,26 @@ static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr, {struct perf_event *bp;struct thread_struct *t = &tsk->thread; +DEFINE_BREAKPOINT_ATTR (attr);if (!t->ptrace_bps[nr]) {/* * Put stub len and type to register (reserve) an inactive but * correct bp */ - bp =register_user_hw_breakpoint (addr,HW_BREAKPOINT_LEN_1 , -HW_BREAKPOINT_W , - ptrace_triggered, tsk, - false); + attr.bp_addr = addr; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; + attr.bp_type =HW_BREAKPOINT_W ; + attr.disabled =1 ; + + bp =register_user_hw_breakpoint (&attr, ptrace_triggered, tsk); }else { bp = t->ptrace_bps[nr]; t->ptrace_bps[nr] =NULL ; - bp =modify_user_hw_breakpoint (bp, addr, bp->attr.bp_len, - bp->attr.bp_type, - bp->callback, - tsk, - bp->attr.disabled); + + attr = bp->attr; + attr.bp_addr = addr; + bp =modify_user_hw_breakpoint (bp, &attr, bp->callback, tsk); }/* * CHECKME: the previous code returned -EIO if the addr wasn't a
include/linux/hw_breakpoint.h +16 -20
@@ -20,6 +20,14 @@ enum {#ifdef CONFIG_HAVE_HW_BREAKPOINT +/* As it's for in-kernel or ptrace use, we want it to be pinned */ +#define DEFINE_BREAKPOINT_ATTR (name) \ +struct perf_event_attr name = { \ + .type = PERF_TYPE_BREAKPOINT, \ + .size = sizeof(name), \ + .pinned = 1, \ +}; +static inline unsigned long hw_breakpoint_addr (struct perf_event *bp) {return bp->attr.bp_addr;
@@ -36,22 +44,16 @@ static inline int hw_breakpoint_len(struct perf_event *bp) }extern struct perf_event * -register_user_hw_breakpoint (unsigned long addr, -int len, -int type, +register_user_hw_breakpoint (struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active); +struct task_struct *tsk);/* FIXME: only change from the attr, and don't unregister */ extern struct perf_event *modify_user_hw_breakpoint (struct perf_event *bp, -unsigned long addr, -int len, -int type, +struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active); +struct task_struct *tsk);/* * Kernel breakpoints are not associated with any particular thread.
@@ -89,20 +91,14 @@ static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)#else /* !CONFIG_HAVE_HW_BREAKPOINT */ static inline struct perf_event * -register_user_hw_breakpoint (unsigned long addr, -int len, -int type, +register_user_hw_breakpoint (struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active) {return NULL ; } +struct task_struct *tsk) {return NULL ; }static inline struct perf_event *modify_user_hw_breakpoint (struct perf_event *bp, -unsigned long addr, -int len, -int type, +struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active) {return NULL ; } +struct task_struct *tsk) {return NULL ; }static inline struct perf_event * register_wide_hw_breakpoint_cpu(unsigned long addr, int len,
kernel/hw_breakpoint.c +18 -69
124 lines not on this page · raw message
Signature · 1 line
1.6.2.3
PATCH 2/2 hw-breakpoints: Use struct perf_event_attr to define kernel breakpoints
Kernel breakpoints are created using functions in which we pass breakpoint parameters as individual variables: address, length and type.
Although it fits well for x86, this just does not scale across architectures that may support this api later as these may have more or different needs. Pass in a perf_event_attr structure instead because it is meant to evolve as much as possible into a generic hardware breakpoint parameter structure.
--- include/linux/hw_breakpoint.h | 35 +++++++++++-------------- kernel/hw_breakpoint.c | 35 +++---------------------- kernel/trace/trace_ksym.c | 42 ++++++++++++++---------------- samples/hw_breakpoint/data_breakpoint.c | 10 +++--- 4 files changed, 44 insertions(+), 78 deletions(-)
include/linux/hw_breakpoint.h +15 -20
@@ -28,6 +28,13 @@ struct perf_event_attr name = { \ .pinned = 1, \ }; +static inline void hw_breakpoint_init (struct perf_event_attr *attr) +{ + attr->type =PERF_TYPE_BREAKPOINT ; + attr->size =sizeof (*attr); + attr->pinned =1 ; +} +static inline unsigned long hw_breakpoint_addr (struct perf_event *bp) {return bp->attr.bp_addr;
@@ -59,19 +66,13 @@ modify_user_hw_breakpoint(struct perf_event *bp,* Kernel breakpoints are not associated with any particular thread. */ extern struct perf_event * -register_wide_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, +register_wide_hw_breakpoint_cpu (struct perf_event_attr *attr,perf_callback_t triggered, -int cpu, -bool active); +int cpu);extern struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active); +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered);extern int register_perf_hw_breakpoint (struct perf_event *bp);extern int __register_perf_hw_breakpoint (struct perf_event *bp);
@@ -100,18 +101,12 @@ modify_user_hw_breakpoint(struct perf_event *bp,perf_callback_t triggered, struct task_struct *tsk) { return NULL; }static inline struct perf_event * -register_wide_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, +register_wide_hw_breakpoint_cpu (struct perf_event_attr *attr,perf_callback_t triggered, -int cpu, -bool active) {return NULL ; } +int cpu) {return NULL ; }static inline struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active) {return NULL ; } +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered) {return NULL ; }static inline int register_perf_hw_breakpoint (struct perf_event *bp) {return -ENOSYS ; } static inline int
kernel/hw_breakpoint.c +4 -31
@@ -339,42 +339,16 @@ void unregister_hw_breakpoint(struct perf_event *bp) }EXPORT_SYMBOL_GPL (unregister_hw_breakpoint); -static struct perf_event * -register_kernel_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -int cpu, -bool active) -{ -DEFINE_BREAKPOINT_ATTR (attr); - - attr.bp_addr = addr; - attr.bp_len = len; - attr.bp_type = type; - -if (!active) - attr.disabled =1 ; - -return perf_event_create_kernel_counter (&attr, cpu,-1 , triggered); -} -/** * register_wide_hw_breakpoint - register a wide breakpoint in the kernel -* @addr: is the memory address that triggers the breakpoint -* @len: the length of the access to the memory (1 byte, 2 bytes etc...) -* @type: the type of the access to the memory (read/write/exec) +* @attr: breakpoint attributes * @triggered: callback to trigger when we hit the breakpoint -* @active: should we activate it while registering it * * @return a set of per_cpu pointers to perf events */ struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active) +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered) {struct perf_event **cpu_events, **pevent, *bp;long err;
@@ -386,8 +360,7 @@ register_wide_hw_breakpoint(unsigned long addr,for_each_possible_cpu (cpu) { pevent =per_cpu_ptr (cpu_events, cpu); - bp =register_kernel_hw_breakpoint_cpu (addr, len, type, - triggered, cpu, active); + bp =perf_event_create_kernel_counter (attr, cpu,-1 , triggered); *pevent = bp;
kernel/trace/trace_ksym.c +20 -22
98 lines not on this page · raw message
samples/hw_breakpoint/data_breakpoint.c +5 -5
@@ -51,13 +51,13 @@ static void sample_hbp_handler(struct perf_event *temp, void *data)static int __init hw_break_module_init (void ) {int ret; -unsigned long addr; +DEFINE_BREAKPOINT_ATTR (attr); - addr =kallsyms_lookup_name (ksym_name); + attr.bp_addr =kallsyms_lookup_name (ksym_name); + attr.bp_len =HW_BREAKPOINT_LEN_4 ; + attr.bp_type =HW_BREAKPOINT_W |HW_BREAKPOINT_R ; - sample_hbp =register_wide_hw_breakpoint (addr,HW_BREAKPOINT_LEN_4 , -HW_BREAKPOINT_W |HW_BREAKPOINT_R , - sample_hbp_handler, true); + sample_hbp =register_wide_hw_breakpoint (&attr, sample_hbp_handler);if (IS_ERR (sample_hbp)) { ret =PTR_ERR (sample_hbp); goto fail;
Signature · 1 line
1.6.2.3
[tip:perf/core] hw-breakpoints: Use struct perf_event_attr to define kernel breakpoints
Commit-ID: dd1853c3f493f6d22d9e5390b192a07b73d2ac0a Gitweb: http://git.kernel.org/tip/dd1853c3f493f6d22d9e5390b192a07b73d2ac0a Author: Frederic Weisbecker <[email protected]> AuthorDate: Fri, 27 Nov 2009 04:55:54 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 27 Nov 2009 06:22:59 +0100
hw-breakpoints: Use struct perf_event_attr to define kernel breakpoints
Kernel breakpoints are created using functions in which we pass breakpoint parameters as individual variables: address, length and type.
Although it fits well for x86, this just does not scale across architectures that may support this api later as these may have more or different needs. Pass in a perf_event_attr structure instead because it is meant to evolve as much as possible into a generic hardware breakpoint parameter structure.
LKML-Reference: <[email protected]>
--- include/linux/hw_breakpoint.h | 35 +++++++++++-------------- kernel/hw_breakpoint.c | 35 +++---------------------- kernel/trace/trace_ksym.c | 42 ++++++++++++++---------------- samples/hw_breakpoint/data_breakpoint.c | 10 +++--- 4 files changed, 44 insertions(+), 78 deletions(-)
include/linux/hw_breakpoint.h +15 -20
@@ -28,6 +28,13 @@ struct perf_event_attr name = { \ .pinned = 1, \ }; +static inline void hw_breakpoint_init (struct perf_event_attr *attr) +{ + attr->type =PERF_TYPE_BREAKPOINT ; + attr->size =sizeof (*attr); + attr->pinned =1 ; +} +static inline unsigned long hw_breakpoint_addr (struct perf_event *bp) {return bp->attr.bp_addr;
@@ -59,19 +66,13 @@ modify_user_hw_breakpoint(struct perf_event *bp,* Kernel breakpoints are not associated with any particular thread. */ extern struct perf_event * -register_wide_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, +register_wide_hw_breakpoint_cpu (struct perf_event_attr *attr,perf_callback_t triggered, -int cpu, -bool active); +int cpu);extern struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active); +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered);extern int register_perf_hw_breakpoint (struct perf_event *bp);extern int __register_perf_hw_breakpoint (struct perf_event *bp);
@@ -100,18 +101,12 @@ modify_user_hw_breakpoint(struct perf_event *bp,perf_callback_t triggered, struct task_struct *tsk) { return NULL; }static inline struct perf_event * -register_wide_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, +register_wide_hw_breakpoint_cpu (struct perf_event_attr *attr,perf_callback_t triggered, -int cpu, -bool active) {return NULL ; } +int cpu) {return NULL ; }static inline struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active) {return NULL ; } +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered) {return NULL ; }static inline int register_perf_hw_breakpoint (struct perf_event *bp) {return -ENOSYS ; } static inline int
kernel/hw_breakpoint.c +4 -31
@@ -339,42 +339,16 @@ void unregister_hw_breakpoint(struct perf_event *bp) }EXPORT_SYMBOL_GPL (unregister_hw_breakpoint); -static struct perf_event * -register_kernel_hw_breakpoint_cpu (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -int cpu, -bool active) -{ -DEFINE_BREAKPOINT_ATTR (attr); - - attr.bp_addr = addr; - attr.bp_len = len; - attr.bp_type = type; - -if (!active) - attr.disabled =1 ; - -return perf_event_create_kernel_counter (&attr, cpu,-1 , triggered); -} -/** * register_wide_hw_breakpoint - register a wide breakpoint in the kernel -* @addr: is the memory address that triggers the breakpoint -* @len: the length of the access to the memory (1 byte, 2 bytes etc...) -* @type: the type of the access to the memory (read/write/exec) +* @attr: breakpoint attributes * @triggered: callback to trigger when we hit the breakpoint -* @active: should we activate it while registering it * * @return a set of per_cpu pointers to perf events */ struct perf_event ** -register_wide_hw_breakpoint (unsigned long addr, -int len, -int type, -perf_callback_t triggered, -bool active) +register_wide_hw_breakpoint (struct perf_event_attr *attr, +perf_callback_t triggered) {struct perf_event **cpu_events, **pevent, *bp;long err;
@@ -386,8 +360,7 @@ register_wide_hw_breakpoint(unsigned long addr,for_each_possible_cpu (cpu) { pevent =per_cpu_ptr (cpu_events, cpu); - bp =register_kernel_hw_breakpoint_cpu (addr, len, type, - triggered, cpu, active); + bp =perf_event_create_kernel_counter (attr, cpu,-1 , triggered); *pevent = bp;
kernel/trace/trace_ksym.c +20 -22
98 lines not on this page · raw message
samples/hw_breakpoint/data_breakpoint.c +5 -5
@@ -51,13 +51,13 @@ static void sample_hbp_handler(struct perf_event *temp, void *data)static int __init hw_break_module_init (void ) {int ret; -unsigned long addr; +DEFINE_BREAKPOINT_ATTR (attr); - addr =kallsyms_lookup_name (ksym_name); + attr.bp_addr =kallsyms_lookup_name (ksym_name); + attr.bp_len =HW_BREAKPOINT_LEN_4 ; + attr.bp_type =HW_BREAKPOINT_W |HW_BREAKPOINT_R ; - sample_hbp =register_wide_hw_breakpoint (addr,HW_BREAKPOINT_LEN_4 , -HW_BREAKPOINT_W |HW_BREAKPOINT_R , - sample_hbp_handler, true); + sample_hbp =register_wide_hw_breakpoint (&attr, sample_hbp_handler);if (IS_ERR (sample_hbp)) { ret =PTR_ERR (sample_hbp); goto fail;
Commit-ID: 5fa10b28e57f94a90535cfeafe89dcee9f47d540 Gitweb: http://git.kernel.org/tip/5fa10b28e57f94a90535cfeafe89dcee9f47d540 Author: Frederic Weisbecker <[email protected]> AuthorDate: Fri, 27 Nov 2009 04:55:53 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 27 Nov 2009 06:22:58 +0100
hw-breakpoints: Use struct perf_event_attr to define user breakpoints
In-kernel user breakpoints are created using functions in which we pass breakpoint parameters as individual variables: address, length and type.
Although it fits well for x86, this just does not scale across archictectures that may support this api later as these may have more or different needs. Pass in a perf_event_attr structure instead because it is meant to evolve as much as possible into a generic hardware breakpoint parameter structure.
LKML-Reference: <[email protected]>
--- arch/x86/kernel/ptrace.c | 74 +++++++++++++++++++--------------- include/linux/hw_breakpoint.h | 36 +++++++--------- kernel/hw_breakpoint.c | 87 ++++++++-------------------------------- 3 files changed, 75 insertions(+), 122 deletions(-)
arch/x86/kernel/ptrace.c +41 -33
@@ -593,6 +593,34 @@ static unsigned long ptrace_get_dr7(struct perf_event *bp[])return dr7; } +static struct perf_event * +ptrace_modify_breakpoint (struct perf_event *bp,int len,int type, +struct task_struct *tsk) +{ +int err; +int gen_len, gen_type; +DEFINE_BREAKPOINT_ATTR (attr); + +/* +* We shoud have at least an inactive breakpoint at this +* slot. It means the user is writing dr7 without having +* written the address register first +*/ +if (!bp) +return ERR_PTR (-EINVAL ); + + err =arch_bp_generic_fields (len, type, &gen_len, &gen_type); +if (err) +return ERR_PTR (err); + + attr = bp->attr; + attr.bp_len = gen_len; + attr.bp_type = gen_type; + attr.disabled =0 ; + +return modify_user_hw_breakpoint (bp, &attr, bp->callback, tsk); +} +/* * Handle ptrace writes to debug register 7. */
@@ -603,7 +631,6 @@ static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)int i, orig_ret =0 , rc =0 ;int enabled, second_pass =0 ;unsigned len, type; -int gen_len, gen_type;struct perf_event *bp; data &= ~DR_CONTROL_RESERVED ;
@@ -634,33 +661,12 @@ restore:continue ; } -/* -* We shoud have at least an inactive breakpoint at this -* slot. It means the user is writing dr7 without having -* written the address register first -*/ -if (!bp) { - rc = -EINVAL ; -break ; - } - - rc =arch_bp_generic_fields (len, type, &gen_len, &gen_type); -if (rc) -break ; - -/* -* This is a temporary thing as bp is unregistered/registered -* to simulate modification -*/ - bp =modify_user_hw_breakpoint (bp, bp->attr.bp_addr, gen_len, - gen_type, bp->callback, - tsk, true); - thread->ptrace_bps[i] =NULL ; + bp =ptrace_modify_breakpoint (bp, len, type, tsk);/* Incorrect bp, or we have a bug in bp API */ if (IS_ERR (bp)) { rc =PTR_ERR (bp); - bp =NULL ; + thread->ptrace_bps[i] =NULL ;break ; } thread->ptrace_bps[i] = bp;
@@ -707,24 +713,26 @@ static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr, {struct perf_event *bp;struct thread_struct *t = &tsk->thread; +DEFINE_BREAKPOINT_ATTR (attr);if (!t->ptrace_bps[nr]) {/* * Put stub len and type to register (reserve) an inactive but * correct bp */ - bp =register_user_hw_breakpoint (addr,HW_BREAKPOINT_LEN_1 , -HW_BREAKPOINT_W , - ptrace_triggered, tsk, - false); + attr.bp_addr = addr; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; + attr.bp_type =HW_BREAKPOINT_W ; + attr.disabled =1 ; + + bp =register_user_hw_breakpoint (&attr, ptrace_triggered, tsk); }else { bp = t->ptrace_bps[nr]; t->ptrace_bps[nr] =NULL ; - bp =modify_user_hw_breakpoint (bp, addr, bp->attr.bp_len, - bp->attr.bp_type, - bp->callback, - tsk, - bp->attr.disabled); + + attr = bp->attr; + attr.bp_addr = addr; + bp =modify_user_hw_breakpoint (bp, &attr, bp->callback, tsk); }/* * CHECKME: the previous code returned -EIO if the addr wasn't a
include/linux/hw_breakpoint.h +16 -20
@@ -20,6 +20,14 @@ enum {#ifdef CONFIG_HAVE_HW_BREAKPOINT +/* As it's for in-kernel or ptrace use, we want it to be pinned */ +#define DEFINE_BREAKPOINT_ATTR (name) \ +struct perf_event_attr name = { \ + .type = PERF_TYPE_BREAKPOINT, \ + .size = sizeof(name), \ + .pinned = 1, \ +}; +static inline unsigned long hw_breakpoint_addr (struct perf_event *bp) {return bp->attr.bp_addr;
@@ -36,22 +44,16 @@ static inline int hw_breakpoint_len(struct perf_event *bp) }extern struct perf_event * -register_user_hw_breakpoint (unsigned long addr, -int len, -int type, +register_user_hw_breakpoint (struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active); +struct task_struct *tsk);/* FIXME: only change from the attr, and don't unregister */ extern struct perf_event *modify_user_hw_breakpoint (struct perf_event *bp, -unsigned long addr, -int len, -int type, +struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active); +struct task_struct *tsk);/* * Kernel breakpoints are not associated with any particular thread.
@@ -89,20 +91,14 @@ static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)#else /* !CONFIG_HAVE_HW_BREAKPOINT */ static inline struct perf_event * -register_user_hw_breakpoint (unsigned long addr, -int len, -int type, +register_user_hw_breakpoint (struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active) {return NULL ; } +struct task_struct *tsk) {return NULL ; }static inline struct perf_event *modify_user_hw_breakpoint (struct perf_event *bp, -unsigned long addr, -int len, -int type, +struct perf_event_attr *attr,perf_callback_t triggered, -struct task_struct *tsk, -bool active) {return NULL ; } +struct task_struct *tsk) {return NULL ; }static inline struct perf_event * register_wide_hw_breakpoint_cpu(unsigned long addr, int len,
kernel/hw_breakpoint.c +18 -69
124 lines not on this page · raw message
Quoted 10 lines · Frederic Weisbecker
In-kernel user breakpoints are created using functions in which we pass breakpoint parameters as individual variables: address, length and type.
Although it fits well for x86, this just does not scale across archictectures that may support this api later as these may have more or different needs. Pass in a
perf_event_attrstructure instead because it is meant to evolve as much as possible into a generic hardware breakpoint parameter structure.
I suspect this further needs cleanup. Taking a quick look at all the exported interfaces:
struct perf_event * register_user_hw_breakpoint(struct perf_event_attr *attr,
perf_callback_t triggered,
struct task_struct *tsk);
struct perf_event *
modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr,
perf_callback_t triggered,
struct task_struct *tsk);void unregister_hw_breakpoint(struct perf_event *bp);
struct perf_event ** register_wide_hw_breakpoint(struct perf_event_attr *attr,
perf_callback_t triggered);
void unregister_wide_hw_breakpoint(struct perf_event **cpu_events);
It could be further improved to make them more intuitive and symmetrical, for instance:
- Merge 'perf_callback_t triggered' with 'struct perf_event_attr' (it is very much an attribute of the breakpoint) (you may also want to rename 'triggered' to something else...which is a pending suggestion from the community - 'triggered' indicates a boolean datatype and not a callback).
- Make register_<> always return 'struct perf_event *' (just like how unregister_<> always returns 'void').
- Both unregister_hw_breakpoint() and unregister_wide_hw_breakpoint() can accept 'struct perf_event *' as parameters.
Would you also like to rename register_wide_hw_breakpoint() to register_kernel_hw_breakpoint() since a) It is used only for kernel-space requests b) If a per-cpu kernel-space counter is desired in future, register_wide_hw_breakpoint() name would shrink to register_hw_breakpoint() causing ambiguity (user or kernel?) and name-space collision.
Thanks,
K.Prasad
Quoted 20 lines · K.Prasad
I suspect this further needs cleanup. Taking a quick look at all the exported interfaces:
struct
perf_event* register_user_hw_breakpoint(structperf_event_attr*attr,perf_callback_t triggered, struct task_struct *tsk); struct perf_event * modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr, perf_callback_t triggered, struct task_struct *tsk);void
unregister_hw_breakpoint(struct perf_event *bp);struct
perf_event** register_wide_hw_breakpoint(structperf_event_attr*attr,perf_callback_t triggered);void
unregister_wide_hw_breakpoint(struct perf_event **cpu_events);
Quoted 8 lines
It could be further improved to make them more intuitive and symmetrical, for instance:
- Merge '
perf_callback_ttriggered' with 'structperf_event_attr' (it is very much an attribute of the breakpoint) (you may also want to rename 'triggered' to something else...which is a pending suggestion from the community - 'triggered' indicates a boolean datatype and not a callback).
The perf attributes need to be a user and kernel interface (it is a syscall parameter).
I don't we should expose what is supposed to be a kernel internal-only address to such user interface, while it's not needed for the user.
But yeah I can rename trigger to "callback" simply.
Note: it's nice to have reviews and suggestions like you do, it makes the things evolving, and I'll happily fix everything you reported (if I agreed with the idea) but feel free to also send patches, it will make it evolve faster :)
Quoted 2 lines
- Make register_<> always return 'struct
perf_event*' (just like how unregister_<> always returns 'void').
That's a bit hard in the case of wide breakpoints as we are maintaining a cpu array of breakpoints.
Quoted 2 lines
- Both
unregister_hw_breakpoint()andunregister_wide_hw_breakpoint()can accept 'structperf_event*' as parameters.
Same thing here.
Quoted 6 lines
Would you also like to rename
register_wide_hw_breakpoint()toregister_kernel_hw_breakpoint()since a) It is used only for kernel-space requests b) If a per-cpu kernel-space counter is desired in future,register_wide_hw_breakpoint()name would shrink toregister_hw_breakpoint()causing ambiguity (user or kernel?) and name-space collision.
Sure, I can rename it, unless you send a patch for that :)