1 files changed, 105 insertions, 25 deletions

diff --git a/arch/tile/kernel/traps.c b/arch/tile/kernel/traps.c
index 12cb10f38527..3870abbeeaa2 100644
--- a/arch/tile/kernel/traps.c
+++ b/arch/tile/kernel/traps.c
@@ -20,6 +20,9 @@
 #include <linux/uaccess.h>
 #include <linux/ptrace.h>
 #include <asm/opcode-tile.h>
+#include <asm/opcode_constants.h>
+#include <asm/stack.h>
+#include <asm/traps.h>
 
 #include <arch/interrupts.h>
 #include <arch/spr_def.h>
@@ -42,7 +45,7 @@ static int __init setup_unaligned_fixup(char *str)
 	if (strict_strtol(str, 0, &val) != 0)
 		return 0;
 	unaligned_fixup = val;
-	printk("Fixups for unaligned data accesses are %s\n",
+	pr_info("Fixups for unaligned data accesses are %s\n",
 	       unaligned_fixup >= 0 ?
 	       (unaligned_fixup ? "enabled" : "disabled") :
 	       "completely disabled");
@@ -56,7 +59,7 @@ static int dma_disabled;
 
 static int __init nodma(char *str)
 {
-	printk("User-space DMA is disabled\n");
+	pr_info("User-space DMA is disabled\n");
 	dma_disabled = 1;
 	return 1;
 }
@@ -97,20 +100,106 @@ static int retry_gpv(unsigned int gpv_reason)
 
 #endif /* CHIP_HAS_TILE_DMA() */
 
-/* Defined inside do_trap(), below. */
 #ifdef __tilegx__
-extern tilegx_bundle_bits bpt_code;
+#define bundle_bits tilegx_bundle_bits
 #else
-extern tile_bundle_bits bpt_code;
+#define bundle_bits tile_bundle_bits
 #endif
 
+extern bundle_bits bpt_code;
+
+asm(".pushsection .rodata.bpt_code,\"a\";"
+    ".align 8;"
+    "bpt_code: bpt;"
+    ".size bpt_code,.-bpt_code;"
+    ".popsection");
+
+static int special_ill(bundle_bits bundle, int *sigp, int *codep)
+{
+	int sig, code, maxcode;
+
+	if (bundle == bpt_code) {
+		*sigp = SIGTRAP;
+		*codep = TRAP_BRKPT;
+		return 1;
+	}
+
+	/* If it's a "raise" bundle, then "ill" must be in pipe X1. */
+#ifdef __tilegx__
+	if ((bundle & TILEGX_BUNDLE_MODE_MASK) != 0)
+		return 0;
+	if (get_Opcode_X1(bundle) != UNARY_OPCODE_X1)
+		return 0;
+	if (get_UnaryOpcodeExtension_X1(bundle) != ILL_UNARY_OPCODE_X1)
+		return 0;
+#else
+	if (bundle & TILE_BUNDLE_Y_ENCODING_MASK)
+		return 0;
+	if (get_Opcode_X1(bundle) != SHUN_0_OPCODE_X1)
+		return 0;
+	if (get_UnShOpcodeExtension_X1(bundle) != UN_0_SHUN_0_OPCODE_X1)
+		return 0;
+	if (get_UnOpcodeExtension_X1(bundle) != ILL_UN_0_SHUN_0_OPCODE_X1)
+		return 0;
+#endif
+
+	/* Check that the magic distinguishers are set to mean "raise". */
+	if (get_Dest_X1(bundle) != 29 || get_SrcA_X1(bundle) != 37)
+		return 0;
+
+	/* There must be an "addli zero, zero, VAL" in X0. */
+	if (get_Opcode_X0(bundle) != ADDLI_OPCODE_X0)
+		return 0;
+	if (get_Dest_X0(bundle) != TREG_ZERO)
+		return 0;
+	if (get_SrcA_X0(bundle) != TREG_ZERO)
+		return 0;
+
+	/*
+	 * Validate the proposed signal number and si_code value.
+	 * Note that we embed these in the static instruction itself
+	 * so that we perturb the register state as little as possible
+	 * at the time of the actual fault; it's unlikely you'd ever
+	 * need to dynamically choose which kind of fault to raise
+	 * from user space.
+	 */
+	sig = get_Imm16_X0(bundle) & 0x3f;
+	switch (sig) {
+	case SIGILL:
+		maxcode = NSIGILL;
+		break;
+	case SIGFPE:
+		maxcode = NSIGFPE;
+		break;
+	case SIGSEGV:
+		maxcode = NSIGSEGV;
+		break;
+	case SIGBUS:
+		maxcode = NSIGBUS;
+		break;
+	case SIGTRAP:
+		maxcode = NSIGTRAP;
+		break;
+	default:
+		return 0;
+	}
+	code = (get_Imm16_X0(bundle) >> 6) & 0xf;
+	if (code <= 0 || code > maxcode)
+		return 0;
+
+	/* Make it the requested signal. */
+	*sigp = sig;
+	*codep = code | __SI_FAULT;
+	return 1;
+}
+
 void __kprobes do_trap(struct pt_regs *regs, int fault_num,
 		       unsigned long reason)
 {
 	siginfo_t info = { 0 };
 	int signo, code;
 	unsigned long address;
-	__typeof__(bpt_code) instr;
+	bundle_bits instr;
 
 	/* Re-enable interrupts. */
 	local_irq_enable();
@@ -122,10 +211,10 @@ void __kprobes do_trap(struct pt_regs *regs, int fault_num,
 	if (!user_mode(regs)) {
 		if (fixup_exception(regs))  /* only UNALIGN_DATA in practice */
 			return;
-		printk(KERN_ALERT "Kernel took bad trap %d at PC %#lx\n",
+		pr_alert("Kernel took bad trap %d at PC %#lx\n",
 		       fault_num, regs->pc);
 		if (fault_num == INT_GPV)
-			printk(KERN_ALERT "GPV_REASON is %#lx\n", reason);
+			pr_alert("GPV_REASON is %#lx\n", reason);
 		show_regs(regs);
 		do_exit(SIGKILL);  /* FIXME: implement i386 die() */
 		return;
@@ -133,22 +222,14 @@ void __kprobes do_trap(struct pt_regs *regs, int fault_num,
 
 	switch (fault_num) {
 	case INT_ILL:
-		asm(".pushsection .rodata.bpt_code,\"a\";"
-		    ".align 8;"
-		    "bpt_code: bpt;"
-		    ".size bpt_code,.-bpt_code;"
-		    ".popsection");
-
-		if (copy_from_user(&instr, (void *)regs->pc, sizeof(instr))) {
-			printk(KERN_ERR "Unreadable instruction for INT_ILL:"
+		if (copy_from_user(&instr, (void __user *)regs->pc,
+				   sizeof(instr))) {
+			pr_err("Unreadable instruction for INT_ILL:"
 			       " %#lx\n", regs->pc);
 			do_exit(SIGKILL);
 			return;
 		}
-		if (instr == bpt_code) {
-			signo = SIGTRAP;
-			code = TRAP_BRKPT;
-		} else {
+		if (!special_ill(instr, &signo, &code)) {
 			signo = SIGILL;
 			code = ILL_ILLOPC;
 		}
@@ -181,7 +262,8 @@ void __kprobes do_trap(struct pt_regs *regs, int fault_num,
 		if (unaligned_fixup >= 0) {
 			struct single_step_state *state =
 				current_thread_info()->step_state;
-			if (!state || (void *)(regs->pc) != state->buffer) {
+			if (!state ||
+			    (void __user *)(regs->pc) != state->buffer) {
 				single_step_once(regs);
 				return;
 			}
@@ -221,17 +303,15 @@ void __kprobes do_trap(struct pt_regs *regs, int fault_num,
 
 	info.si_signo = signo;
 	info.si_code = code;
-	info.si_addr = (void *)address;
+	info.si_addr = (void __user *)address;
 	if (signo == SIGILL)
 		info.si_trapno = fault_num;
 	force_sig_info(signo, &info, current);
 }
 
-extern void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52);
-
 void kernel_double_fault(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
 {
 	_dump_stack(dummy, pc, lr, sp, r52);
-	printk("Double fault: exiting\n");
+	pr_emerg("Double fault: exiting\n");
 	machine_halt();
 }