PPC64-HWBKPT: Implement hw-breakpoints for PowerPC Book III S
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/4 Allow arch-specific cleanup before breakpoint unregistration
Certain architectures (such as PowerPC Book III S) have a need to cleanup data-structures before the breakpoint is unregistered. This patch introduces an arch-specific hook in release_bp_slot() along with a weak definition in the form of a stub funciton.
--- kernel/hw_breakpoint.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
kernel/hw_breakpoint.c +12 -0
@@ -242,6 +242,17 @@ toggle_bp_slot(struct perf_event *bp, bo }/* +* Function to perform processor-specific cleanup during unregistration +*/ +__weak void arch_unregister_hw_breakpoint (struct perf_event *bp) +{ +/* +* A weak stub function here for those archs that don't define +* it inside arch/.../kernel/hw_breakpoint.c +*/ +} + +/* * Contraints to check before allowing this new breakpoint counter: * * == Non-pinned counter == (Considered as pinned for now)
@@ -339,6 +350,7 @@ void release_bp_slot(struct perf_event * {mutex_lock (&nr_bp_mutex); +arch_unregister_hw_breakpoint (bp);__release_bp_slot (bp);mutex_unlock (&nr_bp_mutex);
PATCH 2/4 PPC64-HWBKPT: Implement hw-breakpoints for PowerPC Book III S
In reply to a message not in the archiveImplement perf-events based hw-breakpoint interfaces for PowerPC Book III S processors. These interfaces help arbitrate requests from various users and schedules them as appropriate.
--- arch/powerpc/Kconfig | 1 arch/powerpc/include/asm/cputable.h | 4 arch/powerpc/include/asm/hw_breakpoint.h | 49 ++++ arch/powerpc/include/asm/processor.h | 8 arch/powerpc/kernel/Makefile | 1 arch/powerpc/kernel/hw_breakpoint.c | 345 +++++++++++++++++++++++++++++++ arch/powerpc/kernel/machine_kexec_64.c | 3 arch/powerpc/kernel/process.c | 6 arch/powerpc/kernel/ptrace.c | 64 +++++ arch/powerpc/lib/Makefile | 1 include/linux/hw_breakpoint.h | 1 11 files changed, 483 insertions(+)
arch/powerpc/include/asm/hw_breakpoint.h new file +49 -0
@@ -0,0 +1,49 @@ +#ifndef _PPC_BOOK3S_64_HW_BREAKPOINT_H +#define _PPC_BOOK3S_64_HW_BREAKPOINT_H + +#ifdef __KERNEL__ +#ifdef CONFIG_HAVE_HW_BREAKPOINT + +struct arch_hw_breakpoint { +u8 len;/* length of the target data symbol */ +int type; +unsigned long address; +}; + +#include <linux/kdebug.h> +#include <asm/reg.h> +#include <asm/system.h> + +static inline int hw_breakpoint_slots (int type) +{ +return HBP_NUM ; +} +struct perf_event ; +struct pmu ; +struct perf_sample_data ; + +#define HW_BREAKPOINT_ALIGN 0x7 +/* Maximum permissible length of any HW Breakpoint */ +#define HW_BREAKPOINT_LEN 0x8 + +extern int arch_bp_generic_fields (int type,int *gen_bp_type); +extern int arch_check_bp_in_kernelspace (struct perf_event *bp); +extern int arch_validate_hwbkpt_settings (struct perf_event *bp); +extern int hw_breakpoint_exceptions_notify (struct notifier_block *unused, +unsigned long val,void *data); +int arch_install_hw_breakpoint (struct perf_event *bp); +void arch_uninstall_hw_breakpoint (struct perf_event *bp); +void hw_breakpoint_pmu_read (struct perf_event *bp); +extern void flush_ptrace_hw_breakpoint (struct task_struct *tsk); + +extern struct pmu perf_ops_bp; +extern void ptrace_triggered (struct perf_event *bp,int nmi, +struct perf_sample_data *data,struct pt_regs *regs); +static inline void hw_breakpoint_disable (void ) +{ +set_dabr (0 ); +} + +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ +#endif /* __KERNEL__ */ +#endif /* _PPC_BOOK3S_64_HW_BREAKPOINT_H */
arch/powerpc/kernel/hw_breakpoint.c new file +345 -0
345 lines not on this page · raw message
arch/powerpc/kernel/Makefile +1 -0
@@ -34,6 +34,7 @@ obj-y += vdso32/ obj-$(CONFIG_PPC64) += setup_64.o sys_ppc32.o \ signal_64.o ptrace32.o \ paca.o nvram_64.o firmware.o +obj-$(CONFIG_HAVE_HW_BREAKPOINT) += hw_breakpoint.o obj-$(CONFIG_PPC_BOOK3S_64) += cpu_setup_ppc970.o cpu_setup_pa6t.o obj64-$(CONFIG_RELOCATABLE) += reloc_64.o obj-$(CONFIG_PPC_BOOK3E_64) += exceptions-64e.o
arch/powerpc/include/asm/processor.h +8 -0
@@ -209,6 +209,14 @@ struct thread_struct {#ifdef CONFIG_PPC64 unsigned long start_tb;/* Start purr when proc switched in */ unsigned long accum_tb;/* Total accumilated purr for process */ +#ifdef CONFIG_HAVE_HW_BREAKPOINT +struct perf_event *ptrace_bps[HBP_NUM ]; +/* +* Helps identify source of single-step exception and subsequent +* hw-breakpoint enablement +*/ +struct perf_event *last_hit_ubp; +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ #endif unsigned long dabr;/* Data address breakpoint register */ #ifdef CONFIG_ALTIVEC
arch/powerpc/kernel/ptrace.c +64 -0
85 lines not on this page · raw message
arch/powerpc/kernel/process.c +6 -0
@@ -462,8 +462,14 @@ struct task_struct *__switch_to(struct t#ifdef CONFIG_PPC_ADV_DEBUG_REGS switch_booke_debug_regs (&new->thread);#else +/* +* For PPC_BOOK3S_64, we use the hw-breakpoint interfaces that would +* schedule DABR +*/ +#ifndef CONFIG_HAVE_HW_BREAKPOINT if (unlikely (__get_cpu_var (current_dabr) != new->thread.dabr))set_dabr (new->thread.dabr); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ #endif
arch/powerpc/include/asm/cputable.h +4 -0
@@ -516,6 +516,10 @@ static inline int cpu_has_feature(unsign & feature); } +#ifdef CONFIG_HAVE_HW_BREAKPOINT +#define HBP_NUM 1 +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ +#endif /* !__ASSEMBLY__ */ #endif /* __KERNEL__ */
arch/powerpc/kernel/machine_kexec_64.c +3 -0
@@ -15,6 +15,7 @@#include <linux/thread_info.h> #include <linux/init_task.h> #include <linux/errno.h> +#include <linux/hw_breakpoint.h> #include <asm/page.h> #include <asm/current.h>
@@ -165,6 +166,7 @@ static void kexec_smp_down(void *arg)while (kexec_all_irq_disabled ==0 )cpu_relax ();mb ();/* make sure all irqs are disabled before this */ +hw_breakpoint_disable ();/* * Now every CPU has IRQs off, we can clear out any pending * IPIs and be sure that no more will come in after this.
@@ -180,6 +182,7 @@ static void kexec_prepare_cpus_wait(int {int my_cpu, i, notified=-1 ; +hw_breakpoint_disable (); my_cpu =get_cpu ();/* Make sure each CPU has atleast made it to the state we need */ for (i=0 ; i <NR_CPUS ; i++) {
arch/powerpc/lib/Makefile +1 -0
@@ -20,6 +20,7 @@ obj-$(CONFIG_PPC64) += copypage_64.o cop memcpy_64.o usercopy_64.o mem_64.o string.o obj-$(CONFIG_XMON) += sstep.o obj-$(CONFIG_KPROBES) += sstep.o +obj-$(CONFIG_HAVE_HW_BREAKPOINT) += sstep.o ifeq ($(CONFIG_PPC64),y) obj-$(CONFIG_SMP) += locks.o
include/linux/hw_breakpoint.h +1 -0
@@ -139,6 +139,7 @@ static inline struct arch_hw_breakpoint {return NULL ; } +static inline void hw_breakpoint_disable (void ) { }#endif /* CONFIG_HAVE_HW_BREAKPOINT */ #endif /* __KERNEL__ */
arch/powerpc/Kconfig +1 -0
@@ -141,6 +141,7 @@ config PPC select GENERIC_ATOMIC64 if PPC32 select HAVE_PERF_EVENTS select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_HW_BREAKPOINT if PERF_EVENTS && PPC_BOOK3S_64 config EARLY_PRINTK bool
PATCH 3/4 PPC64-HWBKPT: Handle concurrent alignment interrupts
In reply to a message not in the archiveAn alignment interrupt may intervene between a DSI/hw-breakpoint exception and the single-step exception. Enable the alignment interrupt (through modifications to emulate_single_step()) to notify the single-step exception handler for proper restoration of hw-breakpoints.
--- arch/powerpc/kernel/traps.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
arch/powerpc/kernel/traps.c +2 -5
@@ -602,7 +602,7 @@ void RunModeException(struct pt_regs *revoid __kprobes single_step_exception (struct pt_regs *regs) { - regs->msr &= ~(MSR_SE |MSR_BE );/* Turn off 'trace' bits */ +clear_single_step (regs);if (notify_die (DIE_SSTEP ,"single_step" , regs,5 ,5 ,SIGTRAP ) ==NOTIFY_STOP )
@@ -621,10 +621,7 @@ void __kprobes single_step_exception(str*/ static void emulate_single_step (struct pt_regs *regs) { -if (single_stepping (regs)) { -clear_single_step (regs); -_exception (SIGTRAP , regs,TRAP_TRACE ,0 ); - } +single_step_exception (regs); }static inline int __parse_fpscr (unsigned long fpscr)
PATCH 4/4 PPC64-HWBKPT: Enable hw-breakpoints while handling intervening signals
In reply to a message not in the archiveA signal delivered between a hw_breakpoint_handler() and the single_step_dabr_instruction() will not have the breakpoint active during signal handling (since breakpoint will not be restored through single-stepping due to absence of MSR_SE bit on the signal frame). Enable breakpoints before signal delivery and clear them during sigreturn() syscall.
Limitation: Nested hw-breakpoint exceptions (where second exception is raised inside signal context) will cause a 'double-hit' i.e. the first breakpoint exception will be taken twice.
Restore hw-breakpoints if the user-context is altered in the signal handler (causing loss of MSR_SE). Side-effect: 'Double-hit' of breakpoint if the instruction pointer is unaltered in the new context.
--- arch/powerpc/include/asm/hw_breakpoint.h | 3 +++ arch/powerpc/kernel/hw_breakpoint.c | 28 ++++++++++++++++++++++++++++ arch/powerpc/kernel/signal.c | 8 ++++++++ arch/powerpc/kernel/signal_32.c | 10 ++++++++++ arch/powerpc/kernel/signal_64.c | 7 +++++++ 5 files changed, 56 insertions(+)
arch/powerpc/include/asm/hw_breakpoint.h +3 -0
@@ -43,6 +43,9 @@ static inline void hw_breakpoint_disable {set_dabr (0 ); } +extern void sighandler_install_bp (struct task_struct *tsk); +extern void sigreturn_uninstall_bp (struct task_struct *tsk); +extern void thread_change_pc (struct task_struct *tsk,unsigned long msr);#endif /* CONFIG_HAVE_HW_BREAKPOINT */ #endif /* __KERNEL__ */
arch/powerpc/kernel/hw_breakpoint.c +28 -0
@@ -175,6 +175,34 @@ int arch_validate_hwbkpt_settings(structreturn 0 ; } +void sighandler_install_bp (struct task_struct *tsk) +{ +struct arch_hw_breakpoint *info; + +if (likely (!tsk->thread.last_hit_ubp)) +return ; + + info =counter_arch_bp (tsk->thread.last_hit_ubp); +set_dabr (info->address | info->type |DABR_TRANSLATION ); +} + +void sigreturn_uninstall_bp (struct task_struct *tsk) +{ +if (unlikely (tsk->thread.last_hit_ubp)) +set_dabr (0 ); +} + +void thread_change_pc (struct task_struct *tsk,unsigned long new_msr) +{ +/* +* Do not bother to restore breakpoints if single-stepping is not +* cleared. single_step_dabr_instruction() will handle it if MSR_SE +* is set. +*/ +if (!(new_msr &MSR_SE )) +sighandler_install_bp (tsk); +} +/* * Handle debug exception notifications. */
arch/powerpc/kernel/signal.c +8 -0
@@ -11,6 +11,7 @@#include <linux/tracehook.h> #include <linux/signal.h> +#include <asm/hw_breakpoint.h> #include <asm/uaccess.h> #include <asm/unistd.h>
@@ -149,6 +150,13 @@ static int do_signal_pending(sigset_t *oif (current->thread.dabr)set_dabr (current->thread.dabr);#endif +#ifdef CONFIG_HAVE_HW_BREAKPOINT +/* +* Re-enable the breakpoints (if it was previously cleared in +* hw_breakpoint_handler()) for the signal stack. +*/ +sighandler_install_bp (current); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ if (is32) {if (ka.sa.sa_flags &SA_SIGINFO )
arch/powerpc/kernel/signal_64.c +7 -0
@@ -33,6 +33,7 @@#include <asm/cacheflush.h> #include <asm/syscalls.h> #include <asm/vdso.h> +#include <asm/hw_breakpoint.h> #include "signal.h"
@@ -312,6 +313,9 @@ int sys_swapcontext(struct ucontext __us || __copy_to_user(&old_ctx->uc_sigmask, ¤t->blocked, sizeof(sigset_t)))return -EFAULT ; +#ifdef CONFIG_HAVE_HW_BREAKPOINT +thread_change_pc (current, new_msr); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ }if (new_ctx ==NULL )return 0 ;
@@ -364,6 +368,9 @@ int sys_rt_sigreturn(unsigned long r3, uif (__copy_from_user (&set, &uc->uc_sigmask,sizeof (set))) goto badframe;restore_sigmask (&set); +#ifdef CONFIG_HAVE_HW_BREAKPOINT +sigreturn_uninstall_bp (current); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ if (restore_sigcontext (regs,NULL ,1 , &uc->uc_mcontext)) goto badframe;
arch/powerpc/kernel/signal_32.c +10 -0
@@ -42,6 +42,7 @@#include <asm/syscalls.h> #include <asm/sigcontext.h> #include <asm/vdso.h> +#include <asm/hw_breakpoint.h> #ifdef CONFIG_PPC64 #include "ppc32.h" #include <asm/unistd.h>
@@ -996,6 +997,9 @@ long sys_swapcontext(struct ucontext __u || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))return -EFAULT ; +#ifdef CONFIG_HAVE_HW_BREAKPOINT +thread_change_pc (current, new_msr); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ }if (new_ctx ==NULL )return 0 ;
@@ -1034,6 +1038,9 @@ long sys_rt_sigreturn(int r3, int r4, in (regs->gpr[1 ] + __SIGNAL_FRAMESIZE +16 );if (!access_ok (VERIFY_READ , rt_sf,sizeof (*rt_sf))) goto bad; +#ifdef CONFIG_HAVE_HW_BREAKPOINT +sigreturn_uninstall_bp (current); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ if (do_setcontext (&rt_sf->uc, regs,1 )) goto bad;
@@ -1279,6 +1286,9 @@ long sys_sigreturn(int r3, int r4, int r#endif restore_sigmask (&set); +#ifdef CONFIG_HAVE_HW_BREAKPOINT +sigreturn_uninstall_bp (current); +#endif /* CONFIG_HAVE_HW_BREAKPOINT */ sr = (struct mcontext __user *)from_user_ptr (sigctx.regs); addr = sr; if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
Re: [Patch 4/4] PPC64-HWBKPT: Enable hw-breakpoints while handling intervening signals
Quoted 9 lines · K.Prasad
A signal delivered between a
hw_breakpoint_handler()and thesingle_step_dabr_instruction()will not have the breakpoint active during signal handling (since breakpoint will not be restored through single-stepping due to absence ofMSR_SEbit on the signal frame). Enable breakpoints before signal delivery and clear them duringsigreturn()syscall.Limitation: Nested hw-breakpoint exceptions (where second exception is raised inside signal context) will cause a 'double-hit' i.e. the first breakpoint exception will be taken twice.
I don't think this will actually cause a problem. In the case of a perf_event breakpoint, the semantics are trigger-after-execute, so the first hit won't cause a trigger, and perf_event won't double-count it. In the case of ptrace-style breakpoints, we don't single-step (it's up to the ptracer to do the single-stepping if needed) so the problem doesn't arise.
In fact I don't think we even need to do anything on sigreturn. Yes, we are changing the NIP but we are changing it to a previous value as a result of an explicit action by the program, which is a bit different to what signal delivery and ptrace do.
On signal delivery I was imagining that we would clear the MSR_SE bit before saving the MSR value in the signal frame, and reinstall the DABR value at the same time, and then essentially forget that we had already hit the breakpoint once and just wait for it to hit again.
Paul.