arch/loongarch/kernel/traps.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Author: Huacai Chen <chenhuacai@loongson.cn>
   4  * Copyright (C) 2020-2022 Loongson Technology Corporation Limited
   5  */
   6 #include <linux/bitops.h>
   7 #include <linux/bug.h>
   8 #include <linux/compiler.h>
   9 #include <linux/context_tracking.h>
  10 #include <linux/entry-common.h>
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/extable.h>
  15 #include <linux/mm.h>
  16 #include <linux/sched/mm.h>
  17 #include <linux/sched/debug.h>
  18 #include <linux/smp.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/memblock.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/ptrace.h>
  24 #include <linux/kgdb.h>
  25 #include <linux/kdebug.h>
  26 #include <linux/kprobes.h>
  27 #include <linux/notifier.h>
  28 #include <linux/irq.h>
  29 #include <linux/perf_event.h>
  30
  31 #include <asm/addrspace.h>
  32 #include <asm/bootinfo.h>
  33 #include <asm/branch.h>
  34 #include <asm/break.h>
  35 #include <asm/cpu.h>
  36 #include <asm/fpu.h>
  37 #include <asm/loongarch.h>
  38 #include <asm/mmu_context.h>
  39 #include <asm/pgtable.h>
  40 #include <asm/ptrace.h>
  41 #include <asm/sections.h>
  42 #include <asm/siginfo.h>
  43 #include <asm/stacktrace.h>
  44 #include <asm/tlb.h>
  45 #include <asm/types.h>
  46 #include <asm/unwind.h>
  47
  48 #include "access-helper.h"
  49
  50 extern asmlinkage void handle_ade(void);
  51 extern asmlinkage void handle_ale(void);
  52 extern asmlinkage void handle_sys(void);
  53 extern asmlinkage void handle_bp(void);
  54 extern asmlinkage void handle_ri(void);
  55 extern asmlinkage void handle_fpu(void);
  56 extern asmlinkage void handle_fpe(void);
  57 extern asmlinkage void handle_lbt(void);
  58 extern asmlinkage void handle_lsx(void);
  59 extern asmlinkage void handle_lasx(void);
  60 extern asmlinkage void handle_reserved(void);
  61 extern asmlinkage void handle_watch(void);
  62 extern asmlinkage void handle_vint(void);
  63
  64 static void show_backtrace(struct task_struct *task, const struct pt_regs *regs,
  65                            const char *loglvl, bool user)
  66 {
  67         unsigned long addr;
  68         struct unwind_state state;
  69         struct pt_regs *pregs = (struct pt_regs *)regs;
  70
  71         if (!task)
  72                 task = current;
  73
  74         printk("%sCall Trace:", loglvl);
  75         for (unwind_start(&state, task, pregs);
  76               !unwind_done(&state); unwind_next_frame(&state)) {
  77                 addr = unwind_get_return_address(&state);
  78                 print_ip_sym(loglvl, addr);
  79         }
  80         printk("%s\n", loglvl);
  81 }
  82
  83 static void show_stacktrace(struct task_struct *task,
  84         const struct pt_regs *regs, const char *loglvl, bool user)
  85 {
  86         int i;
  87         const int field = 2 * sizeof(unsigned long);
  88         unsigned long stackdata;
  89         unsigned long *sp = (unsigned long *)regs->regs[3];
  90
  91         printk("%sStack :", loglvl);
  92         i = 0;
  93         while ((unsigned long) sp & (PAGE_SIZE - 1)) {
  94                 if (i && ((i % (64 / field)) == 0)) {
  95                         pr_cont("\n");
  96                         printk("%s       ", loglvl);
  97                 }
  98                 if (i > 39) {
  99                         pr_cont(" ...");
 100                         break;
 101                 }
 102
 103                 if (__get_addr(&stackdata, sp++, user)) {
 104                         pr_cont(" (Bad stack address)");
 105                         break;
 106                 }
 107
 108                 pr_cont(" %0*lx", field, stackdata);
 109                 i++;
 110         }
 111         pr_cont("\n");
 112         show_backtrace(task, regs, loglvl, user);
 113 }
 114
 115 void show_stack(struct task_struct *task, unsigned long *sp, const char *loglvl)
 116 {
 117         struct pt_regs regs;
 118
 119         regs.csr_crmd = 0;
 120         if (sp) {
 121                 regs.csr_era = 0;
 122                 regs.regs[1] = 0;
 123                 regs.regs[3] = (unsigned long)sp;
 124         } else {
 125                 if (!task || task == current)
 126                         prepare_frametrace(&regs);
 127                 else {
 128                         regs.csr_era = task->thread.reg01;
 129                         regs.regs[1] = 0;
 130                         regs.regs[3] = task->thread.reg03;
 131                         regs.regs[22] = task->thread.reg22;
 132                 }
 133         }
 134
 135         show_stacktrace(task, &regs, loglvl, false);
 136 }
 137
 138 static void show_code(unsigned int *pc, bool user)
 139 {
 140         long i;
 141         unsigned int insn;
 142
 143         printk("Code:");
 144
 145         for(i = -3 ; i < 6 ; i++) {
 146                 if (__get_inst(&insn, pc + i, user)) {
 147                         pr_cont(" (Bad address in era)\n");
 148                         break;
 149                 }
 150                 pr_cont("%c%08x%c", (i?' ':'<'), insn, (i?' ':'>'));
 151         }
 152         pr_cont("\n");
 153 }
 154
 155 static void __show_regs(const struct pt_regs *regs)
 156 {
 157         const int field = 2 * sizeof(unsigned long);
 158         unsigned int excsubcode;
 159         unsigned int exccode;
 160         int i;
 161
 162         show_regs_print_info(KERN_DEFAULT);
 163
 164         /*
 165          * Saved main processor registers
 166          */
 167         for (i = 0; i < 32; ) {
 168                 if ((i % 4) == 0)
 169                         printk("$%2d   :", i);
 170                 pr_cont(" %0*lx", field, regs->regs[i]);
 171
 172                 i++;
 173                 if ((i % 4) == 0)
 174                         pr_cont("\n");
 175         }
 176
 177         /*
 178          * Saved csr registers
 179          */
 180         printk("era   : %0*lx %pS\n", field, regs->csr_era,
 181                (void *) regs->csr_era);
 182         printk("ra    : %0*lx %pS\n", field, regs->regs[1],
 183                (void *) regs->regs[1]);
 184
 185         printk("CSR crmd: %08lx ", regs->csr_crmd);
 186         printk("CSR prmd: %08lx ", regs->csr_prmd);
 187         printk("CSR euen: %08lx ", regs->csr_euen);
 188         printk("CSR ecfg: %08lx ", regs->csr_ecfg);
 189         printk("CSR estat: %08lx        ", regs->csr_estat);
 190
 191         pr_cont("\n");
 192
 193         exccode = ((regs->csr_estat) & CSR_ESTAT_EXC) >> CSR_ESTAT_EXC_SHIFT;
 194         excsubcode = ((regs->csr_estat) & CSR_ESTAT_ESUBCODE) >> CSR_ESTAT_ESUBCODE_SHIFT;
 195         printk("ExcCode : %x (SubCode %x)\n", exccode, excsubcode);
 196
 197         if (exccode >= EXCCODE_TLBL && exccode <= EXCCODE_ALE)
 198                 printk("BadVA : %0*lx\n", field, regs->csr_badvaddr);
 199
 200         printk("PrId  : %08x (%s)\n", read_cpucfg(LOONGARCH_CPUCFG0),
 201                cpu_family_string());
 202 }
 203
 204 void show_regs(struct pt_regs *regs)
 205 {
 206         __show_regs((struct pt_regs *)regs);
 207         dump_stack();
 208 }
 209
 210 void show_registers(struct pt_regs *regs)
 211 {
 212         __show_regs(regs);
 213         print_modules();
 214         printk("Process %s (pid: %d, threadinfo=%p, task=%p)\n",
 215                current->comm, current->pid, current_thread_info(), current);
 216
 217         show_stacktrace(current, regs, KERN_DEFAULT, user_mode(regs));
 218         show_code((void *)regs->csr_era, user_mode(regs));
 219         printk("\n");
 220 }
 221
 222 static DEFINE_RAW_SPINLOCK(die_lock);
 223
 224 void __noreturn die(const char *str, struct pt_regs *regs)
 225 {
 226         static int die_counter;
 227         int sig = SIGSEGV;
 228
 229         oops_enter();
 230
 231         if (notify_die(DIE_OOPS, str, regs, 0, current->thread.trap_nr,
 232                        SIGSEGV) == NOTIFY_STOP)
 233                 sig = 0;
 234
 235         console_verbose();
 236         raw_spin_lock_irq(&die_lock);
 237         bust_spinlocks(1);
 238
 239         printk("%s[#%d]:\n", str, ++die_counter);
 240         show_registers(regs);
 241         add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
 242         raw_spin_unlock_irq(&die_lock);
 243
 244         oops_exit();
 245
 246         if (in_interrupt())
 247                 panic("Fatal exception in interrupt");
 248
 249         if (panic_on_oops)
 250                 panic("Fatal exception");
 251
 252         make_task_dead(sig);
 253 }
 254
 255 static inline void setup_vint_size(unsigned int size)
 256 {
 257         unsigned int vs;
 258
 259         vs = ilog2(size/4);
 260
 261         if (vs == 0 || vs > 7)
 262                 panic("vint_size %d Not support yet", vs);
 263
 264         csr_xchg32(vs<<CSR_ECFG_VS_SHIFT, CSR_ECFG_VS, LOONGARCH_CSR_ECFG);
 265 }
 266
 267 /*
 268  * Send SIGFPE according to FCSR Cause bits, which must have already
 269  * been masked against Enable bits.  This is impotant as Inexact can
 270  * happen together with Overflow or Underflow, and `ptrace' can set
 271  * any bits.
 272  */
 273 void force_fcsr_sig(unsigned long fcsr, void __user *fault_addr,
 274                      struct task_struct *tsk)
 275 {
 276         int si_code = FPE_FLTUNK;
 277
 278         if (fcsr & FPU_CSR_INV_X)
 279                 si_code = FPE_FLTINV;
 280         else if (fcsr & FPU_CSR_DIV_X)
 281                 si_code = FPE_FLTDIV;
 282         else if (fcsr & FPU_CSR_OVF_X)
 283                 si_code = FPE_FLTOVF;
 284         else if (fcsr & FPU_CSR_UDF_X)
 285                 si_code = FPE_FLTUND;
 286         else if (fcsr & FPU_CSR_INE_X)
 287                 si_code = FPE_FLTRES;
 288
 289         force_sig_fault(SIGFPE, si_code, fault_addr);
 290 }
 291
 292 int process_fpemu_return(int sig, void __user *fault_addr, unsigned long fcsr)
 293 {
 294         int si_code;
 295
 296         switch (sig) {
 297         case 0:
 298                 return 0;
 299
 300         case SIGFPE:
 301                 force_fcsr_sig(fcsr, fault_addr, current);
 302                 return 1;
 303
 304         case SIGBUS:
 305                 force_sig_fault(SIGBUS, BUS_ADRERR, fault_addr);
 306                 return 1;
 307
 308         case SIGSEGV:
 309                 mmap_read_lock(current->mm);
 310                 if (vma_lookup(current->mm, (unsigned long)fault_addr))
 311                         si_code = SEGV_ACCERR;
 312                 else
 313                         si_code = SEGV_MAPERR;
 314                 mmap_read_unlock(current->mm);
 315                 force_sig_fault(SIGSEGV, si_code, fault_addr);
 316                 return 1;
 317
 318         default:
 319                 force_sig(sig);
 320                 return 1;
 321         }
 322 }
 323
 324 /*
 325  * Delayed fp exceptions when doing a lazy ctx switch
 326  */
 327 asmlinkage void noinstr do_fpe(struct pt_regs *regs, unsigned long fcsr)
 328 {
 329         int sig;
 330         void __user *fault_addr;
 331         irqentry_state_t state = irqentry_enter(regs);
 332
 333         if (notify_die(DIE_FP, "FP exception", regs, 0, current->thread.trap_nr,
 334                        SIGFPE) == NOTIFY_STOP)
 335                 goto out;
 336
 337         /* Clear FCSR.Cause before enabling interrupts */
 338         write_fcsr(LOONGARCH_FCSR0, fcsr & ~mask_fcsr_x(fcsr));
 339         local_irq_enable();
 340
 341         die_if_kernel("FP exception in kernel code", regs);
 342
 343         sig = SIGFPE;
 344         fault_addr = (void __user *) regs->csr_era;
 345
 346         /* Send a signal if required.  */
 347         process_fpemu_return(sig, fault_addr, fcsr);
 348
 349 out:
 350         local_irq_disable();
 351         irqentry_exit(regs, state);
 352 }
 353
 354 asmlinkage void noinstr do_ade(struct pt_regs *regs)
 355 {
 356         irqentry_state_t state = irqentry_enter(regs);
 357
 358         die_if_kernel("Kernel ade access", regs);
 359         force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)regs->csr_badvaddr);
 360
 361         irqentry_exit(regs, state);
 362 }
 363
 364 asmlinkage void noinstr do_ale(struct pt_regs *regs)
 365 {
 366         irqentry_state_t state = irqentry_enter(regs);
 367
 368         die_if_kernel("Kernel ale access", regs);
 369         force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)regs->csr_badvaddr);
 370
 371         irqentry_exit(regs, state);
 372 }
 373
 374 asmlinkage void noinstr do_bp(struct pt_regs *regs)
 375 {
 376         bool user = user_mode(regs);
 377         unsigned int opcode, bcode;
 378         unsigned long era = exception_era(regs);
 379         irqentry_state_t state = irqentry_enter(regs);
 380
 381         local_irq_enable();
 382         current->thread.trap_nr = read_csr_excode();
 383         if (__get_inst(&opcode, (u32 *)era, user))
 384                 goto out_sigsegv;
 385
 386         bcode = (opcode & 0x7fff);
 387
 388         /*
 389          * notify the kprobe handlers, if instruction is likely to
 390          * pertain to them.
 391          */
 392         switch (bcode) {
 393         case BRK_KPROBE_BP:
 394                 if (notify_die(DIE_BREAK, "Kprobe", regs, bcode,
 395                                current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP)
 396                         goto out;
 397                 else
 398                         break;
 399         case BRK_KPROBE_SSTEPBP:
 400                 if (notify_die(DIE_SSTEPBP, "Kprobe_SingleStep", regs, bcode,
 401                                current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP)
 402                         goto out;
 403                 else
 404                         break;
 405         case BRK_UPROBE_BP:
 406                 if (notify_die(DIE_UPROBE, "Uprobe", regs, bcode,
 407                                current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP)
 408                         goto out;
 409                 else
 410                         break;
 411         case BRK_UPROBE_XOLBP:
 412                 if (notify_die(DIE_UPROBE_XOL, "Uprobe_XOL", regs, bcode,
 413                                current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP)
 414                         goto out;
 415                 else
 416                         break;
 417         default:
 418                 if (notify_die(DIE_TRAP, "Break", regs, bcode,
 419                                current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP)
 420                         goto out;
 421                 else
 422                         break;
 423         }
 424
 425         switch (bcode) {
 426         case BRK_BUG:
 427                 die_if_kernel("Kernel bug detected", regs);
 428                 force_sig(SIGTRAP);
 429                 break;
 430         case BRK_DIVZERO:
 431                 die_if_kernel("Break instruction in kernel code", regs);
 432                 force_sig_fault(SIGFPE, FPE_INTDIV, (void __user *)regs->csr_era);
 433                 break;
 434         case BRK_OVERFLOW:
 435                 die_if_kernel("Break instruction in kernel code", regs);
 436                 force_sig_fault(SIGFPE, FPE_INTOVF, (void __user *)regs->csr_era);
 437                 break;
 438         default:
 439                 die_if_kernel("Break instruction in kernel code", regs);
 440                 force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->csr_era);
 441                 break;
 442         }
 443
 444 out:
 445         local_irq_disable();
 446         irqentry_exit(regs, state);
 447         return;
 448
 449 out_sigsegv:
 450         force_sig(SIGSEGV);
 451         goto out;
 452 }
 453
 454 asmlinkage void noinstr do_watch(struct pt_regs *regs)
 455 {
 456         pr_warn("Hardware watch point handler not implemented!\n");
 457 }
 458
 459 asmlinkage void noinstr do_ri(struct pt_regs *regs)
 460 {
 461         int status = -1;
 462         unsigned int opcode = 0;
 463         unsigned int __user *era = (unsigned int __user *)exception_era(regs);
 464         unsigned long old_era = regs->csr_era;
 465         unsigned long old_ra = regs->regs[1];
 466         irqentry_state_t state = irqentry_enter(regs);
 467
 468         local_irq_enable();
 469         current->thread.trap_nr = read_csr_excode();
 470
 471         if (notify_die(DIE_RI, "RI Fault", regs, 0, current->thread.trap_nr,
 472                        SIGILL) == NOTIFY_STOP)
 473                 goto out;
 474
 475         die_if_kernel("Reserved instruction in kernel code", regs);
 476
 477         compute_return_era(regs);
 478
 479         if (unlikely(get_user(opcode, era) < 0)) {
 480                 status = SIGSEGV;
 481                 current->thread.error_code = 1;
 482         }
 483
 484         if (status < 0)
 485                 status = SIGILL;
 486
 487         if (unlikely(status > 0)) {
 488                 regs->csr_era = old_era;                /* Undo skip-over.  */
 489                 regs->regs[1] = old_ra;
 490                 force_sig(status);
 491         }
 492
 493 out:
 494         local_irq_disable();
 495         irqentry_exit(regs, state);
 496 }
 497
 498 static void init_restore_fp(void)
 499 {
 500         if (!used_math()) {
 501                 /* First time FP context user. */
 502                 init_fpu();
 503         } else {
 504                 /* This task has formerly used the FP context */
 505                 if (!is_fpu_owner())
 506                         own_fpu_inatomic(1);
 507         }
 508
 509         BUG_ON(!is_fp_enabled());
 510 }
 511
 512 asmlinkage void noinstr do_fpu(struct pt_regs *regs)
 513 {
 514         irqentry_state_t state = irqentry_enter(regs);
 515
 516         local_irq_enable();
 517         die_if_kernel("do_fpu invoked from kernel context!", regs);
 518
 519         preempt_disable();
 520         init_restore_fp();
 521         preempt_enable();
 522
 523         local_irq_disable();
 524         irqentry_exit(regs, state);
 525 }
 526
 527 asmlinkage void noinstr do_lsx(struct pt_regs *regs)
 528 {
 529         irqentry_state_t state = irqentry_enter(regs);
 530
 531         local_irq_enable();
 532         force_sig(SIGILL);
 533         local_irq_disable();
 534
 535         irqentry_exit(regs, state);
 536 }
 537
 538 asmlinkage void noinstr do_lasx(struct pt_regs *regs)
 539 {
 540         irqentry_state_t state = irqentry_enter(regs);
 541
 542         local_irq_enable();
 543         force_sig(SIGILL);
 544         local_irq_disable();
 545
 546         irqentry_exit(regs, state);
 547 }
 548
 549 asmlinkage void noinstr do_lbt(struct pt_regs *regs)
 550 {
 551         irqentry_state_t state = irqentry_enter(regs);
 552
 553         local_irq_enable();
 554         force_sig(SIGILL);
 555         local_irq_disable();
 556
 557         irqentry_exit(regs, state);
 558 }
 559
 560 asmlinkage void noinstr do_reserved(struct pt_regs *regs)
 561 {
 562         irqentry_state_t state = irqentry_enter(regs);
 563
 564         local_irq_enable();
 565         /*
 566          * Game over - no way to handle this if it ever occurs. Most probably
 567          * caused by a fatal error after another hardware/software error.
 568          */
 569         pr_err("Caught reserved exception %u on pid:%d [%s] - should not happen\n",
 570                 read_csr_excode(), current->pid, current->comm);
 571         die_if_kernel("do_reserved exception", regs);
 572         force_sig(SIGUNUSED);
 573
 574         local_irq_disable();
 575
 576         irqentry_exit(regs, state);
 577 }
 578
 579 asmlinkage void cache_parity_error(void)
 580 {
 581         /* For the moment, report the problem and hang. */
 582         pr_err("Cache error exception:\n");
 583         pr_err("csr_merrctl == %08x\n", csr_read32(LOONGARCH_CSR_MERRCTL));
 584         pr_err("csr_merrera == %016llx\n", csr_read64(LOONGARCH_CSR_MERRERA));
 585         panic("Can't handle the cache error!");
 586 }
 587
 588 asmlinkage void noinstr handle_loongarch_irq(struct pt_regs *regs)
 589 {
 590         struct pt_regs *old_regs;
 591
 592         irq_enter_rcu();
 593         old_regs = set_irq_regs(regs);
 594         handle_arch_irq(regs);
 595         set_irq_regs(old_regs);
 596         irq_exit_rcu();
 597 }
 598
 599 asmlinkage void noinstr do_vint(struct pt_regs *regs, unsigned long sp)
 600 {
 601         register int cpu;
 602         register unsigned long stack;
 603         irqentry_state_t state = irqentry_enter(regs);
 604
 605         cpu = smp_processor_id();
 606
 607         if (on_irq_stack(cpu, sp))
 608                 handle_loongarch_irq(regs);
 609         else {
 610                 stack = per_cpu(irq_stack, cpu) + IRQ_STACK_START;
 611
 612                 /* Save task's sp on IRQ stack for unwinding */
 613                 *(unsigned long *)stack = sp;
 614
 615                 __asm__ __volatile__(
 616                 "move   $s0, $sp                \n" /* Preserve sp */
 617                 "move   $sp, %[stk]             \n" /* Switch stack */
 618                 "move   $a0, %[regs]            \n"
 619                 "bl     handle_loongarch_irq    \n"
 620                 "move   $sp, $s0                \n" /* Restore sp */
 621                 : /* No outputs */
 622                 : [stk] "r" (stack), [regs] "r" (regs)
 623                 : "$a0", "$a1", "$a2", "$a3", "$a4", "$a5", "$a6", "$a7", "$s0",
 624                   "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8",
 625                   "memory");
 626         }
 627
 628         irqentry_exit(regs, state);
 629 }
 630
 631 extern void tlb_init(int cpu);
 632 extern void cache_error_setup(void);
 633
 634 unsigned long eentry;
 635 unsigned long tlbrentry;
 636
 637 long exception_handlers[VECSIZE * 128 / sizeof(long)] __aligned(SZ_64K);
 638
 639 static void configure_exception_vector(void)
 640 {
 641         eentry    = (unsigned long)exception_handlers;
 642         tlbrentry = (unsigned long)exception_handlers + 80*VECSIZE;
 643
 644         csr_write64(eentry, LOONGARCH_CSR_EENTRY);
 645         csr_write64(eentry, LOONGARCH_CSR_MERRENTRY);
 646         csr_write64(tlbrentry, LOONGARCH_CSR_TLBRENTRY);
 647 }
 648
 649 void per_cpu_trap_init(int cpu)
 650 {
 651         unsigned int i;
 652
 653         setup_vint_size(VECSIZE);
 654
 655         configure_exception_vector();
 656
 657         if (!cpu_data[cpu].asid_cache)
 658                 cpu_data[cpu].asid_cache = asid_first_version(cpu);
 659
 660         mmgrab(&init_mm);
 661         current->active_mm = &init_mm;
 662         BUG_ON(current->mm);
 663         enter_lazy_tlb(&init_mm, current);
 664
 665         /* Initialise exception handlers */
 666         if (cpu == 0)
 667                 for (i = 0; i < 64; i++)
 668                         set_handler(i * VECSIZE, handle_reserved, VECSIZE);
 669
 670         tlb_init(cpu);
 671         cpu_cache_init();
 672 }
 673
 674 /* Install CPU exception handler */
 675 void set_handler(unsigned long offset, void *addr, unsigned long size)
 676 {
 677         memcpy((void *)(eentry + offset), addr, size);
 678         local_flush_icache_range(eentry + offset, eentry + offset + size);
 679 }
 680
 681 static const char panic_null_cerr[] =
 682         "Trying to set NULL cache error exception handler\n";
 683
 684 /*
 685  * Install uncached CPU exception handler.
 686  * This is suitable only for the cache error exception which is the only
 687  * exception handler that is being run uncached.
 688  */
 689 void set_merr_handler(unsigned long offset, void *addr, unsigned long size)
 690 {
 691         unsigned long uncached_eentry = TO_UNCACHE(__pa(eentry));
 692
 693         if (!addr)
 694                 panic(panic_null_cerr);
 695
 696         memcpy((void *)(uncached_eentry + offset), addr, size);
 697 }
 698
 699 void __init trap_init(void)
 700 {
 701         long i;
 702
 703         /* Set interrupt vector handler */
 704         for (i = EXCCODE_INT_START; i < EXCCODE_INT_END; i++)
 705                 set_handler(i * VECSIZE, handle_vint, VECSIZE);
 706
 707         set_handler(EXCCODE_ADE * VECSIZE, handle_ade, VECSIZE);
 708         set_handler(EXCCODE_ALE * VECSIZE, handle_ale, VECSIZE);
 709         set_handler(EXCCODE_SYS * VECSIZE, handle_sys, VECSIZE);
 710         set_handler(EXCCODE_BP * VECSIZE, handle_bp, VECSIZE);
 711         set_handler(EXCCODE_INE * VECSIZE, handle_ri, VECSIZE);
 712         set_handler(EXCCODE_IPE * VECSIZE, handle_ri, VECSIZE);
 713         set_handler(EXCCODE_FPDIS * VECSIZE, handle_fpu, VECSIZE);
 714         set_handler(EXCCODE_LSXDIS * VECSIZE, handle_lsx, VECSIZE);
 715         set_handler(EXCCODE_LASXDIS * VECSIZE, handle_lasx, VECSIZE);
 716         set_handler(EXCCODE_FPE * VECSIZE, handle_fpe, VECSIZE);
 717         set_handler(EXCCODE_BTDIS * VECSIZE, handle_lbt, VECSIZE);
 718         set_handler(EXCCODE_WATCH * VECSIZE, handle_watch, VECSIZE);
 719
 720         cache_error_setup();
 721
 722         local_flush_icache_range(eentry, eentry + 0x400);
 723 }