[mirror_ubuntu-artful-kernel.git] / arch / tile / kernel / kgdb.c

/*
 * Copyright 2013 Tilera Corporation. All Rights Reserved.
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation, version 2.
 *
 *   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, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 *
 * TILE-Gx KGDB support.
 */

#include <linux/ptrace.h>
#include <linux/kgdb.h>
#include <linux/kdebug.h>
#include <linux/uaccess.h>
#include <linux/module.h>
#include <linux/sched/task_stack.h>

#include <asm/cacheflush.h>

static tile_bundle_bits singlestep_insn = TILEGX_BPT_BUNDLE | DIE_SSTEPBP;
static unsigned long stepped_addr;
static tile_bundle_bits stepped_instr;

struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
	{ "r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[0])},
	{ "r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[1])},
	{ "r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[2])},
	{ "r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[3])},
	{ "r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[4])},
	{ "r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[5])},
	{ "r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[6])},
	{ "r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[7])},
	{ "r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[8])},
	{ "r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[9])},
	{ "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[10])},
	{ "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[11])},
	{ "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[12])},
	{ "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[13])},
	{ "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[14])},
	{ "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[15])},
	{ "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[16])},
	{ "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[17])},
	{ "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[18])},
	{ "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[19])},
	{ "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[20])},
	{ "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[21])},
	{ "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[22])},
	{ "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[23])},
	{ "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[24])},
	{ "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[25])},
	{ "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[26])},
	{ "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[27])},
	{ "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[28])},
	{ "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[29])},
	{ "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[30])},
	{ "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[31])},
	{ "r32", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[32])},
	{ "r33", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[33])},
	{ "r34", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[34])},
	{ "r35", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[35])},
	{ "r36", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[36])},
	{ "r37", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[37])},
	{ "r38", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[38])},
	{ "r39", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[39])},
	{ "r40", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[40])},
	{ "r41", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[41])},
	{ "r42", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[42])},
	{ "r43", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[43])},
	{ "r44", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[44])},
	{ "r45", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[45])},
	{ "r46", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[46])},
	{ "r47", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[47])},
	{ "r48", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[48])},
	{ "r49", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[49])},
	{ "r50", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[50])},
	{ "r51", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[51])},
	{ "r52", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[52])},
	{ "tp", GDB_SIZEOF_REG, offsetof(struct pt_regs, tp)},
	{ "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, sp)},
	{ "lr", GDB_SIZEOF_REG, offsetof(struct pt_regs, lr)},
	{ "sn", GDB_SIZEOF_REG, -1},
	{ "idn0", GDB_SIZEOF_REG, -1},
	{ "idn1", GDB_SIZEOF_REG, -1},
	{ "udn0", GDB_SIZEOF_REG, -1},
	{ "udn1", GDB_SIZEOF_REG, -1},
	{ "udn2", GDB_SIZEOF_REG, -1},
	{ "udn3", GDB_SIZEOF_REG, -1},
	{ "zero", GDB_SIZEOF_REG, -1},
	{ "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, pc)},
	{ "faultnum", GDB_SIZEOF_REG, offsetof(struct pt_regs, faultnum)},
};

char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
{
	if (regno >= DBG_MAX_REG_NUM || regno < 0)
		return NULL;

	if (dbg_reg_def[regno].offset != -1)
		memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
		       dbg_reg_def[regno].size);
	else
		memset(mem, 0, dbg_reg_def[regno].size);
	return dbg_reg_def[regno].name;
}

int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
{
	if (regno >= DBG_MAX_REG_NUM || regno < 0)
		return -EINVAL;

	if (dbg_reg_def[regno].offset != -1)
		memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
		       dbg_reg_def[regno].size);
	return 0;
}

/*
 * Similar to pt_regs_to_gdb_regs() except that process is sleeping and so
 * we may not be able to get all the info.
 */
void
sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)
{
	struct pt_regs *thread_regs;
	const int NGPRS = TREG_LAST_GPR + 1;

	if (task == NULL)
		return;

	thread_regs = task_pt_regs(task);
	memcpy(gdb_regs, thread_regs, NGPRS * sizeof(unsigned long));
	memset(&gdb_regs[NGPRS], 0,
	       (TILEGX_PC_REGNUM - NGPRS) * sizeof(unsigned long));
	gdb_regs[TILEGX_PC_REGNUM] = thread_regs->pc;
	gdb_regs[TILEGX_FAULTNUM_REGNUM] = thread_regs->faultnum;
}

void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
{
	regs->pc = pc;
}

static void kgdb_call_nmi_hook(void *ignored)
{
	kgdb_nmicallback(raw_smp_processor_id(), NULL);
}

void kgdb_roundup_cpus(unsigned long flags)
{
	local_irq_enable();
	smp_call_function(kgdb_call_nmi_hook, NULL, 0);
	local_irq_disable();
}

/*
 * Convert a kernel address to the writable kernel text mapping.
 */
static unsigned long writable_address(unsigned long addr)
{
	unsigned long ret = 0;

	if (core_kernel_text(addr))
		ret = ktext_writable_addr(addr);
	else if (is_module_text_address(addr))
		ret = addr;
	else
		pr_err("Unknown virtual address 0x%lx\n", addr);

	return ret;
}

/*
 * Calculate the new address for after a step.
 */
static unsigned long get_step_address(struct pt_regs *regs)
{
	int src_reg;
	int jump_off;
	int br_off;
	unsigned long addr;
	unsigned int opcode;
	tile_bundle_bits bundle;

	/* Move to the next instruction by default. */
	addr = regs->pc + TILEGX_BUNDLE_SIZE_IN_BYTES;
	bundle = *(unsigned long *)instruction_pointer(regs);

	/* 0: X mode, Otherwise: Y mode. */
	if (bundle & TILEGX_BUNDLE_MODE_MASK) {
		if (get_Opcode_Y1(bundle) == RRR_1_OPCODE_Y1 &&
		    get_RRROpcodeExtension_Y1(bundle) ==
		    UNARY_RRR_1_OPCODE_Y1) {
			opcode = get_UnaryOpcodeExtension_Y1(bundle);

			switch (opcode) {
			case JALR_UNARY_OPCODE_Y1:
			case JALRP_UNARY_OPCODE_Y1:
			case JR_UNARY_OPCODE_Y1:
			case JRP_UNARY_OPCODE_Y1:
				src_reg = get_SrcA_Y1(bundle);
				dbg_get_reg(src_reg, &addr, regs);
				break;
			}
		}
	} else if (get_Opcode_X1(bundle) == RRR_0_OPCODE_X1) {
		if (get_RRROpcodeExtension_X1(bundle) ==
		    UNARY_RRR_0_OPCODE_X1) {
			opcode = get_UnaryOpcodeExtension_X1(bundle);

			switch (opcode) {
			case JALR_UNARY_OPCODE_X1:
			case JALRP_UNARY_OPCODE_X1:
			case JR_UNARY_OPCODE_X1:
			case JRP_UNARY_OPCODE_X1:
				src_reg = get_SrcA_X1(bundle);
				dbg_get_reg(src_reg, &addr, regs);
				break;
			}
		}
	} else if (get_Opcode_X1(bundle) == JUMP_OPCODE_X1) {
		opcode = get_JumpOpcodeExtension_X1(bundle);

		switch (opcode) {
		case JAL_JUMP_OPCODE_X1:
		case J_JUMP_OPCODE_X1:
			jump_off = sign_extend(get_JumpOff_X1(bundle), 27);
			addr = regs->pc +
				(jump_off << TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES);
			break;
		}
	} else if (get_Opcode_X1(bundle) == BRANCH_OPCODE_X1) {
		br_off = 0;
		opcode = get_BrType_X1(bundle);

		switch (opcode) {
		case BEQZT_BRANCH_OPCODE_X1:
		case BEQZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) == 0)
				br_off = get_BrOff_X1(bundle);
			break;
		case BGEZT_BRANCH_OPCODE_X1:
		case BGEZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) >= 0)
				br_off = get_BrOff_X1(bundle);
			break;
		case BGTZT_BRANCH_OPCODE_X1:
		case BGTZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) > 0)
				br_off = get_BrOff_X1(bundle);
			break;
		case BLBCT_BRANCH_OPCODE_X1:
		case BLBC_BRANCH_OPCODE_X1:
			if (!(get_SrcA_X1(bundle) & 1))
				br_off = get_BrOff_X1(bundle);
			break;
		case BLBST_BRANCH_OPCODE_X1:
		case BLBS_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) & 1)
				br_off = get_BrOff_X1(bundle);
			break;
		case BLEZT_BRANCH_OPCODE_X1:
		case BLEZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) <= 0)
				br_off = get_BrOff_X1(bundle);
			break;
		case BLTZT_BRANCH_OPCODE_X1:
		case BLTZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) < 0)
				br_off = get_BrOff_X1(bundle);
			break;
		case BNEZT_BRANCH_OPCODE_X1:
		case BNEZ_BRANCH_OPCODE_X1:
			if (get_SrcA_X1(bundle) != 0)
				br_off = get_BrOff_X1(bundle);
			break;
		}

		if (br_off != 0) {
			br_off = sign_extend(br_off, 17);
			addr = regs->pc +
				(br_off << TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES);
		}
	}

	return addr;
}

