arch/frv/kernel/traps.c

   1 /* traps.c: high-level exception handler for FR-V
   2  *
   3  * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   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
  12 #include <linux/sched/signal.h>
  13 #include <linux/sched/debug.h>
  14 #include <linux/signal.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mm.h>
  17 #include <linux/types.h>
  18 #include <linux/user.h>
  19 #include <linux/string.h>
  20 #include <linux/linkage.h>
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23
  24 #include <asm/asm-offsets.h>
  25 #include <asm/setup.h>
  26 #include <asm/fpu.h>
  27 #include <linux/uaccess.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/siginfo.h>
  30 #include <asm/unaligned.h>
  31
  32 void show_backtrace(struct pt_regs *, unsigned long);
  33
  34 extern asmlinkage void __break_hijack_kernel_event(void);
  35
  36 /*****************************************************************************/
  37 /*
  38  * instruction access error
  39  */
  40 asmlinkage void insn_access_error(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
  41 {
  42         siginfo_t info;
  43
  44         die_if_kernel("-- Insn Access Error --\n"
  45                       "EPCR0 : %08lx\n"
  46                       "ESR0  : %08lx\n",
  47                       epcr0, esr0);
  48
  49         info.si_signo   = SIGSEGV;
  50         info.si_code    = SEGV_ACCERR;
  51         info.si_errno   = 0;
  52         info.si_addr    = (void __user *) ((epcr0 & EPCR0_V) ? (epcr0 & EPCR0_PC) : __frame->pc);
  53
  54         force_sig_info(info.si_signo, &info, current);
  55 } /* end insn_access_error() */
  56
  57 /*****************************************************************************/
  58 /*
  59  * handler for:
  60  * - illegal instruction
  61  * - privileged instruction
  62  * - unsupported trap
  63  * - debug exceptions
  64  */
  65 asmlinkage void illegal_instruction(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
  66 {
  67         siginfo_t info;
  68
  69         die_if_kernel("-- Illegal Instruction --\n"
  70                       "EPCR0 : %08lx\n"
  71                       "ESR0  : %08lx\n"
  72                       "ESFR1 : %08lx\n",
  73                       epcr0, esr0, esfr1);
  74
  75         info.si_errno   = 0;
  76         info.si_addr    = (void __user *) ((epcr0 & EPCR0_V) ? (epcr0 & EPCR0_PC) : __frame->pc);
  77
  78         switch (__frame->tbr & TBR_TT) {
  79         case TBR_TT_ILLEGAL_INSTR:
  80                 info.si_signo   = SIGILL;
  81                 info.si_code    = ILL_ILLOPC;
  82                 break;
  83         case TBR_TT_PRIV_INSTR:
  84                 info.si_signo   = SIGILL;
  85                 info.si_code    = ILL_PRVOPC;
  86                 break;
  87         case TBR_TT_TRAP2 ... TBR_TT_TRAP126:
  88                 info.si_signo   = SIGILL;
  89                 info.si_code    = ILL_ILLTRP;
  90                 break;
  91         /* GDB uses "tira gr0, #1" as a breakpoint instruction.  */
  92         case TBR_TT_TRAP1:
  93         case TBR_TT_BREAK:
  94                 info.si_signo   = SIGTRAP;
  95                 info.si_code    =
  96                         (__frame->__status & REG__STATUS_STEPPED) ? TRAP_TRACE : TRAP_BRKPT;
  97                 break;
  98         }
  99
 100         force_sig_info(info.si_signo, &info, current);
 101 } /* end illegal_instruction() */
 102
 103 /*****************************************************************************/
 104 /*
 105  * handle atomic operations with errors
 106  * - arguments in gr8, gr9, gr10
 107  * - original memory value placed in gr5
 108  * - replacement memory value placed in gr9
 109  */
 110 asmlinkage void atomic_operation(unsigned long esfr1, unsigned long epcr0,
 111                                  unsigned long esr0)
 112 {
 113         static DEFINE_SPINLOCK(atomic_op_lock);
 114         unsigned long x, y, z;
 115         unsigned long __user *p;
 116         mm_segment_t oldfs;
 117         siginfo_t info;
 118         int ret;
 119
 120         y = 0;
 121         z = 0;
 122
 123         oldfs = get_fs();
 124         if (!user_mode(__frame))
 125                 set_fs(KERNEL_DS);
 126
 127         switch (__frame->tbr & TBR_TT) {
 128                 /* TIRA gr0,#120
 129                  * u32 __atomic_user_cmpxchg32(u32 *ptr, u32 test, u32 new)
 130                  */
 131         case TBR_TT_ATOMIC_CMPXCHG32:
 132                 p = (unsigned long __user *) __frame->gr8;
 133                 x = __frame->gr9;
 134                 y = __frame->gr10;
 135
 136                 for (;;) {
 137                         ret = get_user(z, p);
 138                         if (ret < 0)
 139                                 goto error;
 140
 141                         if (z != x)
 142                                 goto done;
 143
 144                         spin_lock_irq(&atomic_op_lock);
 145
 146                         if (__get_user(z, p) == 0) {
 147                                 if (z != x)
 148                                         goto done2;
 149
 150                                 if (__put_user(y, p) == 0)
 151                                         goto done2;
 152                                 goto error2;
 153                         }
 154
 155                         spin_unlock_irq(&atomic_op_lock);
 156                 }
 157
 158                 /* TIRA gr0,#121
 159                  * u32 __atomic_kernel_xchg32(void *v, u32 new)
 160                  */
 161         case TBR_TT_ATOMIC_XCHG32:
 162                 p = (unsigned long __user *) __frame->gr8;
 163                 y = __frame->gr9;
 164
 165                 for (;;) {
 166                         ret = get_user(z, p);
 167                         if (ret < 0)
 168                                 goto error;
 169
 170                         spin_lock_irq(&atomic_op_lock);
 171
 172                         if (__get_user(z, p) == 0) {
 173                                 if (__put_user(y, p) == 0)
 174                                         goto done2;
 175                                 goto error2;
 176                         }
 177
 178                         spin_unlock_irq(&atomic_op_lock);
 179                 }
 180
 181                 /* TIRA gr0,#122
 182                  * ulong __atomic_kernel_XOR_return(ulong i, ulong *v)
 183                  */
 184         case TBR_TT_ATOMIC_XOR:
 185                 p = (unsigned long __user *) __frame->gr8;
 186                 x = __frame->gr9;
 187
 188                 for (;;) {
 189                         ret = get_user(z, p);
 190                         if (ret < 0)
 191                                 goto error;
 192
 193                         spin_lock_irq(&atomic_op_lock);
 194
 195                         if (__get_user(z, p) == 0) {
 196                                 y = x ^ z;
 197                                 if (__put_user(y, p) == 0)
 198                                         goto done2;
 199                                 goto error2;
 200                         }
 201
 202                         spin_unlock_irq(&atomic_op_lock);
 203                 }
 204
 205                 /* TIRA gr0,#123
 206                  * ulong __atomic_kernel_OR_return(ulong i, ulong *v)
 207                  */
 208         case TBR_TT_ATOMIC_OR:
 209                 p = (unsigned long __user *) __frame->gr8;
 210                 x = __frame->gr9;
 211
 212                 for (;;) {
 213                         ret = get_user(z, p);
 214                         if (ret < 0)
 215                                 goto error;
 216
 217                         spin_lock_irq(&atomic_op_lock);
 218
 219                         if (__get_user(z, p) == 0) {
 220                                 y = x ^ z;
 221                                 if (__put_user(y, p) == 0)
 222                                         goto done2;
 223                                 goto error2;
 224                         }
 225
 226                         spin_unlock_irq(&atomic_op_lock);
 227                 }
 228
 229                 /* TIRA gr0,#124
 230                  * ulong __atomic_kernel_AND_return(ulong i, ulong *v)
 231                  */
 232         case TBR_TT_ATOMIC_AND:
 233                 p = (unsigned long __user *) __frame->gr8;
 234                 x = __frame->gr9;
 235
 236                 for (;;) {
 237                         ret = get_user(z, p);
 238                         if (ret < 0)
 239                                 goto error;
 240
 241                         spin_lock_irq(&atomic_op_lock);
 242
 243                         if (__get_user(z, p) == 0) {
 244                                 y = x & z;
 245                                 if (__put_user(y, p) == 0)
 246                                         goto done2;
 247                                 goto error2;
 248                         }
 249
 250                         spin_unlock_irq(&atomic_op_lock);
 251                 }
 252
 253                 /* TIRA gr0,#125
 254                  * int __atomic_user_sub_return(atomic_t *v, int i)
 255                  */
 256         case TBR_TT_ATOMIC_SUB:
 257                 p = (unsigned long __user *) __frame->gr8;
 258                 x = __frame->gr9;
 259
 260                 for (;;) {
 261                         ret = get_user(z, p);
 262                         if (ret < 0)
 263                                 goto error;
 264
 265                         spin_lock_irq(&atomic_op_lock);
 266
 267                         if (__get_user(z, p) == 0) {
 268                                 y = z - x;
 269                                 if (__put_user(y, p) == 0)
 270                                         goto done2;
 271                                 goto error2;
 272                         }
 273
 274                         spin_unlock_irq(&atomic_op_lock);
 275                 }
 276
 277                 /* TIRA gr0,#126
 278                  * int __atomic_user_add_return(atomic_t *v, int i)
 279                  */
 280         case TBR_TT_ATOMIC_ADD:
 281                 p = (unsigned long __user *) __frame->gr8;
 282                 x = __frame->gr9;
 283
 284                 for (;;) {
 285                         ret = get_user(z, p);
 286                         if (ret < 0)
 287                                 goto error;
 288
 289                         spin_lock_irq(&atomic_op_lock);
 290
 291                         if (__get_user(z, p) == 0) {
 292                                 y = z + x;
 293                                 if (__put_user(y, p) == 0)
 294                                         goto done2;
 295                                 goto error2;
 296                         }
 297
 298                         spin_unlock_irq(&atomic_op_lock);
 299                 }
 300
 301         default:
 302                 BUG();
 303         }
 304
 305 done2:
 306         spin_unlock_irq(&atomic_op_lock);
 307 done:
 308         if (!user_mode(__frame))
 309                 set_fs(oldfs);
 310         __frame->gr5 = z;
 311         __frame->gr9 = y;
 312         return;
 313
 314 error2:
 315         spin_unlock_irq(&atomic_op_lock);
 316 error:
 317         if (!user_mode(__frame))
 318                 set_fs(oldfs);
 319         __frame->pc -= 4;
 320
 321         die_if_kernel("-- Atomic Op Error --\n");
 322
 323         info.si_signo   = SIGSEGV;
 324         info.si_code    = SEGV_ACCERR;
 325         info.si_errno   = 0;
 326         info.si_addr    = (void __user *) __frame->pc;
 327
 328         force_sig_info(info.si_signo, &info, current);
 329 }
 330
 331 /*****************************************************************************/
 332 /*
 333  *
 334  */
 335 asmlinkage void media_exception(unsigned long msr0, unsigned long msr1)
 336 {
 337         siginfo_t info;
 338
 339         die_if_kernel("-- Media Exception --\n"
 340                       "MSR0 : %08lx\n"
 341                       "MSR1 : %08lx\n",
 342                       msr0, msr1);
 343
 344         info.si_signo   = SIGFPE;
 345         info.si_code    = FPE_MDAOVF;
 346         info.si_errno   = 0;
 347         info.si_addr    = (void __user *) __frame->pc;
 348
 349         force_sig_info(info.si_signo, &info, current);
 350 } /* end media_exception() */
 351
 352 /*****************************************************************************/
 353 /*
 354  * instruction or data access exception
 355  */
 356 asmlinkage void memory_access_exception(unsigned long esr0,
 357                                         unsigned long ear0,
 358                                         unsigned long epcr0)
 359 {
 360         siginfo_t info;
 361
 362 #ifdef CONFIG_MMU
 363         if (fixup_exception(__frame))
 364                 return;
 365 #endif
 366
 367         die_if_kernel("-- Memory Access Exception --\n"
 368                       "ESR0  : %08lx\n"
 369                       "EAR0  : %08lx\n"
 370                       "EPCR0 : %08lx\n",
 371                       esr0, ear0, epcr0);
 372
 373         info.si_signo   = SIGSEGV;
 374         info.si_code    = SEGV_ACCERR;
 375         info.si_errno   = 0;
 376         info.si_addr    = NULL;
 377
 378         if ((esr0 & (ESRx_VALID | ESR0_EAV)) == (ESRx_VALID | ESR0_EAV))
 379                 info.si_addr = (void __user *) ear0;
 380
 381         force_sig_info(info.si_signo, &info, current);
 382
 383 } /* end memory_access_exception() */
 384
 385 /*****************************************************************************/
 386 /*
 387  * data access error
 388  * - double-word data load from CPU control area (0xFExxxxxx)
 389  * - read performed on inactive or self-refreshing SDRAM
 390  * - error notification from slave device
 391  * - misaligned address
 392  * - access to out of bounds memory region
 393  * - user mode accessing privileged memory region
 394  * - write to R/O memory region
 395  */
 396 asmlinkage void data_access_error(unsigned long esfr1, unsigned long esr15, unsigned long ear15)
 397 {
 398         siginfo_t info;
 399
 400         die_if_kernel("-- Data Access Error --\n"
 401                       "ESR15 : %08lx\n"
 402                       "EAR15 : %08lx\n",
 403                       esr15, ear15);
 404
 405         info.si_signo   = SIGSEGV;
 406         info.si_code    = SEGV_ACCERR;
 407         info.si_errno   = 0;
 408         info.si_addr    = (void __user *)
 409                 (((esr15 & (ESRx_VALID|ESR15_EAV)) == (ESRx_VALID|ESR15_EAV)) ? ear15 : 0);
 410
 411         force_sig_info(info.si_signo, &info, current);
 412 } /* end data_access_error() */
 413
 414 /*****************************************************************************/
 415 /*
 416  * data store error - should only happen if accessing inactive or self-refreshing SDRAM
 417  */
 418 asmlinkage void data_store_error(unsigned long esfr1, unsigned long esr15)
 419 {
 420         die_if_kernel("-- Data Store Error --\n"
 421                       "ESR15 : %08lx\n",
 422                       esr15);
 423         BUG();
 424 } /* end data_store_error() */
 425
 426 /*****************************************************************************/
 427 /*
 428  *
 429  */
 430 asmlinkage void division_exception(unsigned long esfr1, unsigned long esr0, unsigned long isr)
 431 {
 432         siginfo_t info;
 433
 434         die_if_kernel("-- Division Exception --\n"
 435                       "ESR0 : %08lx\n"
 436                       "ISR  : %08lx\n",
 437                       esr0, isr);
 438
 439         info.si_signo   = SIGFPE;
 440         info.si_code    = FPE_INTDIV;
 441         info.si_errno   = 0;
 442         info.si_addr    = (void __user *) __frame->pc;
 443
 444         force_sig_info(info.si_signo, &info, current);
 445 } /* end division_exception() */
 446
 447 /*****************************************************************************/
 448 /*
 449  *
 450  */
 451 asmlinkage void compound_exception(unsigned long esfr1,
 452                                    unsigned long esr0, unsigned long esr14, unsigned long esr15,
 453                                    unsigned long msr0, unsigned long msr1)
 454 {
 455         die_if_kernel("-- Compound Exception --\n"
 456                       "ESR0  : %08lx\n"
 457                       "ESR15 : %08lx\n"
 458                       "ESR15 : %08lx\n"
 459                       "MSR0  : %08lx\n"
 460                       "MSR1  : %08lx\n",
 461                       esr0, esr14, esr15, msr0, msr1);
 462         BUG();
 463 } /* end compound_exception() */
 464
 465 void show_stack(struct task_struct *task, unsigned long *sp)
 466 {
 467 }
 468
 469 void show_trace_task(struct task_struct *tsk)
 470 {
 471         printk("CONTEXT: stack=0x%lx frame=0x%p LR=0x%lx RET=0x%lx\n",
 472                tsk->thread.sp, tsk->thread.frame, tsk->thread.lr, tsk->thread.sched_lr);
 473 }
 474
 475 static const char *regnames[] = {
 476         "PSR ", "ISR ", "CCR ", "CCCR",
 477         "LR  ", "LCR ", "PC  ", "_stt",
 478         "sys ", "GR8*", "GNE0", "GNE1",
 479         "IACH", "IACL",
 480         "TBR ", "SP  ", "FP  ", "GR3 ",
 481         "GR4 ", "GR5 ", "GR6 ", "GR7 ",
 482         "GR8 ", "GR9 ", "GR10", "GR11",
 483         "GR12", "GR13", "GR14", "GR15",
 484         "GR16", "GR17", "GR18", "GR19",
 485         "GR20", "GR21", "GR22", "GR23",
 486         "GR24", "GR25", "GR26", "GR27",
 487         "EFRM", "CURR", "GR30", "BFRM"
 488 };
 489
 490 void show_regs(struct pt_regs *regs)
 491 {
 492         unsigned long *reg;
 493         int loop;
 494
 495         printk("\n");
 496         show_regs_print_info(KERN_DEFAULT);
 497
 498         printk("Frame: @%08lx [%s]\n",
 499                (unsigned long) regs,
 500                regs->psr & PSR_S ? "kernel" : "user");
 501
 502         reg = (unsigned long *) regs;
 503         for (loop = 0; loop < NR_PT_REGS; loop++) {
 504                 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
 505
 506                 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
 507                         printk("\n");
 508                 else
 509                         printk(" | ");
 510         }
 511 }
 512
 513 void die_if_kernel(const char *str, ...)
 514 {
 515         char buffer[256];
 516         va_list va;
 517
 518         if (user_mode(__frame))
 519                 return;
 520
 521         va_start(va, str);
 522         vsnprintf(buffer, sizeof(buffer), str, va);
 523         va_end(va);
 524
 525         console_verbose();
 526         printk("\n===================================\n");
 527         printk("%s\n", buffer);
 528         show_backtrace(__frame, 0);
 529
 530         __break_hijack_kernel_event();
 531         do_exit(SIGSEGV);
 532 }
 533
 534 /*****************************************************************************/
 535 /*
 536  * dump the contents of an exception frame
 537  */
 538 static void show_backtrace_regs(struct pt_regs *frame)
 539 {
 540         unsigned long *reg;
 541         int loop;
 542
 543         /* print the registers for this frame */
 544         printk("<-- %s Frame: @%p -->\n",
 545                frame->psr & PSR_S ? "Kernel Mode" : "User Mode",
 546                frame);
 547
 548         reg = (unsigned long *) frame;
 549         for (loop = 0; loop < NR_PT_REGS; loop++) {
 550                 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
 551
 552                 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
 553                         printk("\n");
 554                 else
 555                         printk(" | ");
 556         }
 557
 558         printk("--------\n");
 559 } /* end show_backtrace_regs() */
 560
 561 /*****************************************************************************/
 562 /*
 563  * generate a backtrace of the kernel stack
 564  */
 565 void show_backtrace(struct pt_regs *frame, unsigned long sp)
 566 {
 567         struct pt_regs *frame0;
 568         unsigned long tos = 0, stop = 0, base;
 569         int format;
 570
 571         base = ((((unsigned long) frame) + 8191) & ~8191) - sizeof(struct user_context);
 572         frame0 = (struct pt_regs *) base;
 573
 574         if (sp) {
 575                 tos = sp;
 576                 stop = (unsigned long) frame;
 577         }
 578
 579         printk("\nProcess %s (pid: %d)\n\n", current->comm, current->pid);
 580
 581         for (;;) {
 582                 /* dump stack segment between frames */
 583                 //printk("%08lx -> %08lx\n", tos, stop);
 584                 format = 0;
 585                 while (tos < stop) {
 586                         if (format == 0)
 587                                 printk(" %04lx :", tos & 0xffff);
 588
 589                         printk(" %08lx", *(unsigned long *) tos);
 590
 591                         tos += 4;
 592                         format++;
 593                         if (format == 8) {
 594                                 printk("\n");
 595                                 format = 0;
 596                         }
 597                 }
 598
 599                 if (format > 0)
 600                         printk("\n");
 601
 602                 /* dump frame 0 outside of the loop */
 603                 if (frame == frame0)
 604                         break;
 605
 606                 tos = frame->sp;
 607                 if (((unsigned long) frame) + sizeof(*frame) != tos) {
 608                         printk("-- TOS %08lx does not follow frame %p --\n",
 609                                tos, frame);
 610                         break;
 611                 }
 612
 613                 show_backtrace_regs(frame);
 614
 615                 /* dump the stack between this frame and the next */
 616                 stop = (unsigned long) frame->next_frame;
 617                 if (stop != base &&
 618                     (stop < tos ||
 619                      stop > base ||
 620                      (stop < base && stop + sizeof(*frame) > base) ||
 621                      stop & 3)) {
 622                         printk("-- next_frame %08lx is invalid (range %08lx-%08lx) --\n",
 623                                stop, tos, base);
 624                         break;
 625                 }
 626
 627                 /* move to next frame */
 628                 frame = frame->next_frame;
 629         }
 630
 631         /* we can always dump frame 0, even if the rest of the stack is corrupt */
 632         show_backtrace_regs(frame0);
 633
 634 } /* end show_backtrace() */
 635
 636 /*****************************************************************************/
 637 /*
 638  * initialise traps
 639  */
 640 void __init trap_init (void)
 641 {
 642 } /* end trap_init() */