1 /*
2 * Copyright 2010 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
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/kprobes.h>
18 #include <linux/kdebug.h>
19 #include <linux/module.h>
20 #include <linux/reboot.h>
21 #include <linux/uaccess.h>
22 #include <linux/ptrace.h>
23 #include <linux/context_tracking.h>
24 #include <asm/stack.h>
25 #include <asm/traps.h>
26 #include <asm/setup.h>
27
28 #include <arch/interrupts.h>
29 #include <arch/spr_def.h>
30 #include <arch/opcode.h>
31
trap_init(void)32 void __init trap_init(void)
33 {
34 /* Nothing needed here since we link code at .intrpt */
35 }
36
37 int unaligned_fixup = 1;
38
setup_unaligned_fixup(char * str)39 static int __init setup_unaligned_fixup(char *str)
40 {
41 /*
42 * Say "=-1" to completely disable it. If you just do "=0", we
43 * will still parse the instruction, then fire a SIGBUS with
44 * the correct address from inside the single_step code.
45 */
46 if (kstrtoint(str, 0, &unaligned_fixup) != 0)
47 return 0;
48
49 pr_info("Fixups for unaligned data accesses are %s\n",
50 unaligned_fixup >= 0 ?
51 (unaligned_fixup ? "enabled" : "disabled") :
52 "completely disabled");
53 return 1;
54 }
55 __setup("unaligned_fixup=", setup_unaligned_fixup);
56
57 #if CHIP_HAS_TILE_DMA()
58
59 static int dma_disabled;
60
nodma(char * str)61 static int __init nodma(char *str)
62 {
63 pr_info("User-space DMA is disabled\n");
64 dma_disabled = 1;
65 return 1;
66 }
67 __setup("nodma", nodma);
68
69 /* How to decode SPR_GPV_REASON */
70 #define IRET_ERROR (1U << 31)
71 #define MT_ERROR (1U << 30)
72 #define MF_ERROR (1U << 29)
73 #define SPR_INDEX ((1U << 15) - 1)
74 #define SPR_MPL_SHIFT 9 /* starting bit position for MPL encoded in SPR */
75
76 /*
77 * See if this GPV is just to notify the kernel of SPR use and we can
78 * retry the user instruction after adjusting some MPLs suitably.
79 */
retry_gpv(unsigned int gpv_reason)80 static int retry_gpv(unsigned int gpv_reason)
81 {
82 int mpl;
83
84 if (gpv_reason & IRET_ERROR)
85 return 0;
86
87 BUG_ON((gpv_reason & (MT_ERROR|MF_ERROR)) == 0);
88 mpl = (gpv_reason & SPR_INDEX) >> SPR_MPL_SHIFT;
89 if (mpl == INT_DMA_NOTIFY && !dma_disabled) {
90 /* User is turning on DMA. Allow it and retry. */
91 printk(KERN_DEBUG "Process %d/%s is now enabled for DMA\n",
92 current->pid, current->comm);
93 BUG_ON(current->thread.tile_dma_state.enabled);
94 current->thread.tile_dma_state.enabled = 1;
95 grant_dma_mpls();
96 return 1;
97 }
98
99 return 0;
100 }
101
102 #endif /* CHIP_HAS_TILE_DMA() */
103
104 extern tile_bundle_bits bpt_code;
105
106 asm(".pushsection .rodata.bpt_code,\"a\";"
107 ".align 8;"
108 "bpt_code: bpt;"
109 ".size bpt_code,.-bpt_code;"
110 ".popsection");
111
special_ill(tile_bundle_bits bundle,int * sigp,int * codep)112 static int special_ill(tile_bundle_bits bundle, int *sigp, int *codep)
113 {
114 int sig, code, maxcode;
115
116 if (bundle == bpt_code) {
117 *sigp = SIGTRAP;
118 *codep = TRAP_BRKPT;
119 return 1;
120 }
121
122 /* If it's a "raise" bundle, then "ill" must be in pipe X1. */
123 #ifdef __tilegx__
124 if ((bundle & TILEGX_BUNDLE_MODE_MASK) != 0)
125 return 0;
126 if (get_Opcode_X1(bundle) != RRR_0_OPCODE_X1)
127 return 0;
128 if (get_RRROpcodeExtension_X1(bundle) != UNARY_RRR_0_OPCODE_X1)
129 return 0;
130 if (get_UnaryOpcodeExtension_X1(bundle) != ILL_UNARY_OPCODE_X1)
131 return 0;
132 #else
133 if (bundle & TILEPRO_BUNDLE_Y_ENCODING_MASK)
134 return 0;
135 if (get_Opcode_X1(bundle) != SHUN_0_OPCODE_X1)
136 return 0;
137 if (get_UnShOpcodeExtension_X1(bundle) != UN_0_SHUN_0_OPCODE_X1)
138 return 0;
139 if (get_UnOpcodeExtension_X1(bundle) != ILL_UN_0_SHUN_0_OPCODE_X1)
140 return 0;
141 #endif
142
143 /* Check that the magic distinguishers are set to mean "raise". */
144 if (get_Dest_X1(bundle) != 29 || get_SrcA_X1(bundle) != 37)
145 return 0;
146
147 /* There must be an "addli zero, zero, VAL" in X0. */
148 if (get_Opcode_X0(bundle) != ADDLI_OPCODE_X0)
149 return 0;
150 if (get_Dest_X0(bundle) != TREG_ZERO)
151 return 0;
152 if (get_SrcA_X0(bundle) != TREG_ZERO)
153 return 0;
154
155 /*
156 * Validate the proposed signal number and si_code value.
157 * Note that we embed these in the static instruction itself
158 * so that we perturb the register state as little as possible
159 * at the time of the actual fault; it's unlikely you'd ever
160 * need to dynamically choose which kind of fault to raise
161 * from user space.
162 */
163 sig = get_Imm16_X0(bundle) & 0x3f;
164 switch (sig) {
165 case SIGILL:
166 maxcode = NSIGILL;
167 break;
168 case SIGFPE:
169 maxcode = NSIGFPE;
170 break;
171 case SIGSEGV:
172 maxcode = NSIGSEGV;
173 break;
174 case SIGBUS:
175 maxcode = NSIGBUS;
176 break;
177 case SIGTRAP:
178 maxcode = NSIGTRAP;
179 break;
180 default:
181 return 0;
182 }
183 code = (get_Imm16_X0(bundle) >> 6) & 0xf;
184 if (code <= 0 || code > maxcode)
185 return 0;
186
187 /* Make it the requested signal. */
188 *sigp = sig;
189 *codep = code | __SI_FAULT;
190 return 1;
191 }
192
193 static const char *const int_name[] = {
194 [INT_MEM_ERROR] = "Memory error",
195 [INT_ILL] = "Illegal instruction",
196 [INT_GPV] = "General protection violation",
197 [INT_UDN_ACCESS] = "UDN access",
198 [INT_IDN_ACCESS] = "IDN access",
199 #if CHIP_HAS_SN()
200 [INT_SN_ACCESS] = "SN access",
201 #endif
202 [INT_SWINT_3] = "Software interrupt 3",
203 [INT_SWINT_2] = "Software interrupt 2",
204 [INT_SWINT_0] = "Software interrupt 0",
205 [INT_UNALIGN_DATA] = "Unaligned data",
206 [INT_DOUBLE_FAULT] = "Double fault",
207 #ifdef __tilegx__
208 [INT_ILL_TRANS] = "Illegal virtual address",
209 #endif
210 };
211
do_bpt(struct pt_regs * regs)212 static int do_bpt(struct pt_regs *regs)
213 {
214 unsigned long bundle, bcode, bpt;
215
216 bundle = *(unsigned long *)instruction_pointer(regs);
217
218 /*
219 * bpt shoule be { bpt; nop }, which is 0x286a44ae51485000ULL.
220 * we encode the unused least significant bits for other purpose.
221 */
222 bpt = bundle & ~((1ULL << 12) - 1);
223 if (bpt != TILE_BPT_BUNDLE)
224 return 0;
225
226 bcode = bundle & ((1ULL << 12) - 1);
227 /*
228 * notify the kprobe handlers, if instruction is likely to
229 * pertain to them.
230 */
231 switch (bcode) {
232 /* breakpoint_insn */
233 case 0:
234 notify_die(DIE_BREAK, "debug", regs, bundle,
235 INT_ILL, SIGTRAP);
236 break;
237 /* compiled_bpt */
238 case DIE_COMPILED_BPT:
239 notify_die(DIE_COMPILED_BPT, "debug", regs, bundle,
240 INT_ILL, SIGTRAP);
241 break;
242 /* breakpoint2_insn */
243 case DIE_SSTEPBP:
244 notify_die(DIE_SSTEPBP, "single_step", regs, bundle,
245 INT_ILL, SIGTRAP);
246 break;
247 default:
248 return 0;
249 }
250
251 return 1;
252 }
253
do_trap(struct pt_regs * regs,int fault_num,unsigned long reason)254 void __kprobes do_trap(struct pt_regs *regs, int fault_num,
255 unsigned long reason)
256 {
257 enum ctx_state prev_state = exception_enter();
258 siginfo_t info = { 0 };
259 int signo, code;
260 unsigned long address = 0;
261 tile_bundle_bits instr;
262 int is_kernel = !user_mode(regs);
263
264 /* Handle breakpoints, etc. */
265 if (is_kernel && fault_num == INT_ILL && do_bpt(regs))
266 goto done;
267
268 /* Re-enable interrupts, if they were previously enabled. */
269 if (!(regs->flags & PT_FLAGS_DISABLE_IRQ))
270 local_irq_enable();
271
272 /*
273 * If it hits in kernel mode and we can't fix it up, just exit the
274 * current process and hope for the best.
275 */
276 if (is_kernel) {
277 const char *name;
278 char buf[100];
279 if (fixup_exception(regs)) /* ILL_TRANS or UNALIGN_DATA */
280 goto done;
281 if (fault_num >= 0 &&
282 fault_num < ARRAY_SIZE(int_name) &&
283 int_name[fault_num] != NULL)
284 name = int_name[fault_num];
285 else
286 name = "Unknown interrupt";
287 if (fault_num == INT_GPV)
288 snprintf(buf, sizeof(buf), "; GPV_REASON %#lx", reason);
289 #ifdef __tilegx__
290 else if (fault_num == INT_ILL_TRANS)
291 snprintf(buf, sizeof(buf), "; address %#lx", reason);
292 #endif
293 else
294 buf[0] = '\0';
295 pr_alert("Kernel took bad trap %d (%s) at PC %#lx%s\n",
296 fault_num, name, regs->pc, buf);
297 show_regs(regs);
298 do_exit(SIGKILL); /* FIXME: implement i386 die() */
299 }
300
301 switch (fault_num) {
302 case INT_MEM_ERROR:
303 signo = SIGBUS;
304 code = BUS_OBJERR;
305 break;
306 case INT_ILL:
307 if (copy_from_user(&instr, (void __user *)regs->pc,
308 sizeof(instr))) {
309 pr_err("Unreadable instruction for INT_ILL: %#lx\n",
310 regs->pc);
311 do_exit(SIGKILL);
312 }
313 if (!special_ill(instr, &signo, &code)) {
314 signo = SIGILL;
315 code = ILL_ILLOPC;
316 }
317 address = regs->pc;
318 break;
319 case INT_GPV:
320 #if CHIP_HAS_TILE_DMA()
321 if (retry_gpv(reason))
322 goto done;
323 #endif
324 /*FALLTHROUGH*/
325 case INT_UDN_ACCESS:
326 case INT_IDN_ACCESS:
327 #if CHIP_HAS_SN()
328 case INT_SN_ACCESS:
329 #endif
330 signo = SIGILL;
331 code = ILL_PRVREG;
332 address = regs->pc;
333 break;
334 case INT_SWINT_3:
335 case INT_SWINT_2:
336 case INT_SWINT_0:
337 signo = SIGILL;
338 code = ILL_ILLTRP;
339 address = regs->pc;
340 break;
341 case INT_UNALIGN_DATA:
342 #ifndef __tilegx__ /* Emulated support for single step debugging */
343 if (unaligned_fixup >= 0) {
344 struct single_step_state *state =
345 current_thread_info()->step_state;
346 if (!state ||
347 (void __user *)(regs->pc) != state->buffer) {
348 single_step_once(regs);
349 goto done;
350 }
351 }
352 #endif
353 signo = SIGBUS;
354 code = BUS_ADRALN;
355 address = 0;
356 break;
357 case INT_DOUBLE_FAULT:
358 /*
359 * For double fault, "reason" is actually passed as
360 * SYSTEM_SAVE_K_2, the hypervisor's double-fault info, so
361 * we can provide the original fault number rather than
362 * the uninteresting "INT_DOUBLE_FAULT" so the user can
363 * learn what actually struck while PL0 ICS was set.
364 */
365 fault_num = reason;
366 signo = SIGILL;
367 code = ILL_DBLFLT;
368 address = regs->pc;
369 break;
370 #ifdef __tilegx__
371 case INT_ILL_TRANS: {
372 /* Avoid a hardware erratum with the return address stack. */
373 fill_ra_stack();
374
375 signo = SIGSEGV;
376 address = reason;
377 code = SEGV_MAPERR;
378 break;
379 }
380 #endif
381 default:
382 panic("Unexpected do_trap interrupt number %d", fault_num);
383 }
384
385 info.si_signo = signo;
386 info.si_code = code;
387 info.si_addr = (void __user *)address;
388 if (signo == SIGILL)
389 info.si_trapno = fault_num;
390 if (signo != SIGTRAP)
391 trace_unhandled_signal("trap", regs, address, signo);
392 force_sig_info(signo, &info, current);
393
394 done:
395 exception_exit(prev_state);
396 }
397
do_nmi(struct pt_regs * regs,int fault_num,unsigned long reason)398 void do_nmi(struct pt_regs *regs, int fault_num, unsigned long reason)
399 {
400 switch (reason) {
401 case TILE_NMI_DUMP_STACK:
402 do_nmi_dump_stack(regs);
403 break;
404 default:
405 panic("Unexpected do_nmi type %ld", reason);
406 return;
407 }
408 }
409
410 /* Deprecated function currently only used here. */
411 extern void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52);
412
kernel_double_fault(int dummy,ulong pc,ulong lr,ulong sp,ulong r52)413 void kernel_double_fault(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
414 {
415 _dump_stack(dummy, pc, lr, sp, r52);
416 pr_emerg("Double fault: exiting\n");
417 machine_halt();
418 }
419