/*
 * Replace the next instruction after the current instruction with a
 * breakpoint instruction.
 */
static void do_single_step(struct pt_regs *regs)
{
	unsigned long addr_wr;

	/* Determine where the target instruction will send us to. */
	stepped_addr = get_step_address(regs);
	probe_kernel_read((char *)&stepped_instr, (char *)stepped_addr,
			  BREAK_INSTR_SIZE);

	addr_wr = writable_address(stepped_addr);
	probe_kernel_write((char *)addr_wr, (char *)&singlestep_insn,
			   BREAK_INSTR_SIZE);
	smp_wmb();
	flush_icache_range(stepped_addr, stepped_addr + BREAK_INSTR_SIZE);
}

static void undo_single_step(struct pt_regs *regs)
{
	unsigned long addr_wr;

	if (stepped_instr == 0)
		return;

	addr_wr = writable_address(stepped_addr);
	probe_kernel_write((char *)addr_wr, (char *)&stepped_instr,
			   BREAK_INSTR_SIZE);
	stepped_instr = 0;
	smp_wmb();
	flush_icache_range(stepped_addr, stepped_addr + BREAK_INSTR_SIZE);
}

/*
 * Calls linux_debug_hook before the kernel dies. If KGDB is enabled,
 * then try to fall into the debugger.
 */
