arch/ppc64/kernel/traps.c

   1 /*
   2  *  linux/arch/ppc64/kernel/traps.c
   3  *
   4  *  Copyright (C) 1995-1996  Gary Thomas (gdt@linuxppc.org)
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License
   8  *  as published by the Free Software Foundation; either version
   9  *  2 of the License, or (at your option) any later version.
  10  *
  11  *  Modified by Cort Dougan (cort@cs.nmt.edu)
  12  *  and Paul Mackerras (paulus@cs.anu.edu.au)
  13  */
  14
  15 /*
  16  * This file handles the architecture-dependent parts of hardware exceptions
  17  */
  18
  19 #include <linux/config.h>
  20 #include <linux/errno.h>
  21 #include <linux/sched.h>
  22 #include <linux/kernel.h>
  23 #include <linux/mm.h>
  24 #include <linux/stddef.h>
  25 #include <linux/unistd.h>
  26 #include <linux/slab.h>
  27 #include <linux/user.h>
  28 #include <linux/a.out.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/init.h>
  31 #include <linux/module.h>
  32 #include <linux/delay.h>
  33 #include <asm/kdebug.h>
  34
  35 #include <asm/pgtable.h>
  36 #include <asm/uaccess.h>
  37 #include <asm/system.h>
  38 #include <asm/io.h>
  39 #include <asm/processor.h>
  40 #include <asm/ppcdebug.h>
  41 #include <asm/rtas.h>
  42 #include <asm/systemcfg.h>
  43 #include <asm/machdep.h>
  44 #include <asm/pmc.h>
  45
  46 #ifdef CONFIG_DEBUGGER
  47 int (*__debugger)(struct pt_regs *regs);
  48 int (*__debugger_ipi)(struct pt_regs *regs);
  49 int (*__debugger_bpt)(struct pt_regs *regs);
  50 int (*__debugger_sstep)(struct pt_regs *regs);
  51 int (*__debugger_iabr_match)(struct pt_regs *regs);
  52 int (*__debugger_dabr_match)(struct pt_regs *regs);
  53 int (*__debugger_fault_handler)(struct pt_regs *regs);
  54
  55 EXPORT_SYMBOL(__debugger);
  56 EXPORT_SYMBOL(__debugger_ipi);
  57 EXPORT_SYMBOL(__debugger_bpt);
  58 EXPORT_SYMBOL(__debugger_sstep);
  59 EXPORT_SYMBOL(__debugger_iabr_match);
  60 EXPORT_SYMBOL(__debugger_dabr_match);
  61 EXPORT_SYMBOL(__debugger_fault_handler);
  62 #endif
  63
  64 struct notifier_block *ppc64_die_chain;
  65 static DEFINE_SPINLOCK(die_notifier_lock);
  66
  67 int register_die_notifier(struct notifier_block *nb)
  68 {
  69         int err = 0;
  70         unsigned long flags;
  71
  72         spin_lock_irqsave(&die_notifier_lock, flags);
  73         err = notifier_chain_register(&ppc64_die_chain, nb);
  74         spin_unlock_irqrestore(&die_notifier_lock, flags);
  75         return err;
  76 }
  77
  78 /*
  79  * Trap & Exception support
  80  */
  81
  82 static DEFINE_SPINLOCK(die_lock);
  83
  84 int die(const char *str, struct pt_regs *regs, long err)
  85 {
  86         static int die_counter;
  87         int nl = 0;
  88
  89         if (debugger(regs))
  90                 return 1;
  91
  92         console_verbose();
  93         spin_lock_irq(&die_lock);
  94         bust_spinlocks(1);
  95         printk("Oops: %s, sig: %ld [#%d]\n", str, err, ++die_counter);
  96 #ifdef CONFIG_PREEMPT
  97         printk("PREEMPT ");
  98         nl = 1;
  99 #endif
 100 #ifdef CONFIG_SMP
 101         printk("SMP NR_CPUS=%d ", NR_CPUS);
 102         nl = 1;
 103 #endif
 104 #ifdef CONFIG_DEBUG_PAGEALLOC
 105         printk("DEBUG_PAGEALLOC ");
 106         nl = 1;
 107 #endif
 108 #ifdef CONFIG_NUMA
 109         printk("NUMA ");
 110         nl = 1;
 111 #endif
 112         switch(systemcfg->platform) {
 113                 case PLATFORM_PSERIES:
 114                         printk("PSERIES ");
 115                         nl = 1;
 116                         break;
 117                 case PLATFORM_PSERIES_LPAR:
 118                         printk("PSERIES LPAR ");
 119                         nl = 1;
 120                         break;
 121                 case PLATFORM_ISERIES_LPAR:
 122                         printk("ISERIES LPAR ");
 123                         nl = 1;
 124                         break;
 125                 case PLATFORM_POWERMAC:
 126                         printk("POWERMAC ");
 127                         nl = 1;
 128                         break;
 129                 case PLATFORM_BPA:
 130                         printk("BPA ");
 131                         nl = 1;
 132                         break;
 133         }
 134         if (nl)
 135                 printk("\n");
 136         print_modules();
 137         show_regs(regs);
 138         bust_spinlocks(0);
 139         spin_unlock_irq(&die_lock);
 140
 141         if (in_interrupt())
 142                 panic("Fatal exception in interrupt");
 143
 144         if (panic_on_oops) {
 145                 printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
 146                 ssleep(5);
 147                 panic("Fatal exception");
 148         }
 149         do_exit(SIGSEGV);
 150
 151         return 0;
 152 }
 153
 154 void _exception(int signr, struct pt_regs *regs, int code, unsigned long addr)
 155 {
 156         siginfo_t info;
 157
 158         if (!user_mode(regs)) {
 159                 if (die("Exception in kernel mode", regs, signr))
 160                         return;
 161         }
 162
 163         memset(&info, 0, sizeof(info));
 164         info.si_signo = signr;
 165         info.si_code = code;
 166         info.si_addr = (void __user *) addr;
 167         force_sig_info(signr, &info, current);
 168 }
 169
 170 void system_reset_exception(struct pt_regs *regs)
 171 {
 172         /* See if any machine dependent calls */
 173         if (ppc_md.system_reset_exception)
 174                 ppc_md.system_reset_exception(regs);
 175
 176         die("System Reset", regs, 0);
 177
 178         /* Must die if the interrupt is not recoverable */
 179         if (!(regs->msr & MSR_RI))
 180                 panic("Unrecoverable System Reset");
 181
 182         /* What should we do here? We could issue a shutdown or hard reset. */
 183 }
 184
 185 void machine_check_exception(struct pt_regs *regs)
 186 {
 187         int recover = 0;
 188
 189         /* See if any machine dependent calls */
 190         if (ppc_md.machine_check_exception)
 191                 recover = ppc_md.machine_check_exception(regs);
 192
 193         if (recover)
 194                 return;
 195
 196         if (debugger_fault_handler(regs))
 197                 return;
 198         die("Machine check", regs, 0);
 199
 200         /* Must die if the interrupt is not recoverable */
 201         if (!(regs->msr & MSR_RI))
 202                 panic("Unrecoverable Machine check");
 203 }
 204
 205 void unknown_exception(struct pt_regs *regs)
 206 {
 207         printk("Bad trap at PC: %lx, SR: %lx, vector=%lx\n",
 208                regs->nip, regs->msr, regs->trap);
 209
 210         _exception(SIGTRAP, regs, 0, 0);
 211 }
 212
 213 void instruction_breakpoint_exception(struct pt_regs *regs)
 214 {
 215         if (notify_die(DIE_IABR_MATCH, "iabr_match", regs, 5,
 216                                         5, SIGTRAP) == NOTIFY_STOP)
 217                 return;
 218         if (debugger_iabr_match(regs))
 219                 return;
 220         _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip);
 221 }
 222
 223 void single_step_exception(struct pt_regs *regs)
 224 {
 225         regs->msr &= ~MSR_SE;  /* Turn off 'trace' bit */
 226
 227         if (notify_die(DIE_SSTEP, "single_step", regs, 5,
 228                                         5, SIGTRAP) == NOTIFY_STOP)
 229                 return;
 230         if (debugger_sstep(regs))
 231                 return;
 232
 233         _exception(SIGTRAP, regs, TRAP_TRACE, regs->nip);
 234 }
 235
 236 /*
 237  * After we have successfully emulated an instruction, we have to
 238  * check if the instruction was being single-stepped, and if so,
 239  * pretend we got a single-step exception.  This was pointed out
 240  * by Kumar Gala.  -- paulus
 241  */
 242 static inline void emulate_single_step(struct pt_regs *regs)
 243 {
 244         if (regs->msr & MSR_SE)
 245                 single_step_exception(regs);
 246 }
 247
 248 static void parse_fpe(struct pt_regs *regs)
 249 {
 250         int code = 0;
 251         unsigned long fpscr;
 252
 253         flush_fp_to_thread(current);
 254
 255         fpscr = current->thread.fpscr;
 256
 257         /* Invalid operation */
 258         if ((fpscr & FPSCR_VE) && (fpscr & FPSCR_VX))
 259                 code = FPE_FLTINV;
 260
 261         /* Overflow */
 262         else if ((fpscr & FPSCR_OE) && (fpscr & FPSCR_OX))
 263                 code = FPE_FLTOVF;
 264
 265         /* Underflow */
 266         else if ((fpscr & FPSCR_UE) && (fpscr & FPSCR_UX))
 267                 code = FPE_FLTUND;
 268
 269         /* Divide by zero */
 270         else if ((fpscr & FPSCR_ZE) && (fpscr & FPSCR_ZX))
 271                 code = FPE_FLTDIV;
 272
 273         /* Inexact result */
 274         else if ((fpscr & FPSCR_XE) && (fpscr & FPSCR_XX))
 275                 code = FPE_FLTRES;
 276
 277         _exception(SIGFPE, regs, code, regs->nip);
 278 }
 279
 280 /*
 281  * Illegal instruction emulation support.  Return non-zero if we can't
 282  * emulate, or -EFAULT if the associated memory access caused an access
 283  * fault.  Return zero on success.
 284  */
 285
 286 #define INST_MFSPR_PVR          0x7c1f42a6
 287 #define INST_MFSPR_PVR_MASK     0xfc1fffff
 288
 289 #define INST_DCBA               0x7c0005ec
 290 #define INST_DCBA_MASK          0x7c0007fe
 291
 292 #define INST_MCRXR              0x7c000400
 293 #define INST_MCRXR_MASK         0x7c0007fe
 294
 295 static int emulate_instruction(struct pt_regs *regs)
 296 {
 297         unsigned int instword;
 298
 299         if (!user_mode(regs))
 300                 return -EINVAL;
 301
 302         CHECK_FULL_REGS(regs);
 303
 304         if (get_user(instword, (unsigned int __user *)(regs->nip)))
 305                 return -EFAULT;
 306
 307         /* Emulate the mfspr rD, PVR. */
 308         if ((instword & INST_MFSPR_PVR_MASK) == INST_MFSPR_PVR) {
 309                 unsigned int rd;
 310
 311                 rd = (instword >> 21) & 0x1f;
 312                 regs->gpr[rd] = mfspr(SPRN_PVR);
 313                 return 0;
 314         }
 315
 316         /* Emulating the dcba insn is just a no-op.  */
 317         if ((instword & INST_DCBA_MASK) == INST_DCBA) {
 318                 static int warned;
 319
 320                 if (!warned) {
 321                         printk(KERN_WARNING
 322                                "process %d (%s) uses obsolete 'dcba' insn\n",
 323                                current->pid, current->comm);
 324                         warned = 1;
 325                 }
 326                 return 0;
 327         }
 328
 329         /* Emulate the mcrxr insn.  */
 330         if ((instword & INST_MCRXR_MASK) == INST_MCRXR) {
 331                 static int warned;
 332                 unsigned int shift;
 333
 334                 if (!warned) {
 335                         printk(KERN_WARNING
 336                                "process %d (%s) uses obsolete 'mcrxr' insn\n",
 337                                current->pid, current->comm);
 338                         warned = 1;
 339                 }
 340
 341                 shift = (instword >> 21) & 0x1c;
 342                 regs->ccr &= ~(0xf0000000 >> shift);
 343                 regs->ccr |= (regs->xer & 0xf0000000) >> shift;
 344                 regs->xer &= ~0xf0000000;
 345                 return 0;
 346         }
 347
 348         return -EINVAL;
 349 }
 350
 351 /*
 352  * Look through the list of trap instructions that are used for BUG(),
 353  * BUG_ON() and WARN_ON() and see if we hit one.  At this point we know
 354  * that the exception was caused by a trap instruction of some kind.
 355  * Returns 1 if we should continue (i.e. it was a WARN_ON) or 0
 356  * otherwise.
 357  */
 358 extern struct bug_entry __start___bug_table[], __stop___bug_table[];
 359
 360 #ifndef CONFIG_MODULES
 361 #define module_find_bug(x)      NULL
 362 #endif
 363
 364 struct bug_entry *find_bug(unsigned long bugaddr)
 365 {
 366         struct bug_entry *bug;
 367
 368         for (bug = __start___bug_table; bug < __stop___bug_table; ++bug)
 369                 if (bugaddr == bug->bug_addr)
 370                         return bug;
 371         return module_find_bug(bugaddr);
 372 }
 373
 374 static int
 375 check_bug_trap(struct pt_regs *regs)
 376 {
 377         struct bug_entry *bug;
 378         unsigned long addr;
 379
 380         if (regs->msr & MSR_PR)
 381                 return 0;       /* not in kernel */
 382         addr = regs->nip;       /* address of trap instruction */
 383         if (addr < PAGE_OFFSET)
 384                 return 0;
 385         bug = find_bug(regs->nip);
 386         if (bug == NULL)
 387                 return 0;
 388         if (bug->line & BUG_WARNING_TRAP) {
 389                 /* this is a WARN_ON rather than BUG/BUG_ON */
 390                 printk(KERN_ERR "Badness in %s at %s:%d\n",
 391                        bug->function, bug->file,
 392                       (unsigned int)bug->line & ~BUG_WARNING_TRAP);
 393                 show_stack(current, (void *)regs->gpr[1]);
 394                 return 1;
 395         }
 396         printk(KERN_CRIT "kernel BUG in %s at %s:%d!\n",
 397                bug->function, bug->file, (unsigned int)bug->line);
 398         return 0;
 399 }
 400
 401 void program_check_exception(struct pt_regs *regs)
 402 {
 403         if (debugger_fault_handler(regs))
 404                 return;
 405
 406         if (regs->msr & 0x100000) {
 407                 /* IEEE FP exception */
 408                 parse_fpe(regs);
 409         } else if (regs->msr & 0x20000) {
 410                 /* trap exception */
 411
 412                 if (notify_die(DIE_BPT, "breakpoint", regs, 5,
 413                                         5, SIGTRAP) == NOTIFY_STOP)
 414                         return;
 415                 if (debugger_bpt(regs))
 416                         return;
 417
 418                 if (check_bug_trap(regs)) {
 419                         regs->nip += 4;
 420                         return;
 421                 }
 422                 _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip);
 423
 424         } else {
 425                 /* Privileged or illegal instruction; try to emulate it. */
 426                 switch (emulate_instruction(regs)) {
 427                 case 0:
 428                         regs->nip += 4;
 429                         emulate_single_step(regs);
 430                         break;
 431
 432                 case -EFAULT:
 433                         _exception(SIGSEGV, regs, SEGV_MAPERR, regs->nip);
 434                         break;
 435
 436                 default:
 437                         if (regs->msr & 0x40000)
 438                                 /* priveleged */
 439                                 _exception(SIGILL, regs, ILL_PRVOPC, regs->nip);
 440                         else
 441                                 /* illegal */
 442                                 _exception(SIGILL, regs, ILL_ILLOPC, regs->nip);
 443                         break;
 444                 }
 445         }
 446 }
 447
 448 void kernel_fp_unavailable_exception(struct pt_regs *regs)
 449 {
 450         printk(KERN_EMERG "Unrecoverable FP Unavailable Exception "
 451                           "%lx at %lx\n", regs->trap, regs->nip);
 452         die("Unrecoverable FP Unavailable Exception", regs, SIGABRT);
 453 }
 454
 455 void altivec_unavailable_exception(struct pt_regs *regs)
 456 {
 457         if (user_mode(regs)) {
 458                 /* A user program has executed an altivec instruction,
 459                    but this kernel doesn't support altivec. */
 460                 _exception(SIGILL, regs, ILL_ILLOPC, regs->nip);
 461                 return;
 462         }
 463         printk(KERN_EMERG "Unrecoverable VMX/Altivec Unavailable Exception "
 464                           "%lx at %lx\n", regs->trap, regs->nip);
 465         die("Unrecoverable VMX/Altivec Unavailable Exception", regs, SIGABRT);
 466 }
 467
 468 extern perf_irq_t perf_irq;
 469
 470 void performance_monitor_exception(struct pt_regs *regs)
 471 {
 472         perf_irq(regs);
 473 }
 474
 475 void alignment_exception(struct pt_regs *regs)
 476 {
 477         int fixed;
 478
 479         fixed = fix_alignment(regs);
 480
 481         if (fixed == 1) {
 482                 regs->nip += 4; /* skip over emulated instruction */
 483                 emulate_single_step(regs);
 484                 return;
 485         }
 486
 487         /* Operand address was bad */
 488         if (fixed == -EFAULT) {
 489                 if (user_mode(regs)) {
 490                         _exception(SIGSEGV, regs, SEGV_MAPERR, regs->dar);
 491                 } else {
 492                         /* Search exception table */
 493                         bad_page_fault(regs, regs->dar, SIGSEGV);
 494                 }
 495
 496                 return;
 497         }
 498
 499         _exception(SIGBUS, regs, BUS_ADRALN, regs->nip);
 500 }
 501
 502 #ifdef CONFIG_ALTIVEC
 503 void altivec_assist_exception(struct pt_regs *regs)
 504 {
 505         int err;
 506         siginfo_t info;
 507
 508         if (!user_mode(regs)) {
 509                 printk(KERN_EMERG "VMX/Altivec assist exception in kernel mode"
 510                        " at %lx\n", regs->nip);
 511                 die("Kernel VMX/Altivec assist exception", regs, SIGILL);
 512         }
 513
 514         flush_altivec_to_thread(current);
 515
 516         err = emulate_altivec(regs);
 517         if (err == 0) {
 518                 regs->nip += 4;         /* skip emulated instruction */
 519                 emulate_single_step(regs);
 520                 return;
 521         }
 522
 523         if (err == -EFAULT) {
 524                 /* got an error reading the instruction */
 525                 info.si_signo = SIGSEGV;
 526                 info.si_errno = 0;
 527                 info.si_code = SEGV_MAPERR;
 528                 info.si_addr = (void __user *) regs->nip;
 529                 force_sig_info(SIGSEGV, &info, current);
 530         } else {
 531                 /* didn't recognize the instruction */
 532                 /* XXX quick hack for now: set the non-Java bit in the VSCR */
 533                 if (printk_ratelimit())
 534                         printk(KERN_ERR "Unrecognized altivec instruction "
 535                                "in %s at %lx\n", current->comm, regs->nip);
 536                 current->thread.vscr.u[3] |= 0x10000;
 537         }
 538 }
 539 #endif /* CONFIG_ALTIVEC */
 540
 541 /*
 542  * We enter here if we get an unrecoverable exception, that is, one
 543  * that happened at a point where the RI (recoverable interrupt) bit
 544  * in the MSR is 0.  This indicates that SRR0/1 are live, and that
 545  * we therefore lost state by taking this exception.
 546  */
 547 void unrecoverable_exception(struct pt_regs *regs)
 548 {
 549         printk(KERN_EMERG "Unrecoverable exception %lx at %lx\n",
 550                regs->trap, regs->nip);
 551         die("Unrecoverable exception", regs, SIGABRT);
 552 }
 553
 554 /*
 555  * We enter here if we discover during exception entry that we are
 556  * running in supervisor mode with a userspace value in the stack pointer.
 557  */
 558 void kernel_bad_stack(struct pt_regs *regs)
 559 {
 560         printk(KERN_EMERG "Bad kernel stack pointer %lx at %lx\n",
 561                regs->gpr[1], regs->nip);
 562         die("Bad kernel stack pointer", regs, SIGABRT);
 563 }
 564
 565 void __init trap_init(void)
 566 {
 567 }