arch/sh/kernel/hw_breakpoint.c - kernel/bruno - Git at Google

 /*
  * arch/sh/kernel/hw_breakpoint.c
  *
  * Unified kernel/user-space hardware breakpoint facility for the on-chip UBC.
  *
  * Copyright (C) 2009 - 2010  Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  */
 #include <linux/init.h>
 #include <linux/perf_event.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/percpu.h>
 #include <linux/kallsyms.h>
 #include <linux/notifier.h>
 #include <linux/kprobes.h>
 #include <linux/kdebug.h>
 #include <linux/io.h>
 #include <linux/clk.h>
 #include <asm/hw_breakpoint.h>
 #include <asm/mmu_context.h>
 #include <asm/ptrace.h>
 #include <asm/traps.h>

 /*
  * Stores the breakpoints currently in use on each breakpoint address
  * register for each cpus
  */
 static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]);

 /*
  * A dummy placeholder for early accesses until the CPUs get a chance to
  * register their UBCs later in the boot process.
  */
 static struct sh_ubc ubc_dummy = { .num_events = 0 };

 static struct sh_ubc *sh_ubc __read_mostly = &ubc_dummy;

 /*
  * Install a perf counter breakpoint.
  *
  * We seek a free UBC channel and use it for this breakpoint.
  *
  * Atomic: we hold the counter->ctx->lock and we only handle variables
  * and registers local to this cpu.
  */
 int arch_install_hw_breakpoint(struct perf_event *bp)
 {
 	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
 	int i;

 	for (i = 0; i < sh_ubc->num_events; i++) {
 		struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);

 		if (!*slot) {
 			*slot = bp;
 			break;
 		}
 	}

 	if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
 		return -EBUSY;

 	clk_enable(sh_ubc->clk);
 	sh_ubc->enable(info, i);

 	return 0;
 }

 /*
  * Uninstall the breakpoint contained in the given counter.
  *
  * First we search the debug address register it uses and then we disable
  * it.
  *
  * Atomic: we hold the counter->ctx->lock and we only handle variables
  * and registers local to this cpu.
  */
 void arch_uninstall_hw_breakpoint(struct perf_event *bp)
 {
 	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
 	int i;

 	for (i = 0; i < sh_ubc->num_events; i++) {
 		struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);

 		if (*slot == bp) {
 			*slot = NULL;
 			break;
 		}
 	}

 	if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
 		return;

 	sh_ubc->disable(info, i);
 	clk_disable(sh_ubc->clk);
 }

 static int get_hbp_len(u16 hbp_len)
 {
 	unsigned int len_in_bytes = 0;

 	switch (hbp_len) {
 	case SH_BREAKPOINT_LEN_1:
 		len_in_bytes = 1;
 		break;
 	case SH_BREAKPOINT_LEN_2:
 		len_in_bytes = 2;
 		break;
 	case SH_BREAKPOINT_LEN_4:
 		len_in_bytes = 4;
 		break;
 	case SH_BREAKPOINT_LEN_8:
 		len_in_bytes = 8;
 		break;
 	}
 	return len_in_bytes;
 }

 /*
  * Check for virtual address in kernel space.
  */
 int arch_check_bp_in_kernelspace(struct perf_event *bp)
 {
 	unsigned int len;
 	unsigned long va;
 	struct arch_hw_breakpoint *info = counter_arch_bp(bp);

 	va = info->address;
 	len = get_hbp_len(info->len);

 	return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
 }

 int arch_bp_generic_fields(int sh_len, int sh_type,
 			   int *gen_len, int *gen_type)
 {
 	/* Len */
 	switch (sh_len) {
 	case SH_BREAKPOINT_LEN_1:
 		*gen_len = HW_BREAKPOINT_LEN_1;
 		break;
 	case SH_BREAKPOINT_LEN_2:
 		*gen_len = HW_BREAKPOINT_LEN_2;
 		break;
 	case SH_BREAKPOINT_LEN_4:
 		*gen_len = HW_BREAKPOINT_LEN_4;
 		break;
 	case SH_BREAKPOINT_LEN_8:
 		*gen_len = HW_BREAKPOINT_LEN_8;
 		break;
 	default:
 		return -EINVAL;
 	}

 	/* Type */
 	switch (sh_type) {
 	case SH_BREAKPOINT_READ:
 		*gen_type = HW_BREAKPOINT_R;
 	case SH_BREAKPOINT_WRITE:
 		*gen_type = HW_BREAKPOINT_W;
 		break;
 	case SH_BREAKPOINT_RW:
 		*gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static int arch_build_bp_info(struct perf_event *bp)
 {
 	struct arch_hw_breakpoint *info = counter_arch_bp(bp);

 	info->address = bp->attr.bp_addr;

 	/* Len */
 	switch (bp->attr.bp_len) {
 	case HW_BREAKPOINT_LEN_1:
 		info->len = SH_BREAKPOINT_LEN_1;
 		break;
 	case HW_BREAKPOINT_LEN_2:
 		info->len = SH_BREAKPOINT_LEN_2;
 		break;
 	case HW_BREAKPOINT_LEN_4:
 		info->len = SH_BREAKPOINT_LEN_4;
 		break;
 	case HW_BREAKPOINT_LEN_8:
 		info->len = SH_BREAKPOINT_LEN_8;
 		break;
 	default:
 		return -EINVAL;
 	}

 	/* Type */
 	switch (bp->attr.bp_type) {
 	case HW_BREAKPOINT_R:
 		info->type = SH_BREAKPOINT_READ;
 		break;
 	case HW_BREAKPOINT_W:
 		info->type = SH_BREAKPOINT_WRITE;
 		break;
 	case HW_BREAKPOINT_W | HW_BREAKPOINT_R:
 		info->type = SH_BREAKPOINT_RW;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 /*
  * Validate the arch-specific HW Breakpoint register settings
  */
 int arch_validate_hwbkpt_settings(struct perf_event *bp)
 {
 	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
 	unsigned int align;
 	int ret;

 	ret = arch_build_bp_info(bp);
 	if (ret)
 		return ret;

 	ret = -EINVAL;

 	switch (info->len) {
 	case SH_BREAKPOINT_LEN_1:
 		align = 0;
 		break;
 	case SH_BREAKPOINT_LEN_2:
 		align = 1;
 		break;
 	case SH_BREAKPOINT_LEN_4:
 		align = 3;
 		break;
 	case SH_BREAKPOINT_LEN_8:
 		align = 7;
 		break;
 	default:
 		return ret;
 	}

 	/*
 	 * For kernel-addresses, either the address or symbol name can be
 	 * specified.
 	 */
 	if (info->name)
 		info->address = (unsigned long)kallsyms_lookup_name(info->name);

 	/*
 	 * Check that the low-order bits of the address are appropriate
 	 * for the alignment implied by len.
 	 */
 	if (info->address & align)
 		return -EINVAL;

 	return 0;
 }

 /*
  * Release the user breakpoints used by ptrace
  */
 void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
 {
 	int i;
 	struct thread_struct *t = &tsk->thread;

 	for (i = 0; i < sh_ubc->num_events; i++) {
 		unregister_hw_breakpoint(t->ptrace_bps[i]);
 		t->ptrace_bps[i] = NULL;
 	}
 }

 static int __kprobes hw_breakpoint_handler(struct die_args *args)
 {
 	int cpu, i, rc = NOTIFY_STOP;
 	struct perf_event *bp;
 	unsigned int cmf, resume_mask;

 	/*
 	 * Do an early return if none of the channels triggered.
 	 */
 	cmf = sh_ubc->triggered_mask();
 	if (unlikely(!cmf))
 		return NOTIFY_DONE;

 	/*
 	 * By default, resume all of the active channels.
 	 */
 	resume_mask = sh_ubc->active_mask();

 	/*
 	 * Disable breakpoints during exception handling.
 	 */
 	sh_ubc->disable_all();

 	cpu = get_cpu();
 	for (i = 0; i < sh_ubc->num_events; i++) {
 		unsigned long event_mask = (1 << i);

 		if (likely(!(cmf & event_mask)))
 			continue;

 		/*
 		 * The counter may be concurrently released but that can only
 		 * occur from a call_rcu() path. We can then safely fetch
 		 * the breakpoint, use its callback, touch its counter
 		 * while we are in an rcu_read_lock() path.
 		 */
 		rcu_read_lock();

 		bp = per_cpu(bp_per_reg[i], cpu);
 		if (bp)
 			rc = NOTIFY_DONE;

 		/*
 		 * Reset the condition match flag to denote completion of
 		 * exception handling.
 		 */
 		sh_ubc->clear_triggered_mask(event_mask);

 		/*
 		 * bp can be NULL due to concurrent perf counter
 		 * removing.
 		 */
 		if (!bp) {
 			rcu_read_unlock();
 			break;
 		}

 		/*
 		 * Don't restore the channel if the breakpoint is from
 		 * ptrace, as it always operates in one-shot mode.
 		 */
 		if (bp->overflow_handler == ptrace_triggered)
 			resume_mask &= ~(1 << i);

 		perf_bp_event(bp, args->regs);

 		/* Deliver the signal to userspace */
 		if (!arch_check_bp_in_kernelspace(bp)) {
 			siginfo_t info;

 			info.si_signo = args->signr;
 			info.si_errno = notifier_to_errno(rc);
 			info.si_code = TRAP_HWBKPT;

 			force_sig_info(args->signr, &info, current);
 		}

 		rcu_read_unlock();
 	}

 	if (cmf == 0)
 		rc = NOTIFY_DONE;

 	sh_ubc->enable_all(resume_mask);

 	put_cpu();

 	return rc;
 }

 BUILD_TRAP_HANDLER(breakpoint)
 {
 	unsigned long ex = lookup_exception_vector();
 	TRAP_HANDLER_DECL;

 	notify_die(DIE_BREAKPOINT, "breakpoint", regs, 0, ex, SIGTRAP);
 }

 /*
  * Handle debug exception notifications.
  */
 int __kprobes hw_breakpoint_exceptions_notify(struct notifier_block *unused,
 				    unsigned long val, void *data)
 {
 	struct die_args *args = data;

 	if (val != DIE_BREAKPOINT)
 		return NOTIFY_DONE;

 	/*
 	 * If the breakpoint hasn't been triggered by the UBC, it's
 	 * probably from a debugger, so don't do anything more here.
 	 *
 	 * This also permits the UBC interface clock to remain off for
 	 * non-UBC breakpoints, as we don't need to check the triggered
 	 * or active channel masks.
 	 */
 	if (args->trapnr != sh_ubc->trap_nr)
 		return NOTIFY_DONE;

 	return hw_breakpoint_handler(data);
 }

 void hw_breakpoint_pmu_read(struct perf_event *bp)
 {
 	/* TODO */
 }

 int register_sh_ubc(struct sh_ubc *ubc)
 {
 	/* Bail if it's already assigned */
 	if (sh_ubc != &ubc_dummy)
 		return -EBUSY;
 	sh_ubc = ubc;

 	pr_info("HW Breakpoints: %s UBC support registered\n", ubc->name);

 	WARN_ON(ubc->num_events > HBP_NUM);

 	return 0;
 }
	/*
	* arch/sh/kernel/hw_breakpoint.c
	*
	* Unified kernel/user-space hardware breakpoint facility for the on-chip UBC.
	*
	* Copyright (C) 2009 - 2010 Paul Mundt
	*
	* This file is subject to the terms and conditions of the GNU General Public
	* License. See the file "COPYING" in the main directory of this archive
	* for more details.
	*/
	#include <linux/init.h>
	#include <linux/perf_event.h>
	#include <linux/hw_breakpoint.h>
	#include <linux/percpu.h>
	#include <linux/kallsyms.h>
	#include <linux/notifier.h>
	#include <linux/kprobes.h>
	#include <linux/kdebug.h>
	#include <linux/io.h>
	#include <linux/clk.h>
	#include <asm/hw_breakpoint.h>
	#include <asm/mmu_context.h>
	#include <asm/ptrace.h>
	#include <asm/traps.h>

	/*
	* Stores the breakpoints currently in use on each breakpoint address
	* register for each cpus
	*/
	static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]);

	/*
	* A dummy placeholder for early accesses until the CPUs get a chance to
	* register their UBCs later in the boot process.
	*/
	static struct sh_ubc ubc_dummy = { .num_events = 0 };

	static struct sh_ubc *sh_ubc __read_mostly = &ubc_dummy;

	/*
	* Install a perf counter breakpoint.
	*
	* We seek a free UBC channel and use it for this breakpoint.
	*
	* Atomic: we hold the counter->ctx->lock and we only handle variables
	* and registers local to this cpu.
	*/
	int arch_install_hw_breakpoint(struct perf_event *bp)
	{
	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
	int i;

	for (i = 0; i < sh_ubc->num_events; i++) {
	struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);

	if (!*slot) {
	*slot = bp;
	break;
	}
	}

	if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
	return -EBUSY;

	clk_enable(sh_ubc->clk);
	sh_ubc->enable(info, i);

	return 0;
	}

	/*
	* Uninstall the breakpoint contained in the given counter.
	*
	* First we search the debug address register it uses and then we disable
	* it.
	*
	* Atomic: we hold the counter->ctx->lock and we only handle variables
	* and registers local to this cpu.
	*/
	void arch_uninstall_hw_breakpoint(struct perf_event *bp)
	{
	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
	int i;

	for (i = 0; i < sh_ubc->num_events; i++) {
	struct perf_event **slot = this_cpu_ptr(&bp_per_reg[i]);

	if (*slot == bp) {
	*slot = NULL;
	break;
	}
	}

	if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
	return;

	sh_ubc->disable(info, i);
	clk_disable(sh_ubc->clk);
	}

	static int get_hbp_len(u16 hbp_len)
	{
	unsigned int len_in_bytes = 0;

	switch (hbp_len) {
	case SH_BREAKPOINT_LEN_1:
	len_in_bytes = 1;
	break;
	case SH_BREAKPOINT_LEN_2:
	len_in_bytes = 2;
	break;
	case SH_BREAKPOINT_LEN_4:
	len_in_bytes = 4;
	break;
	case SH_BREAKPOINT_LEN_8:
	len_in_bytes = 8;
	break;
	}
	return len_in_bytes;
	}

	/*
	* Check for virtual address in kernel space.
	*/
	int arch_check_bp_in_kernelspace(struct perf_event *bp)
	{
	unsigned int len;
	unsigned long va;
	struct arch_hw_breakpoint *info = counter_arch_bp(bp);

	va = info->address;
	len = get_hbp_len(info->len);

	return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
	}

	int arch_bp_generic_fields(int sh_len, int sh_type,
	int gen_len, int gen_type)
	{
	/* Len */
	switch (sh_len) {
	case SH_BREAKPOINT_LEN_1:
	*gen_len = HW_BREAKPOINT_LEN_1;
	break;
	case SH_BREAKPOINT_LEN_2:
	*gen_len = HW_BREAKPOINT_LEN_2;
	break;
	case SH_BREAKPOINT_LEN_4:
	*gen_len = HW_BREAKPOINT_LEN_4;
	break;
	case SH_BREAKPOINT_LEN_8:
	*gen_len = HW_BREAKPOINT_LEN_8;
	break;
	default:
	return -EINVAL;
	}

	/* Type */
	switch (sh_type) {
	case SH_BREAKPOINT_READ:
	*gen_type = HW_BREAKPOINT_R;
	case SH_BREAKPOINT_WRITE:
	*gen_type = HW_BREAKPOINT_W;
	break;
	case SH_BREAKPOINT_RW:
	*gen_type = HW_BREAKPOINT_W \| HW_BREAKPOINT_R;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	static int arch_build_bp_info(struct perf_event *bp)
	{
	struct arch_hw_breakpoint *info = counter_arch_bp(bp);

	info->address = bp->attr.bp_addr;

	/* Len */
	switch (bp->attr.bp_len) {
	case HW_BREAKPOINT_LEN_1:
	info->len = SH_BREAKPOINT_LEN_1;
	break;
	case HW_BREAKPOINT_LEN_2:
	info->len = SH_BREAKPOINT_LEN_2;
	break;
	case HW_BREAKPOINT_LEN_4:
	info->len = SH_BREAKPOINT_LEN_4;
	break;
	case HW_BREAKPOINT_LEN_8:
	info->len = SH_BREAKPOINT_LEN_8;
	break;
	default:
	return -EINVAL;
	}

	/* Type */
	switch (bp->attr.bp_type) {
	case HW_BREAKPOINT_R:
	info->type = SH_BREAKPOINT_READ;
	break;
	case HW_BREAKPOINT_W:
	info->type = SH_BREAKPOINT_WRITE;
	break;
	case HW_BREAKPOINT_W \| HW_BREAKPOINT_R:
	info->type = SH_BREAKPOINT_RW;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	/*
	* Validate the arch-specific HW Breakpoint register settings
	*/
	int arch_validate_hwbkpt_settings(struct perf_event *bp)
	{
	struct arch_hw_breakpoint *info = counter_arch_bp(bp);
	unsigned int align;
	int ret;

	ret = arch_build_bp_info(bp);
	if (ret)
	return ret;

	ret = -EINVAL;

	switch (info->len) {
	case SH_BREAKPOINT_LEN_1:
	align = 0;
	break;
	case SH_BREAKPOINT_LEN_2:
	align = 1;
	break;
	case SH_BREAKPOINT_LEN_4:
	align = 3;
	break;
	case SH_BREAKPOINT_LEN_8:
	align = 7;
	break;
	default:
	return ret;
	}

	/*
	* For kernel-addresses, either the address or symbol name can be
	* specified.
	*/
	if (info->name)
	info->address = (unsigned long)kallsyms_lookup_name(info->name);

	/*
	* Check that the low-order bits of the address are appropriate
	* for the alignment implied by len.
	*/
	if (info->address & align)
	return -EINVAL;

	return 0;
	}

	/*
	* Release the user breakpoints used by ptrace
	*/
	void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
	{
	int i;
	struct thread_struct *t = &tsk->thread;

	for (i = 0; i < sh_ubc->num_events; i++) {
	unregister_hw_breakpoint(t->ptrace_bps[i]);
	t->ptrace_bps[i] = NULL;
	}
	}

	static int __kprobes hw_breakpoint_handler(struct die_args *args)
	{
	int cpu, i, rc = NOTIFY_STOP;
	struct perf_event *bp;
	unsigned int cmf, resume_mask;

	/*
	* Do an early return if none of the channels triggered.
	*/
	cmf = sh_ubc->triggered_mask();
	if (unlikely(!cmf))
	return NOTIFY_DONE;

	/*
	* By default, resume all of the active channels.
	*/
	resume_mask = sh_ubc->active_mask();

	/*
	* Disable breakpoints during exception handling.
	*/
	sh_ubc->disable_all();

	cpu = get_cpu();
	for (i = 0; i < sh_ubc->num_events; i++) {
	unsigned long event_mask = (1 << i);

	if (likely(!(cmf & event_mask)))
	continue;

	/*
	* The counter may be concurrently released but that can only
	* occur from a call_rcu() path. We can then safely fetch
	* the breakpoint, use its callback, touch its counter
	* while we are in an rcu_read_lock() path.
	*/
	rcu_read_lock();

	bp = per_cpu(bp_per_reg[i], cpu);
	if (bp)
	rc = NOTIFY_DONE;

	/*
	* Reset the condition match flag to denote completion of
	* exception handling.
	*/
	sh_ubc->clear_triggered_mask(event_mask);

	/*
	* bp can be NULL due to concurrent perf counter
	* removing.
	*/
	if (!bp) {
	rcu_read_unlock();
	break;
	}

	/*
	* Don't restore the channel if the breakpoint is from
	* ptrace, as it always operates in one-shot mode.
	*/
	if (bp->overflow_handler == ptrace_triggered)
	resume_mask &= ~(1 << i);

	perf_bp_event(bp, args->regs);

	/* Deliver the signal to userspace */
	if (!arch_check_bp_in_kernelspace(bp)) {
	siginfo_t info;

	info.si_signo = args->signr;
	info.si_errno = notifier_to_errno(rc);
	info.si_code = TRAP_HWBKPT;

	force_sig_info(args->signr, &info, current);
	}

	rcu_read_unlock();
	}

	if (cmf == 0)
	rc = NOTIFY_DONE;

	sh_ubc->enable_all(resume_mask);

	put_cpu();

	return rc;
	}

	BUILD_TRAP_HANDLER(breakpoint)
	{
	unsigned long ex = lookup_exception_vector();
	TRAP_HANDLER_DECL;

	notify_die(DIE_BREAKPOINT, "breakpoint", regs, 0, ex, SIGTRAP);
	}

	/*
	* Handle debug exception notifications.
	*/
	int __kprobes hw_breakpoint_exceptions_notify(struct notifier_block *unused,
	unsigned long val, void *data)
	{
	struct die_args *args = data;

	if (val != DIE_BREAKPOINT)
	return NOTIFY_DONE;

	/*
	* If the breakpoint hasn't been triggered by the UBC, it's
	* probably from a debugger, so don't do anything more here.
	*
	* This also permits the UBC interface clock to remain off for
	* non-UBC breakpoints, as we don't need to check the triggered
	* or active channel masks.
	*/
	if (args->trapnr != sh_ubc->trap_nr)
	return NOTIFY_DONE;

	return hw_breakpoint_handler(data);
	}

	void hw_breakpoint_pmu_read(struct perf_event *bp)
	{
	/* TODO */
	}

	int register_sh_ubc(struct sh_ubc *ubc)
	{
	/* Bail if it's already assigned */
	if (sh_ubc != &ubc_dummy)
	return -EBUSY;
	sh_ubc = ubc;

	pr_info("HW Breakpoints: %s UBC support registered\n", ubc->name);

	WARN_ON(ubc->num_events > HBP_NUM);

	return 0;
	}