static int
kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
{
	int ret;
	unsigned long flags;
	struct die_args *args = (struct die_args *)ptr;
	struct pt_regs *regs = args->regs;

#ifdef CONFIG_KPROBES
	/*
	 * Return immediately if the kprobes fault notifier has set
	 * DIE_PAGE_FAULT.
	 */
	if (cmd == DIE_PAGE_FAULT)
		return NOTIFY_DONE;
#endif /* CONFIG_KPROBES */

	switch (cmd) {
	case DIE_BREAK:
	case DIE_COMPILED_BPT:
		break;
	case DIE_SSTEPBP:
		local_irq_save(flags);
		kgdb_handle_exception(0, SIGTRAP, 0, regs);
		local_irq_restore(flags);
		return NOTIFY_STOP;
	default:
		/* Userspace events, ignore. */
		if (user_mode(regs))
			return NOTIFY_DONE;
	}

	local_irq_save(flags);
	ret = kgdb_handle_exception(args->trapnr, args->signr, args->err, regs);
	local_irq_restore(flags);
	if (ret)
		return NOTIFY_DONE;

	return NOTIFY_STOP;
}

static struct notifier_block kgdb_notifier = {
	.notifier_call = kgdb_notify,
};

/*
 * kgdb_arch_handle_exception - Handle architecture specific GDB packets.
 * @vector: The error vector of the exception that happened.
 * @signo: The signal number of the exception that happened.
 * @err_code: The error code of the exception that happened.
 * @remcom_in_buffer: The buffer of the packet we have read.
 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
 * @regs: The &struct pt_regs of the current process.
 *
 * This function MUST handle the 'c' and 's' command packets,
 * as well packets to set / remove a hardware breakpoint, if used.
 * If there are additional packets which the hardware needs to handle,
 * they are handled here. The code should return -1 if it wants to
 * process more packets, and a %0 or %1 if it wants to exit from the
 * kgdb callback.
 */
int kgdb_arch_handle_exception(int vector, int signo, int err_code,
			       char *remcom_in_buffer, char *remcom_out_buffer,
			       struct pt_regs *regs)
{
	char *ptr;
	unsigned long address;

	/* Undo any stepping we may have done. */
	undo_single_step(regs);

