Release 4.14 arch/arm64/kernel/debug-monitors.c

Directory: arch/arm64/kernel
/*
 * ARMv8 single-step debug support and mdscr context switching.
 *
 * Copyright (C) 2012 ARM Limited
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Will Deacon <will.deacon@arm.com>
 */

#include <linux/cpu.h>
#include <linux/debugfs.h>
#include <linux/hardirq.h>
#include <linux/init.h>
#include <linux/ptrace.h>
#include <linux/kprobes.h>
#include <linux/stat.h>
#include <linux/uaccess.h>
#include <linux/sched/task_stack.h>

#include <asm/cpufeature.h>
#include <asm/cputype.h>
#include <asm/debug-monitors.h>
#include <asm/system_misc.h>

/* Determine debug architecture. */


u8 debug_monitors_arch(void)
{
	return cpuid_feature_extract_unsigned_field(read_sanitised_ftr_reg(SYS_ID_AA64DFR0_EL1),
						ID_AA64DFR0_DEBUGVER_SHIFT);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 11 61.11% 1 25.00%
Suzuki K. Poulose 6 33.33% 2 50.00%
Dave P Martin 1 5.56% 1 25.00%
Total 18 100.00% 4 100.00%

/*
 * MDSCR access routines.
 */


static void mdscr_write(u32 mdscr)
{
	unsigned long flags;
	local_dbg_save(flags);
	write_sysreg(mdscr, mdscr_el1);
	local_dbg_restore(flags);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 23 76.67% 1 50.00%
Mark Rutland 7 23.33% 1 50.00%
Total 30 100.00% 2 100.00%


NOKPROBE_SYMBOL(mdscr_write);



static u32 mdscr_read(void)
{
	return read_sysreg(mdscr_el1);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 10 71.43% 1 50.00%
Mark Rutland 4 28.57% 1 50.00%
Total 14 100.00% 2 100.00%


NOKPROBE_SYMBOL(mdscr_read);

/*
 * Allow root to disable self-hosted debug from userspace.
 * This is useful if you want to connect an external JTAG debugger.
 */

static bool debug_enabled = true;



static int create_debug_debugfs_entry(void)
{
	debugfs_create_bool("debug_enabled", 0644, NULL, &debug_enabled);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%


fs_initcall(create_debug_debugfs_entry);



static int __init early_debug_disable(char *buf)
{
	debug_enabled = false;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 17 94.44% 1 50.00%
Viresh Kumar 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%

early_param("nodebugmon", early_debug_disable);

/*
 * Keep track of debug users on each core.
 * The ref counts are per-cpu so we use a local_t type.
 */
static DEFINE_PER_CPU(int, mde_ref_count);
static DEFINE_PER_CPU(int, kde_ref_count);



void enable_debug_monitors(enum dbg_active_el el)
{
	u32 mdscr, enable = 0;

	WARN_ON(preemptible());

	if (this_cpu_inc_return(mde_ref_count) == 1)
		enable = DBG_MDSCR_MDE;

	if (el == DBG_ACTIVE_EL1 &&
	    this_cpu_inc_return(kde_ref_count) == 1)
		enable |= DBG_MDSCR_KDE;

	if (enable && debug_enabled) {
		mdscr = mdscr_read();
		mdscr |= enable;
		mdscr_write(mdscr);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 72 97.30% 2 66.67%
Christoph Lameter 2 2.70% 1 33.33%
Total 74 100.00% 3 100.00%


NOKPROBE_SYMBOL(enable_debug_monitors);



void disable_debug_monitors(enum dbg_active_el el)
{
	u32 mdscr, disable = 0;

	WARN_ON(preemptible());

	if (this_cpu_dec_return(mde_ref_count) == 0)
		disable = ~DBG_MDSCR_MDE;

	if (el == DBG_ACTIVE_EL1 &&
	    this_cpu_dec_return(kde_ref_count) == 0)
		disable &= ~DBG_MDSCR_KDE;

	if (disable) {
		mdscr = mdscr_read();
		mdscr &= disable;
		mdscr_write(mdscr);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 68 91.89% 2 66.67%
Christoph Lameter 6 8.11% 1 33.33%
Total 74 100.00% 3 100.00%


NOKPROBE_SYMBOL(disable_debug_monitors);

/*
 * OS lock clearing.
 */


static int clear_os_lock(unsigned int cpu)
{
	write_sysreg(0, oslar_el1);
	isb();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 16 69.57% 2 66.67%
Mark Rutland 7 30.43% 1 33.33%
Total 23 100.00% 3 100.00%



static int debug_monitors_init(void)
{
	return cpuhp_setup_state(CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING,
				 "arm64/debug_monitors:starting",
				 clear_os_lock, NULL);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 19 95.00% 2 66.67%
Thomas Gleixner 1 5.00% 1 33.33%
Total 20 100.00% 3 100.00%


postcore_initcall(debug_monitors_init);

/*
 * Single step API and exception handling.
 */


static void set_regs_spsr_ss(struct pt_regs *regs)
{
	regs->pstate |= DBG_SPSR_SS;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%


NOKPROBE_SYMBOL(set_regs_spsr_ss);



static void clear_regs_spsr_ss(struct pt_regs *regs)
{
	regs->pstate &= ~DBG_SPSR_SS;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


NOKPROBE_SYMBOL(clear_regs_spsr_ss);

/* EL1 Single Step Handler hooks */
static LIST_HEAD(step_hook);
static DEFINE_SPINLOCK(step_hook_lock);



void register_step_hook(struct step_hook *hook)
{
	spin_lock(&step_hook_lock);
	list_add_rcu(&hook->node, &step_hook);
	spin_unlock(&step_hook_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 30 90.91% 1 50.00%
Yang Shi 3 9.09% 1 50.00%
Total 33 100.00% 2 100.00%



void unregister_step_hook(struct step_hook *hook)
{
	spin_lock(&step_hook_lock);
	list_del_rcu(&hook->node);
	spin_unlock(&step_hook_lock);
	synchronize_rcu();
}

Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 27 81.82% 1 50.00%
Yang Shi 6 18.18% 1 50.00%
Total 33 100.00% 2 100.00%

/*
 * Call registered single step handlers
 * There is no Syndrome info to check for determining the handler.
 * So we call all the registered handlers, until the right handler is
 * found which returns zero.
 */


static int call_step_hook(struct pt_regs *regs, unsigned int esr)
{
	struct step_hook *hook;
	int retval = DBG_HOOK_ERROR;

	rcu_read_lock();

	list_for_each_entry_rcu(hook, &step_hook, node)	{
		retval = hook->fn(regs, esr);
		if (retval == DBG_HOOK_HANDLED)
			break;
	}

	rcu_read_unlock();

	return retval;
}
Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 57 91.94% 1 50.00%
Yang Shi 5 8.06% 1 50.00%
Total 62 100.00% 2 100.00%


NOKPROBE_SYMBOL(call_step_hook);



static void send_user_sigtrap(int si_code)
{
	struct pt_regs *regs = current_pt_regs();
	siginfo_t info = {
		.si_signo	= SIGTRAP,
		.si_errno	= 0,
		.si_code	= si_code,
		.si_addr	= (void __user *)instruction_pointer(regs),
        };

	if (WARN_ON(!user_mode(regs)))
		return;

	if (interrupts_enabled(regs))
		local_irq_enable();

	force_sig_info(SIGTRAP, &info, current);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 82 100.00% 2 100.00%
Total 82 100.00% 2 100.00%



static int single_step_handler(unsigned long addr, unsigned int esr,
			       struct pt_regs *regs)
{
	bool handler_found = false;

	/*
         * If we are stepping a pending breakpoint, call the hw_breakpoint
         * handler first.
         */
	if (!reinstall_suspended_bps(regs))
		return 0;

#ifdef	CONFIG_KPROBES
	if (kprobe_single_step_handler(regs, esr) == DBG_HOOK_HANDLED)
		handler_found = true;
#endif
	if (!handler_found && call_step_hook(regs, esr) == DBG_HOOK_HANDLED)
		handler_found = true;

	if (!handler_found && user_mode(regs)) {
		send_user_sigtrap(TRAP_TRACE);

		/*
                 * ptrace will disable single step unless explicitly
                 * asked to re-enable it. For other clients, it makes
                 * sense to leave it enabled (i.e. rewind the controls
                 * to the active-not-pending state).
                 */
		user_rewind_single_step(current);
	} else if (!handler_found) {
		pr_warn("Unexpected kernel single-step exception at EL1\n");
		/*
                 * Re-enable stepping since we know that we will be
                 * returning to regs.
                 */
		set_regs_spsr_ss(regs);
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Pratyush Anand 47 39.50% 1 20.00%
Will Deacon 45 37.82% 2 40.00%
Sandeepa Prabhu 27 22.69% 2 40.00%
Total 119 100.00% 5 100.00%


NOKPROBE_SYMBOL(single_step_handler);

/*
 * Breakpoint handler is re-entrant as another breakpoint can
 * hit within breakpoint handler, especically in kprobes.
 * Use reader/writer locks instead of plain spinlock.
 */
static LIST_HEAD(break_hook);
static DEFINE_SPINLOCK(break_hook_lock);



void register_break_hook(struct break_hook *hook)
{
	spin_lock(&break_hook_lock);
	list_add_rcu(&hook->node, &break_hook);
	spin_unlock(&break_hook_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 30 90.91% 1 50.00%
Yang Shi 3 9.09% 1 50.00%
Total 33 100.00% 2 100.00%



void unregister_break_hook(struct break_hook *hook)
{
	spin_lock(&break_hook_lock);
	list_del_rcu(&hook->node);
	spin_unlock(&break_hook_lock);
	synchronize_rcu();
}

Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 27 81.82% 1 50.00%
Yang Shi 6 18.18% 1 50.00%
Total 33 100.00% 2 100.00%



static int call_break_hook(struct pt_regs *regs, unsigned int esr)
{
	struct break_hook *hook;
	int (*fn)(struct pt_regs *regs, unsigned int esr) = NULL;

	rcu_read_lock();
	list_for_each_entry_rcu(hook, &break_hook, node)
		if ((esr & hook->esr_mask) == hook->esr_val)
			fn = hook->fn;
	rcu_read_unlock();

	return fn ? fn(regs, esr) : DBG_HOOK_ERROR;
}
Contributors
Person Tokens Prop Commits CommitProp
Sandeepa Prabhu 79 94.05% 1 50.00%
Yang Shi 5 5.95% 1 50.00%
Total 84 100.00% 2 100.00%


NOKPROBE_SYMBOL(call_break_hook);



static int brk_handler(unsigned long addr, unsigned int esr,
		       struct pt_regs *regs)
{
	bool handler_found = false;

#ifdef	CONFIG_KPROBES
	if ((esr & BRK64_ESR_MASK) == BRK64_ESR_KPROBES) {
		if (kprobe_breakpoint_handler(regs, esr) == DBG_HOOK_HANDLED)
			handler_found = true;
	}
#endif
	if (!handler_found && call_break_hook(regs, esr) == DBG_HOOK_HANDLED)
		handler_found = true;

	if (!handler_found && user_mode(regs)) {
		send_user_sigtrap(TRAP_BRKPT);
	} else if (!handler_found) {
		pr_warn("Unexpected kernel BRK exception at EL1\n");
		return -EFAULT;
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 42 37.84% 2 50.00%
Pratyush Anand 41 36.94% 1 25.00%
Sandeepa Prabhu 28 25.23% 1 25.00%
Total 111 100.00% 4 100.00%


NOKPROBE_SYMBOL(brk_handler);



int aarch32_break_handler(struct pt_regs *regs)
{
	u32 arm_instr;
	u16 thumb_instr;
	bool bp = false;
	void __user *pc = (void __user *)instruction_pointer(regs);

	if (!compat_user_mode(regs))
		return -EFAULT;

	if (compat_thumb_mode(regs)) {
		/* get 16-bit Thumb instruction */
		__le16 instr;
		get_user(instr, (__le16 __user *)pc);
		thumb_instr = le16_to_cpu(instr);
		if (thumb_instr == AARCH32_BREAK_THUMB2_LO) {
			/* get second half of 32-bit Thumb-2 instruction */
			get_user(instr, (__le16 __user *)(pc + 2));
			thumb_instr = le16_to_cpu(instr);
			bp = thumb_instr == AARCH32_BREAK_THUMB2_HI;
		} else {
			bp = thumb_instr == AARCH32_BREAK_THUMB;
		}
	} else {
		/* 32-bit ARM instruction */
		__le32 instr;
		get_user(instr, (__le32 __user *)pc);
		arm_instr = le32_to_cpu(instr);
		bp = (arm_instr & ~0xf0000000) == AARCH32_BREAK_ARM;
	}

	if (!bp)
		return -EFAULT;

	send_user_sigtrap(TRAP_BRKPT);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 139 76.80% 2 50.00%
Matthew Leach 27 14.92% 1 25.00%
Luc Van Oostenryck 15 8.29% 1 25.00%
Total 181 100.00% 4 100.00%


NOKPROBE_SYMBOL(aarch32_break_handler);



static int __init debug_traps_init(void)
{
	hook_debug_fault_code(DBG_ESR_EVT_HWSS, single_step_handler, SIGTRAP,
			      TRAP_TRACE, "single-step handler");
	hook_debug_fault_code(DBG_ESR_EVT_BRK, brk_handler, SIGTRAP,
			      TRAP_BRKPT, "ptrace BRK handler");
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 38 100.00% 3 100.00%
Total 38 100.00% 3 100.00%


arch_initcall(debug_traps_init);

/* Re-enable single step for syscall restarting. */


void user_rewind_single_step(struct task_struct *task)
{
	/*
         * If single step is active for this thread, then set SPSR.SS
         * to 1 to avoid returning to the active-pending state.
         */
	if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP))
		set_regs_spsr_ss(task_pt_regs(task));
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%


NOKPROBE_SYMBOL(user_rewind_single_step);



void user_fastforward_single_step(struct task_struct *task)
{
	if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP))
		clear_regs_spsr_ss(task_pt_regs(task));
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

/* Kernel API */


void kernel_enable_single_step(struct pt_regs *regs)
{
	WARN_ON(!irqs_disabled());
	set_regs_spsr_ss(regs);
	mdscr_write(mdscr_read() | DBG_MDSCR_SS);
	enable_debug_monitors(DBG_ACTIVE_EL1);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


NOKPROBE_SYMBOL(kernel_enable_single_step);



void kernel_disable_single_step(void)
{
	WARN_ON(!irqs_disabled());
	mdscr_write(mdscr_read() & ~DBG_MDSCR_SS);
	disable_debug_monitors(DBG_ACTIVE_EL1);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


NOKPROBE_SYMBOL(kernel_disable_single_step);



int kernel_active_single_step(void)
{
	WARN_ON(!irqs_disabled());
	return mdscr_read() & DBG_MDSCR_SS;
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%


NOKPROBE_SYMBOL(kernel_active_single_step);

/* ptrace API */


void user_enable_single_step(struct task_struct *task)
{
	struct thread_info *ti = task_thread_info(task);

	if (!test_and_set_ti_thread_flag(ti, TIF_SINGLESTEP))
		set_regs_spsr_ss(task_pt_regs(task));
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 38 100.00% 2 100.00%
Total 38 100.00% 2 100.00%


NOKPROBE_SYMBOL(user_enable_single_step);



void user_disable_single_step(struct task_struct *task)
{
	clear_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP);
}
Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%


NOKPROBE_SYMBOL(user_disable_single_step);
Overall Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 921 59.61% 8 29.63%
Sandeepa Prabhu 330 21.36% 2 7.41%
Pratyush Anand 173 11.20% 3 11.11%
Yang Shi 31 2.01% 3 11.11%
Matthew Leach 27 1.75% 1 3.70%
Mark Rutland 18 1.17% 1 3.70%
Luc Van Oostenryck 15 0.97% 1 3.70%
Christoph Lameter 10 0.65% 1 3.70%
Suzuki K. Poulose 10 0.65% 2 7.41%
Viresh Kumar 3 0.19% 1 3.70%
Ingo Molnar 3 0.19% 1 3.70%
Jingoo Han 2 0.13% 1 3.70%
Thomas Gleixner 1 0.06% 1 3.70%
Dave P Martin 1 0.06% 1 3.70%
Total 1545 100.00% 27 100.00%
Directory: arch/arm64/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Will Deacon	11	61.11%	1	25.00%
Suzuki K. Poulose	6	33.33%	2	50.00%
Dave P Martin	1	5.56%	1	25.00%
Total	18	100.00%	4	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/arm64/kernel/debug-monitors.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
