1 /* 2 * Kernel traps/events for Hexagon processor 3 * 4 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 and 8 * only version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18 * 02110-1301, USA. 19 */ 20 21 #include <linux/init.h> 22 #include <linux/sched.h> 23 #include <linux/module.h> 24 #include <linux/kallsyms.h> 25 #include <linux/kdebug.h> 26 #include <linux/syscalls.h> 27 #include <linux/signal.h> 28 #include <linux/tracehook.h> 29 #include <asm/traps.h> 30 #include <asm/vm_fault.h> 31 #include <asm/syscall.h> 32 #include <asm/registers.h> 33 #include <asm/unistd.h> 34 #include <asm/sections.h> 35 #ifdef CONFIG_KGDB 36 # include <linux/kgdb.h> 37 #endif 38 39 #define TRAP_SYSCALL 1 40 #define TRAP_DEBUG 0xdb 41 42 void __init trap_init(void) 43 { 44 } 45 46 #ifdef CONFIG_GENERIC_BUG 47 /* Maybe should resemble arch/sh/kernel/traps.c ?? */ 48 int is_valid_bugaddr(unsigned long addr) 49 { 50 return 1; 51 } 52 #endif /* CONFIG_GENERIC_BUG */ 53 54 static const char *ex_name(int ex) 55 { 56 switch (ex) { 57 case HVM_GE_C_XPROT: 58 case HVM_GE_C_XUSER: 59 return "Execute protection fault"; 60 case HVM_GE_C_RPROT: 61 case HVM_GE_C_RUSER: 62 return "Read protection fault"; 63 case HVM_GE_C_WPROT: 64 case HVM_GE_C_WUSER: 65 return "Write protection fault"; 66 case HVM_GE_C_XMAL: 67 return "Misaligned instruction"; 68 case HVM_GE_C_WREG: 69 return "Multiple writes to same register in packet"; 70 case HVM_GE_C_PCAL: 71 return "Program counter values that are not properly aligned"; 72 case HVM_GE_C_RMAL: 73 return "Misaligned data load"; 74 case HVM_GE_C_WMAL: 75 return "Misaligned data store"; 76 case HVM_GE_C_INVI: 77 case HVM_GE_C_PRIVI: 78 return "Illegal instruction"; 79 case HVM_GE_C_BUS: 80 return "Precise bus error"; 81 case HVM_GE_C_CACHE: 82 return "Cache error"; 83 84 case 0xdb: 85 return "Debugger trap"; 86 87 default: 88 return "Unrecognized exception"; 89 } 90 } 91 92 static void do_show_stack(struct task_struct *task, unsigned long *fp, 93 unsigned long ip) 94 { 95 int kstack_depth_to_print = 24; 96 unsigned long offset, size; 97 const char *name = NULL; 98 unsigned long *newfp; 99 unsigned long low, high; 100 char tmpstr[128]; 101 char *modname; 102 int i; 103 104 if (task == NULL) 105 task = current; 106 107 printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n", 108 raw_smp_processor_id(), task->comm, 109 task_pid_nr(task)); 110 111 if (fp == NULL) { 112 if (task == current) { 113 asm("%0 = r30" : "=r" (fp)); 114 } else { 115 fp = (unsigned long *) 116 ((struct hexagon_switch_stack *) 117 task->thread.switch_sp)->fp; 118 } 119 } 120 121 if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) { 122 printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp); 123 return; 124 } 125 126 /* Saved link reg is one word above FP */ 127 if (!ip) 128 ip = *(fp+1); 129 130 /* Expect kernel stack to be in-bounds */ 131 low = (unsigned long)task_stack_page(task); 132 high = low + THREAD_SIZE - 8; 133 low += sizeof(struct thread_info); 134 135 for (i = 0; i < kstack_depth_to_print; i++) { 136 137 name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr); 138 139 printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name, 140 offset); 141 if (((unsigned long) fp < low) || (high < (unsigned long) fp)) 142 printk(KERN_CONT " (FP out of bounds!)"); 143 if (modname) 144 printk(KERN_CONT " [%s] ", modname); 145 printk(KERN_CONT "\n"); 146 147 newfp = (unsigned long *) *fp; 148 149 if (((unsigned long) newfp) & 0x3) { 150 printk(KERN_INFO "-- Corrupt frame pointer %p\n", 151 newfp); 152 break; 153 } 154 155 /* Attempt to continue past exception. */ 156 if (0 == newfp) { 157 struct pt_regs *regs = (struct pt_regs *) (((void *)fp) 158 + 8); 159 160 if (regs->syscall_nr != -1) { 161 printk(KERN_INFO "-- trap0 -- syscall_nr: %ld", 162 regs->syscall_nr); 163 printk(KERN_CONT " psp: %lx elr: %lx\n", 164 pt_psp(regs), pt_elr(regs)); 165 break; 166 } else { 167 /* really want to see more ... */ 168 kstack_depth_to_print += 6; 169 printk(KERN_INFO "-- %s (0x%lx) badva: %lx\n", 170 ex_name(pt_cause(regs)), pt_cause(regs), 171 pt_badva(regs)); 172 } 173 174 newfp = (unsigned long *) regs->r30; 175 ip = pt_elr(regs); 176 } else { 177 ip = *(newfp + 1); 178 } 179 180 /* If link reg is null, we are done. */ 181 if (ip == 0x0) 182 break; 183 184 /* If newfp isn't larger, we're tracing garbage. */ 185 if (newfp > fp) 186 fp = newfp; 187 else 188 break; 189 } 190 } 191 192 void show_stack(struct task_struct *task, unsigned long *fp) 193 { 194 /* Saved link reg is one word above FP */ 195 do_show_stack(task, fp, 0); 196 } 197 198 int die(const char *str, struct pt_regs *regs, long err) 199 { 200 static struct { 201 spinlock_t lock; 202 int counter; 203 } die = { 204 .lock = __SPIN_LOCK_UNLOCKED(die.lock), 205 .counter = 0 206 }; 207 208 console_verbose(); 209 oops_enter(); 210 211 spin_lock_irq(&die.lock); 212 bust_spinlocks(1); 213 printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter); 214 215 if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) == 216 NOTIFY_STOP) 217 return 1; 218 219 print_modules(); 220 show_regs(regs); 221 do_show_stack(current, ®s->r30, pt_elr(regs)); 222 223 bust_spinlocks(0); 224 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); 225 226 spin_unlock_irq(&die.lock); 227 228 if (in_interrupt()) 229 panic("Fatal exception in interrupt"); 230 231 if (panic_on_oops) 232 panic("Fatal exception"); 233 234 oops_exit(); 235 do_exit(err); 236 return 0; 237 } 238 239 int die_if_kernel(char *str, struct pt_regs *regs, long err) 240 { 241 if (!user_mode(regs)) 242 return die(str, regs, err); 243 else 244 return 0; 245 } 246 247 /* 248 * It's not clear that misaligned fetches are ever recoverable. 249 */ 250 static void misaligned_instruction(struct pt_regs *regs) 251 { 252 die_if_kernel("Misaligned Instruction", regs, 0); 253 force_sig(SIGBUS, current); 254 } 255 256 /* 257 * Misaligned loads and stores, on the other hand, can be 258 * emulated, and probably should be, some day. But for now 259 * they will be considered fatal. 260 */ 261 static void misaligned_data_load(struct pt_regs *regs) 262 { 263 die_if_kernel("Misaligned Data Load", regs, 0); 264 force_sig(SIGBUS, current); 265 } 266 267 static void misaligned_data_store(struct pt_regs *regs) 268 { 269 die_if_kernel("Misaligned Data Store", regs, 0); 270 force_sig(SIGBUS, current); 271 } 272 273 static void illegal_instruction(struct pt_regs *regs) 274 { 275 die_if_kernel("Illegal Instruction", regs, 0); 276 force_sig(SIGILL, current); 277 } 278 279 /* 280 * Precise bus errors may be recoverable with a a retry, 281 * but for now, treat them as irrecoverable. 282 */ 283 static void precise_bus_error(struct pt_regs *regs) 284 { 285 die_if_kernel("Precise Bus Error", regs, 0); 286 force_sig(SIGBUS, current); 287 } 288 289 /* 290 * If anything is to be done here other than panic, 291 * it will probably be complex and migrate to another 292 * source module. For now, just die. 293 */ 294 static void cache_error(struct pt_regs *regs) 295 { 296 die("Cache Error", regs, 0); 297 } 298 299 /* 300 * General exception handler 301 */ 302 void do_genex(struct pt_regs *regs) 303 { 304 /* 305 * Decode Cause and Dispatch 306 */ 307 switch (pt_cause(regs)) { 308 case HVM_GE_C_XPROT: 309 case HVM_GE_C_XUSER: 310 execute_protection_fault(regs); 311 break; 312 case HVM_GE_C_RPROT: 313 case HVM_GE_C_RUSER: 314 read_protection_fault(regs); 315 break; 316 case HVM_GE_C_WPROT: 317 case HVM_GE_C_WUSER: 318 write_protection_fault(regs); 319 break; 320 case HVM_GE_C_XMAL: 321 misaligned_instruction(regs); 322 break; 323 case HVM_GE_C_WREG: 324 illegal_instruction(regs); 325 break; 326 case HVM_GE_C_PCAL: 327 misaligned_instruction(regs); 328 break; 329 case HVM_GE_C_RMAL: 330 misaligned_data_load(regs); 331 break; 332 case HVM_GE_C_WMAL: 333 misaligned_data_store(regs); 334 break; 335 case HVM_GE_C_INVI: 336 case HVM_GE_C_PRIVI: 337 illegal_instruction(regs); 338 break; 339 case HVM_GE_C_BUS: 340 precise_bus_error(regs); 341 break; 342 case HVM_GE_C_CACHE: 343 cache_error(regs); 344 break; 345 default: 346 /* Halt and catch fire */ 347 panic("Unrecognized exception 0x%lx\n", pt_cause(regs)); 348 break; 349 } 350 } 351 352 /* Indirect system call dispatch */ 353 long sys_syscall(void) 354 { 355 printk(KERN_ERR "sys_syscall invoked!\n"); 356 return -ENOSYS; 357 } 358 359 void do_trap0(struct pt_regs *regs) 360 { 361 syscall_fn syscall; 362 363 switch (pt_cause(regs)) { 364 case TRAP_SYSCALL: 365 /* System call is trap0 #1 */ 366 367 /* allow strace to catch syscall args */ 368 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) && 369 tracehook_report_syscall_entry(regs))) 370 return; /* return -ENOSYS somewhere? */ 371 372 /* Interrupts should be re-enabled for syscall processing */ 373 __vmsetie(VM_INT_ENABLE); 374 375 /* 376 * System call number is in r6, arguments in r0..r5. 377 * Fortunately, no Linux syscall has more than 6 arguments, 378 * and Hexagon ABI passes first 6 arguments in registers. 379 * 64-bit arguments are passed in odd/even register pairs. 380 * Fortunately, we have no system calls that take more 381 * than three arguments with more than one 64-bit value. 382 * Should that change, we'd need to redesign to copy 383 * between user and kernel stacks. 384 */ 385 regs->syscall_nr = regs->r06; 386 387 /* 388 * GPR R0 carries the first parameter, and is also used 389 * to report the return value. We need a backup of 390 * the user's value in case we need to do a late restart 391 * of the system call. 392 */ 393 regs->restart_r0 = regs->r00; 394 395 if ((unsigned long) regs->syscall_nr >= __NR_syscalls) { 396 regs->r00 = -1; 397 } else { 398 syscall = (syscall_fn) 399 (sys_call_table[regs->syscall_nr]); 400 regs->r00 = syscall(regs->r00, regs->r01, 401 regs->r02, regs->r03, 402 regs->r04, regs->r05); 403 } 404 405 /* allow strace to get the syscall return state */ 406 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE))) 407 tracehook_report_syscall_exit(regs, 0); 408 409 break; 410 case TRAP_DEBUG: 411 /* Trap0 0xdb is debug breakpoint */ 412 if (user_mode(regs)) { 413 struct siginfo info; 414 415 info.si_signo = SIGTRAP; 416 info.si_errno = 0; 417 /* 418 * Some architecures add some per-thread state 419 * to distinguish between breakpoint traps and 420 * trace traps. We may want to do that, and 421 * set the si_code value appropriately, or we 422 * may want to use a different trap0 flavor. 423 */ 424 info.si_code = TRAP_BRKPT; 425 info.si_addr = (void __user *) pt_elr(regs); 426 send_sig_info(SIGTRAP, &info, current); 427 } else { 428 #ifdef CONFIG_KGDB 429 kgdb_handle_exception(pt_cause(regs), SIGTRAP, 430 TRAP_BRKPT, regs); 431 #endif 432 } 433 break; 434 } 435 /* Ignore other trap0 codes for now, especially 0 (Angel calls) */ 436 } 437 438 /* 439 * Machine check exception handler 440 */ 441 void do_machcheck(struct pt_regs *regs) 442 { 443 /* Halt and catch fire */ 444 __vmstop(); 445 } 446 447 /* 448 * Treat this like the old 0xdb trap. 449 */ 450 451 void do_debug_exception(struct pt_regs *regs) 452 { 453 regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK; 454 regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT); 455 do_trap0(regs); 456 } 457