	switch (remcom_in_buffer[0]) {
	case 'c':
	case 's':
	case 'D':
	case 'k':
		/*
		 * Try to read optional parameter, pc unchanged if no parm.
		 * If this was a compiled-in breakpoint, we need to move
		 * to the next instruction or we will just breakpoint
		 * over and over again.
		 */
		ptr = &remcom_in_buffer[1];
		if (kgdb_hex2long(&ptr, &address))
			regs->pc = address;
		else if (*(unsigned long *)regs->pc == compiled_bpt)
			regs->pc += BREAK_INSTR_SIZE;

		if (remcom_in_buffer[0] == 's') {
			do_single_step(regs);
			kgdb_single_step = 1;
			atomic_set(&kgdb_cpu_doing_single_step,
				   raw_smp_processor_id());
		} else
			atomic_set(&kgdb_cpu_doing_single_step, -1);

		return 0;
	}

	return -1; /* this means that we do not want to exit from the handler */
}

struct kgdb_arch arch_kgdb_ops;

/*
 * kgdb_arch_init - Perform any architecture specific initialization.
 *
 * This function will handle the initialization of any architecture
 * specific callbacks.
 */
int kgdb_arch_init(void)
{
	tile_bundle_bits bundle = TILEGX_BPT_BUNDLE;

	memcpy(arch_kgdb_ops.gdb_bpt_instr, &bundle, BREAK_INSTR_SIZE);
	return register_die_notifier(&kgdb_notifier);
}

/*
 * kgdb_arch_exit - Perform any architecture specific uninitialization.
 *
 * This function will handle the uninitialization of any architecture
 * specific callbacks, for dynamic registration and unregistration.
 */
void kgdb_arch_exit(void)
{
	unregister_die_notifier(&kgdb_notifier);
}

int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
{
	int err;
	unsigned long addr_wr = writable_address(bpt->bpt_addr);

	if (addr_wr == 0)
		return -1;

	err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
				BREAK_INSTR_SIZE);
	if (err)
		return err;

	err = probe_kernel_write((char *)addr_wr, arch_kgdb_ops.gdb_bpt_instr,
				 BREAK_INSTR_SIZE);
	smp_wmb();
	flush_icache_range((unsigned long)bpt->bpt_addr,
			   (unsigned long)bpt->bpt_addr + BREAK_INSTR_SIZE);
	return err;
}

int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
{
	int err;
	unsigned long addr_wr = writable_address(bpt->bpt_addr);

	if (addr_wr == 0)
		return -1;

	err = probe_kernel_write((char *)addr_wr, (char *)bpt->saved_instr,
				 BREAK_INSTR_SIZE);
	smp_wmb();
	flush_icache_range((unsigned long)bpt->bpt_addr,
			   (unsigned long)bpt->bpt_addr + BREAK_INSTR_SIZE);
	return err;
}
Commit	Line	Data
8157107b CM	1	/*
	2	* Copyright 2013 Tilera Corporation. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*
	14	* TILE-Gx KGDB support.
	15	*/
	16
	17	#include <linux/ptrace.h>
	18	#include <linux/kgdb.h>
	19	#include <linux/kdebug.h>
	20	#include <linux/uaccess.h>
	21	#include <linux/module.h>
68db0cf1 IM	22	#include <linux/sched/task_stack.h>
68db0cf1 IM	23
8157107b CM	24	#include <asm/cacheflush.h>
	25
	26	static tile_bundle_bits singlestep_insn = TILEGX_BPT_BUNDLE \| DIE_SSTEPBP;
	27	static unsigned long stepped_addr;
	28	static tile_bundle_bits stepped_instr;
	29
	30	struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
	31	{ "r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[0])},
	32	{ "r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[1])},
	33	{ "r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[2])},
	34	{ "r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[3])},
	35	{ "r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[4])},
	36	{ "r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[5])},
	37	{ "r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[6])},
	38	{ "r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[7])},
	39	{ "r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[8])},
	40	{ "r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[9])},
	41	{ "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[10])},
	42	{ "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[11])},
	43	{ "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[12])},
	44	{ "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[13])},
	45	{ "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[14])},
	46	{ "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[15])},
	47	{ "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[16])},
	48	{ "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[17])},
	49	{ "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[18])},
	50	{ "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[19])},
	51	{ "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[20])},
	52	{ "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[21])},
	53	{ "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[22])},
	54	{ "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[23])},
	55	{ "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[24])},
	56	{ "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[25])},
	57	{ "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[26])},
	58	{ "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[27])},
	59	{ "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[28])},
	60	{ "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[29])},
	61	{ "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[30])},
	62	{ "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[31])},
	63	{ "r32", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[32])},
	64	{ "r33", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[33])},
	65	{ "r34", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[34])},
	66	{ "r35", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[35])},
	67	{ "r36", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[36])},
	68	{ "r37", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[37])},
	69	{ "r38", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[38])},
	70	{ "r39", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[39])},
	71	{ "r40", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[40])},
	72	{ "r41", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[41])},
	73	{ "r42", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[42])},
	74	{ "r43", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[43])},
	75	{ "r44", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[44])},
	76	{ "r45", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[45])},
	77	{ "r46", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[46])},
	78	{ "r47", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[47])},
	79	{ "r48", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[48])},
	80	{ "r49", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[49])},
	81	{ "r50", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[50])},
	82	{ "r51", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[51])},
	83	{ "r52", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[52])},
	84	{ "tp", GDB_SIZEOF_REG, offsetof(struct pt_regs, tp)},
	85	{ "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, sp)},
	86	{ "lr", GDB_SIZEOF_REG, offsetof(struct pt_regs, lr)},
	87	{ "sn", GDB_SIZEOF_REG, -1},
88	{ "idn0", GDB_SIZEOF_REG, -1},
89	{ "idn1", GDB_SIZEOF_REG, -1},
90	{ "udn0", GDB_SIZEOF_REG, -1},
91	{ "udn1", GDB_SIZEOF_REG, -1},
92	{ "udn2", GDB_SIZEOF_REG, -1},
93	{ "udn3", GDB_SIZEOF_REG, -1},
94	{ "zero", GDB_SIZEOF_REG, -1},
95	{ "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, pc)},
96	{ "faultnum", GDB_SIZEOF_REG, offsetof(struct pt_regs, faultnum)},
97	};
98
99	char dbg_get_reg(int regno, void mem, struct pt_regs *regs)
100	{
101	if (regno >= DBG_MAX_REG_NUM \|\| regno < 0)
102	return NULL;
103
104	if (dbg_reg_def[regno].offset != -1)
105	memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
106	dbg_reg_def[regno].size);
107	else
108	memset(mem, 0, dbg_reg_def[regno].size);
109	return dbg_reg_def[regno].name;
110	}
111
112	int dbg_set_reg(int regno, void mem, struct pt_regs regs)
113	{
114	if (regno >= DBG_MAX_REG_NUM \|\| regno < 0)
115	return -EINVAL;
116
117	if (dbg_reg_def[regno].offset != -1)
118	memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
119	dbg_reg_def[regno].size);
120	return 0;
121	}
122
123	/*
124	* Similar to pt_regs_to_gdb_regs() except that process is sleeping and so
125	* we may not be able to get all the info.
126	*/
127	void
128	sleeping_thread_to_gdb_regs(unsigned long gdb_regs, struct task_struct task)
129	{
8157107b	130	struct pt_regs *thread_regs;
77ef8f51	131	const int NGPRS = TREG_LAST_GPR + 1;
8157107b CM	132
	133	if (task == NULL)
	134	return;
	135
8157107b	136	thread_regs = task_pt_regs(task);
77ef8f51 CM	137	memcpy(gdb_regs, thread_regs, NGPRS * sizeof(unsigned long));
	138	memset(&gdb_regs[NGPRS], 0,
	139	(TILEGX_PC_REGNUM - NGPRS) * sizeof(unsigned long));
8157107b CM	140	gdb_regs[TILEGX_PC_REGNUM] = thread_regs->pc;
	141	gdb_regs[TILEGX_FAULTNUM_REGNUM] = thread_regs->faultnum;
	142	}
	143
	144	void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
	145	{
	146	regs->pc = pc;
	147	}
	148
	149	static void kgdb_call_nmi_hook(void *ignored)
	150	{
	151	kgdb_nmicallback(raw_smp_processor_id(), NULL);
	152	}
	153
	154	void kgdb_roundup_cpus(unsigned long flags)
	155	{
	156	local_irq_enable();
	157	smp_call_function(kgdb_call_nmi_hook, NULL, 0);
	158	local_irq_disable();
	159	}
	160
	161	/*
	162	* Convert a kernel address to the writable kernel text mapping.
	163	*/
	164	static unsigned long writable_address(unsigned long addr)
	165	{
	166	unsigned long ret = 0;
	167
	168	if (core_kernel_text(addr))
f419e6f6	169	ret = ktext_writable_addr(addr);
8157107b CM	170	else if (is_module_text_address(addr))
	171	ret = addr;
	172	else
	173	pr_err("Unknown virtual address 0x%lx\n", addr);
	174
	175	return ret;
	176	}
	177
	178	/*
	179	* Calculate the new address for after a step.
	180	*/
	181	static unsigned long get_step_address(struct pt_regs *regs)
	182	{
	183	int src_reg;
	184	int jump_off;
	185	int br_off;
	186	unsigned long addr;
	187	unsigned int opcode;
	188	tile_bundle_bits bundle;
	189
	190	/* Move to the next instruction by default. */
	191	addr = regs->pc + TILEGX_BUNDLE_SIZE_IN_BYTES;
	192	bundle = (unsigned long )instruction_pointer(regs);
	193
	194	/* 0: X mode, Otherwise: Y mode. */
	195	if (bundle & TILEGX_BUNDLE_MODE_MASK) {
	196	if (get_Opcode_Y1(bundle) == RRR_1_OPCODE_Y1 &&
	197	get_RRROpcodeExtension_Y1(bundle) ==
	198	UNARY_RRR_1_OPCODE_Y1) {
	199	opcode = get_UnaryOpcodeExtension_Y1(bundle);
	200
	201	switch (opcode) {
	202	case JALR_UNARY_OPCODE_Y1:
	203	case JALRP_UNARY_OPCODE_Y1:
	204	case JR_UNARY_OPCODE_Y1:
	205	case JRP_UNARY_OPCODE_Y1:
	206	src_reg = get_SrcA_Y1(bundle);
	207	dbg_get_reg(src_reg, &addr, regs);
	208	break;
	209	}
	210	}
	211	} else if (get_Opcode_X1(bundle) == RRR_0_OPCODE_X1) {
	212	if (get_RRROpcodeExtension_X1(bundle) ==
	213	UNARY_RRR_0_OPCODE_X1) {
	214	opcode = get_UnaryOpcodeExtension_X1(bundle);
	215
	216	switch (opcode) {
	217	case JALR_UNARY_OPCODE_X1:
	218	case JALRP_UNARY_OPCODE_X1:
	219	case JR_UNARY_OPCODE_X1:
	220	case JRP_UNARY_OPCODE_X1:
	221	src_reg = get_SrcA_X1(bundle);
	222	dbg_get_reg(src_reg, &addr, regs);
	223	break;
	224	}
	225	}
	226	} else if (get_Opcode_X1(bundle) == JUMP_OPCODE_X1) {
	227	opcode = get_JumpOpcodeExtension_X1(bundle);
	228
	229	switch (opcode) {
	230	case JAL_JUMP_OPCODE_X1:
	231	case J_JUMP_OPCODE_X1:
	232	jump_off = sign_extend(get_JumpOff_X1(bundle), 27);
	233	addr = regs->pc +
234	(jump_off << TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES);
235	break;
236	}
237	} else if (get_Opcode_X1(bundle) == BRANCH_OPCODE_X1) {
238	br_off = 0;
239	opcode = get_BrType_X1(bundle);
240
241	switch (opcode) {
242	case BEQZT_BRANCH_OPCODE_X1:
243	case BEQZ_BRANCH_OPCODE_X1:
244	if (get_SrcA_X1(bundle) == 0)
245	br_off = get_BrOff_X1(bundle);
246	break;
247	case BGEZT_BRANCH_OPCODE_X1:
248	case BGEZ_BRANCH_OPCODE_X1:
249	if (get_SrcA_X1(bundle) >= 0)
250	br_off = get_BrOff_X1(bundle);
251	break;
252	case BGTZT_BRANCH_OPCODE_X1:
253	case BGTZ_BRANCH_OPCODE_X1:
254	if (get_SrcA_X1(bundle) > 0)
255	br_off = get_BrOff_X1(bundle);
256	break;
257	case BLBCT_BRANCH_OPCODE_X1:
258	case BLBC_BRANCH_OPCODE_X1:
259	if (!(get_SrcA_X1(bundle) & 1))
260	br_off = get_BrOff_X1(bundle);
261	break;
262	case BLBST_BRANCH_OPCODE_X1:
263	case BLBS_BRANCH_OPCODE_X1:
264	if (get_SrcA_X1(bundle) & 1)
265	br_off = get_BrOff_X1(bundle);
266	break;
267	case BLEZT_BRANCH_OPCODE_X1:
268	case BLEZ_BRANCH_OPCODE_X1:
269	if (get_SrcA_X1(bundle) <= 0)
270	br_off = get_BrOff_X1(bundle);
271	break;
272	case BLTZT_BRANCH_OPCODE_X1:
273	case BLTZ_BRANCH_OPCODE_X1:
274	if (get_SrcA_X1(bundle) < 0)
275	br_off = get_BrOff_X1(bundle);
276	break;
277	case BNEZT_BRANCH_OPCODE_X1:
278	case BNEZ_BRANCH_OPCODE_X1:
279	if (get_SrcA_X1(bundle) != 0)
280	br_off = get_BrOff_X1(bundle);
281	break;
282	}
283
284	if (br_off != 0) {
285	br_off = sign_extend(br_off, 17);
286	addr = regs->pc +
287	(br_off << TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES);
288	}
289	}
290
291	return addr;
292	}
293
294	/*
295	* Replace the next instruction after the current instruction with a
296	* breakpoint instruction.
297	*/
298	static void do_single_step(struct pt_regs *regs)
299	{
300	unsigned long addr_wr;
301
302	/* Determine where the target instruction will send us to. */
303	stepped_addr = get_step_address(regs);
304	probe_kernel_read((char )&stepped_instr, (char )stepped_addr,
305	BREAK_INSTR_SIZE);
306
307	addr_wr = writable_address(stepped_addr);
308	probe_kernel_write((char )addr_wr, (char )&singlestep_insn,
309	BREAK_INSTR_SIZE);
310	smp_wmb();
311	flush_icache_range(stepped_addr, stepped_addr + BREAK_INSTR_SIZE);
312	}
313
314	static void undo_single_step(struct pt_regs *regs)
315	{
316	unsigned long addr_wr;
317
318	if (stepped_instr == 0)
319	return;
320
321	addr_wr = writable_address(stepped_addr);
322	probe_kernel_write((char )addr_wr, (char )&stepped_instr,
323	BREAK_INSTR_SIZE);
324	stepped_instr = 0;
325	smp_wmb();
326	flush_icache_range(stepped_addr, stepped_addr + BREAK_INSTR_SIZE);
327	}
328
329	/*
330	* Calls linux_debug_hook before the kernel dies. If KGDB is enabled,
331	* then try to fall into the debugger.
332	*/
333	static int
334	kgdb_notify(struct notifier_block self, unsigned long cmd, void ptr)
335	{
336	int ret;
337	unsigned long flags;
338	struct die_args args = (struct die_args )ptr;
339	struct pt_regs *regs = args->regs;
340
341	#ifdef CONFIG_KPROBES
342	/*
343	* Return immediately if the kprobes fault notifier has set
344	* DIE_PAGE_FAULT.
345	*/
346	if (cmd == DIE_PAGE_FAULT)
347	return NOTIFY_DONE;
348	#endif /* CONFIG_KPROBES */
349
350	switch (cmd) {
351	case DIE_BREAK:
352	case DIE_COMPILED_BPT:
353	break;
354	case DIE_SSTEPBP:
355	local_irq_save(flags);
356	kgdb_handle_exception(0, SIGTRAP, 0, regs);
357	local_irq_restore(flags);
358	return NOTIFY_STOP;
359	default:
360	/* Userspace events, ignore. */
361	if (user_mode(regs))
362	return NOTIFY_DONE;
363	}
364
365	local_irq_save(flags);
366	ret = kgdb_handle_exception(args->trapnr, args->signr, args->err, regs);
367	local_irq_restore(flags);
368	if (ret)
369	return NOTIFY_DONE;
370
371	return NOTIFY_STOP;
372	}
373
374	static struct notifier_block kgdb_notifier = {
375	.notifier_call = kgdb_notify,
376	};
377
378	/*
379	* kgdb_arch_handle_exception - Handle architecture specific GDB packets.
380	* @vector: The error vector of the exception that happened.
381	* @signo: The signal number of the exception that happened.
382	* @err_code: The error code of the exception that happened.
383	* @remcom_in_buffer: The buffer of the packet we have read.
384	* @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
385	* @regs: The &struct pt_regs of the current process.
386	*
387	* This function MUST handle the 'c' and 's' command packets,
388	* as well packets to set / remove a hardware breakpoint, if used.
389	* If there are additional packets which the hardware needs to handle,
390	* they are handled here. The code should return -1 if it wants to
391	* process more packets, and a %0 or %1 if it wants to exit from the
392	* kgdb callback.
393	*/
394	int kgdb_arch_handle_exception(int vector, int signo, int err_code,
395	char remcom_in_buffer, char remcom_out_buffer,
396	struct pt_regs *regs)
397	{
398	char *ptr;
399	unsigned long address;
400
401	/* Undo any stepping we may have done. */
402	undo_single_step(regs);
403
404	switch (remcom_in_buffer[0]) {
405	case 'c':
406	case 's':
407	case 'D':
408	case 'k':
409	/*
410	* Try to read optional parameter, pc unchanged if no parm.
411	* If this was a compiled-in breakpoint, we need to move
412	* to the next instruction or we will just breakpoint
413	* over and over again.
414	*/
415	ptr = &remcom_in_buffer[1];
416	if (kgdb_hex2long(&ptr, &address))
417	regs->pc = address;
418	else if ((unsigned long )regs->pc == compiled_bpt)
419	regs->pc += BREAK_INSTR_SIZE;
420
421	if (remcom_in_buffer[0] == 's') {
422	do_single_step(regs);
423	kgdb_single_step = 1;
424	atomic_set(&kgdb_cpu_doing_single_step,
425	raw_smp_processor_id());
426	} else
427	atomic_set(&kgdb_cpu_doing_single_step, -1);
428
429	return 0;
430	}
431
432	return -1; /* this means that we do not want to exit from the handler */
433	}
434
435	struct kgdb_arch arch_kgdb_ops;
436
437	/*
35b90a29	438	* kgdb_arch_init - Perform any architecture specific initialization.
8157107b	439	*
35b90a29	440	* This function will handle the initialization of any architecture
8157107b CM	441	* specific callbacks.
	442	*/
	443	int kgdb_arch_init(void)
	444	{
	445	tile_bundle_bits bundle = TILEGX_BPT_BUNDLE;
	446
	447	memcpy(arch_kgdb_ops.gdb_bpt_instr, &bundle, BREAK_INSTR_SIZE);
	448	return register_die_notifier(&kgdb_notifier);
	449	}
	450
	451	/*
35b90a29	452	* kgdb_arch_exit - Perform any architecture specific uninitialization.
8157107b	453	*
35b90a29	454	* This function will handle the uninitialization of any architecture
8157107b CM	455	* specific callbacks, for dynamic registration and unregistration.
	456	*/
	457	void kgdb_arch_exit(void)
	458	{
	459	unregister_die_notifier(&kgdb_notifier);
	460	}
	461
	462	int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
	463	{
	464	int err;
	465	unsigned long addr_wr = writable_address(bpt->bpt_addr);
	466
	467	if (addr_wr == 0)
	468	return -1;
	469
	470	err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
	471	BREAK_INSTR_SIZE);
	472	if (err)
	473	return err;
	474
	475	err = probe_kernel_write((char *)addr_wr, arch_kgdb_ops.gdb_bpt_instr,
	476	BREAK_INSTR_SIZE);
	477	smp_wmb();
	478	flush_icache_range((unsigned long)bpt->bpt_addr,
	479	(unsigned long)bpt->bpt_addr + BREAK_INSTR_SIZE);
	480	return err;
	481	}
	482
	483	int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
	484	{
	485	int err;
	486	unsigned long addr_wr = writable_address(bpt->bpt_addr);
	487
	488	if (addr_wr == 0)
	489	return -1;
	490
	491	err = probe_kernel_write((char )addr_wr, (char )bpt->saved_instr,
	492	BREAK_INSTR_SIZE);
	493	smp_wmb();
	494	flush_icache_range((unsigned long)bpt->bpt_addr,
	495	(unsigned long)bpt->bpt_addr + BREAK_INSTR_SIZE);
	496	return err;
	497	}