开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
traps.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：30k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

traps.c：源码内容
  1. /*
  2.  *  linux/arch/m68k/kernel/traps.c
  3.  *
  4.  *  Copyright (C) 1993, 1994 by Hamish Macdonald
  5.  *
  6.  *  68040 fixes by Michael Rausch
  7.  *  68040 fixes by Martin Apel
  8.  *  68040 fixes and writeback by Richard Zidlicky
  9.  *  68060 fixes by Roman Hodek
  10.  *  68060 fixes by Jesper Skov
  11.  *
  12.  * This file is subject to the terms and conditions of the GNU General Public
  13.  * License.  See the file COPYING in the main directory of this archive
  14.  * for more details.
  15.  */
  17. /*
  18.  * Sets up all exception vectors
  19.  */
  21. #include <linux/config.h>
  22. #include <linux/sched.h>
  23. #include <linux/signal.h>
  24. #include <linux/kernel.h>
  25. #include <linux/mm.h>
  26. #include <linux/module.h>
  27. #include <linux/a.out.h>
  28. #include <linux/user.h>
  29. #include <linux/string.h>
  30. #include <linux/linkage.h>
  31. #include <linux/init.h>
  33. #include <asm/setup.h>
  34. #include <asm/fpu.h>
  35. #include <asm/system.h>
  36. #include <asm/uaccess.h>
  37. #include <asm/traps.h>
  38. #include <asm/pgalloc.h>
  39. #include <asm/machdep.h>
  40. #include <asm/siginfo.h>
  42. /* assembler routines */
  43. asmlinkage void system_call(void);
  44. asmlinkage void buserr(void);
  45. asmlinkage void trap(void);
  46. asmlinkage void inthandler(void);
  47. asmlinkage void nmihandler(void);
  48. #ifdef CONFIG_M68KFPU_EMU
  49. asmlinkage void fpu_emu(void);
  50. #endif
  52. e_vector vectors[256] = {
  53. 0, 0, buserr, trap, trap, trap, trap, trap,
  54. trap, trap, trap, trap, trap, trap, trap, trap,
  55. trap, trap, trap, trap, trap, trap, trap, trap,
  56. inthandler, inthandler, inthandler, inthandler,
  57. inthandler, inthandler, inthandler, inthandler,
  58. /* TRAP #0-15 */
  59. system_call, trap, trap, trap, trap, trap, trap, trap,
  60. trap, trap, trap, trap, trap, trap, trap, trap,
  61. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  62. };
  64. /* nmi handler for the Amiga */
  65. asm(".textn"
  66.     __ALIGN_STR "n"
  67.     SYMBOL_NAME_STR(nmihandler) ": rte");
  69. /*
  70.  * this must be called very early as the kernel might
  71.  * use some instruction that are emulated on the 060
  72.  */
  73. void __init base_trap_init(void)
  74. {
  75. if(MACH_IS_SUN3X) {
  76. extern e_vector *sun3x_prom_vbr;
  78. __asm__ volatile ("movec %%vbr, %0" : "=r" ((void*)sun3x_prom_vbr));
  79. }
  81. /* setup the exception vector table */
  82. __asm__ volatile ("movec %0,%%vbr" : : "r" ((void*)vectors));
  84. if (CPU_IS_060) {
  85. /* set up ISP entry points */
  86. asmlinkage void unimp_vec(void) asm ("_060_isp_unimp");
  88. vectors[VEC_UNIMPII] = unimp_vec;
  89. }
  90. }
  92. void __init trap_init (void)
  93. {
  94. int i;
  96. for (i = 48; i < 64; i++)
  97. if (!vectors[i])
  98. vectors[i] = trap;
  100. for (i = 64; i < 256; i++)
  101. vectors[i] = inthandler;
  103. #ifdef CONFIG_M68KFPU_EMU
  104. if (FPU_IS_EMU)
  105. vectors[VEC_LINE11] = fpu_emu;
  106. #endif
  108. if (CPU_IS_040 && !FPU_IS_EMU) {
  109. /* set up FPSP entry points */
  110. asmlinkage void dz_vec(void) asm ("dz");
  111. asmlinkage void inex_vec(void) asm ("inex");
  112. asmlinkage void ovfl_vec(void) asm ("ovfl");
  113. asmlinkage void unfl_vec(void) asm ("unfl");
  114. asmlinkage void snan_vec(void) asm ("snan");
  115. asmlinkage void operr_vec(void) asm ("operr");
  116. asmlinkage void bsun_vec(void) asm ("bsun");
  117. asmlinkage void fline_vec(void) asm ("fline");
  118. asmlinkage void unsupp_vec(void) asm ("unsupp");
  120. vectors[VEC_FPDIVZ] = dz_vec;
  121. vectors[VEC_FPIR] = inex_vec;
  122. vectors[VEC_FPOVER] = ovfl_vec;
  123. vectors[VEC_FPUNDER] = unfl_vec;
  124. vectors[VEC_FPNAN] = snan_vec;
  125. vectors[VEC_FPOE] = operr_vec;
  126. vectors[VEC_FPBRUC] = bsun_vec;
  127. vectors[VEC_LINE11] = fline_vec;
  128. vectors[VEC_FPUNSUP] = unsupp_vec;
  129. }
  131. if (CPU_IS_060 && !FPU_IS_EMU) {
  132. /* set up IFPSP entry points */
  133. asmlinkage void snan_vec(void) asm ("_060_fpsp_snan");
  134. asmlinkage void operr_vec(void) asm ("_060_fpsp_operr");
  135. asmlinkage void ovfl_vec(void) asm ("_060_fpsp_ovfl");
  136. asmlinkage void unfl_vec(void) asm ("_060_fpsp_unfl");
  137. asmlinkage void dz_vec(void) asm ("_060_fpsp_dz");
  138. asmlinkage void inex_vec(void) asm ("_060_fpsp_inex");
  139. asmlinkage void fline_vec(void) asm ("_060_fpsp_fline");
  140. asmlinkage void unsupp_vec(void) asm ("_060_fpsp_unsupp");
  141. asmlinkage void effadd_vec(void) asm ("_060_fpsp_effadd");
  143. vectors[VEC_FPNAN] = snan_vec;
  144. vectors[VEC_FPOE] = operr_vec;
  145. vectors[VEC_FPOVER] = ovfl_vec;
  146. vectors[VEC_FPUNDER] = unfl_vec;
  147. vectors[VEC_FPDIVZ] = dz_vec;
  148. vectors[VEC_FPIR] = inex_vec;
  149. vectors[VEC_LINE11] = fline_vec;
  150. vectors[VEC_FPUNSUP] = unsupp_vec;
  151. vectors[VEC_UNIMPEA] = effadd_vec;
  152. }
  154.         /* if running on an amiga, make the NMI interrupt do nothing */
  155. if (MACH_IS_AMIGA) {
  156. vectors[VEC_INT7] = nmihandler;
  157. }
  158. }
  161. static char *vec_names[] = {
  162. "RESET SP", "RESET PC", "BUS ERROR", "ADDRESS ERROR",
  163. "ILLEGAL INSTRUCTION", "ZERO DIVIDE", "CHK", "TRAPcc",
  164. "PRIVILEGE VIOLATION", "TRACE", "LINE 1010", "LINE 1111",
  165. "UNASSIGNED RESERVED 12", "COPROCESSOR PROTOCOL VIOLATION",
  166. "FORMAT ERROR", "UNINITIALIZED INTERRUPT",
  167. "UNASSIGNED RESERVED 16", "UNASSIGNED RESERVED 17",
  168. "UNASSIGNED RESERVED 18", "UNASSIGNED RESERVED 19",
  169. "UNASSIGNED RESERVED 20", "UNASSIGNED RESERVED 21",
  170. "UNASSIGNED RESERVED 22", "UNASSIGNED RESERVED 23",
  171. "SPURIOUS INTERRUPT", "LEVEL 1 INT", "LEVEL 2 INT", "LEVEL 3 INT",
  172. "LEVEL 4 INT", "LEVEL 5 INT", "LEVEL 6 INT", "LEVEL 7 INT",
  173. "SYSCALL", "TRAP #1", "TRAP #2", "TRAP #3",
  174. "TRAP #4", "TRAP #5", "TRAP #6", "TRAP #7",
  175. "TRAP #8", "TRAP #9", "TRAP #10", "TRAP #11",
  176. "TRAP #12", "TRAP #13", "TRAP #14", "TRAP #15",
  177. "FPCP BSUN", "FPCP INEXACT", "FPCP DIV BY 0", "FPCP UNDERFLOW",
  178. "FPCP OPERAND ERROR", "FPCP OVERFLOW", "FPCP SNAN",
  179. "FPCP UNSUPPORTED OPERATION",
  180. "MMU CONFIGURATION ERROR"
  181. };
  183. #ifndef CONFIG_SUN3
  184. static char *space_names[] = {
  185. "Space 0", "User Data", "User Program", "Space 3",
  186. "Space 4", "Super Data", "Super Program", "CPU"
  187. };
  188. #else
  189. static char *space_names[] = {
  190. "Space 0", "User Data", "User Program", "Control",
  191. "Space 4", "Super Data", "Super Program", "CPU"
  192. };
  193. #endif
  195. void die_if_kernel(char *,struct pt_regs *,int);
  196. asmlinkage int do_page_fault(struct pt_regs *regs, unsigned long address,
  197.                              unsigned long error_code);
  198. int send_fault_sig(struct pt_regs *regs);
  200. asmlinkage void trap_c(struct frame *fp);
  202. #if defined (CONFIG_M68060)
  203. static inline void access_error060 (struct frame *fp)
  204. {
  205. unsigned long fslw = fp->un.fmt4.pc; /* is really FSLW for access error */
  207. #ifdef DEBUG
  208. printk("fslw=%#lx, fa=%#lxn", fslw, fp->un.fmt4.effaddr);
  209. #endif
  211. if (fslw & MMU060_BPE) {
  212. /* branch prediction error -> clear branch cache */
  213. __asm__ __volatile__ ("movec %/cacr,%/d0nt"
  214.       "orl   #0x00400000,%/d0nt"
  215.       "movec %/d0,%/cacr"
  216.       : : : "d0" );
  217. /* return if there's no other error */
  218. if (!(fslw & MMU060_ERR_BITS) && !(fslw & MMU060_SEE))
  219. return;
  220. }
  222. if (fslw & (MMU060_DESC_ERR | MMU060_WP | MMU060_SP)) {
  223. unsigned long errorcode;
  224. unsigned long addr = fp->un.fmt4.effaddr;
  226. if (fslw & MMU060_MA)
  227. addr = (addr + PAGE_SIZE - 1) & PAGE_MASK;
  229. errorcode = 1;
  230. if (fslw & MMU060_DESC_ERR) {
  231. __flush_tlb040_one(addr);
  232. errorcode = 0;
  233. }
  234. if (fslw & MMU060_W)
  235. errorcode |= 2;
  236. #ifdef DEBUG
  237. printk("errorcode = %dn", errorcode );
  238. #endif
  239. do_page_fault(&fp->ptregs, addr, errorcode);
  240. } else if (fslw & (MMU060_SEE)){
  241. /* Software Emulation Error.
  242.  * fault during mem_read/mem_write in ifpsp060/os.S
  243.  */
  244. send_fault_sig(&fp->ptregs);
  245. } else {
  246. printk("pc=%#lx, fa=%#lxn", fp->ptregs.pc, fp->un.fmt4.effaddr);
  247. printk( "68060 access error, fslw=%lxn", fslw );
  248. trap_c( fp );
  249. }
  250. }
  251. #endif /* CONFIG_M68060 */
  253. #if defined (CONFIG_M68040)
  254. static inline unsigned long probe040(int iswrite, unsigned long addr, int wbs)
  255. {
  256. unsigned long mmusr;
  257. mm_segment_t old_fs = get_fs();
  259. set_fs(MAKE_MM_SEG(wbs));
  261. if (iswrite)
  262.                 asm volatile (".chip 68040; ptestw (%0); .chip 68k" : : "a" (addr));
  263. else
  264.                 asm volatile (".chip 68040; ptestr (%0); .chip 68k" : : "a" (addr));
  266.         asm volatile (".chip 68040; movec %%mmusr,%0; .chip 68k" : "=r" (mmusr));
  268. set_fs(old_fs); 
  270. return mmusr;
  271. }
  273. static inline int do_040writeback1(unsigned short wbs, unsigned long wba,
  274.    unsigned long wbd)
  275. {
  276. int res = 0;
  277. mm_segment_t old_fs = get_fs();
  279. /* set_fs can not be moved, otherwise put_user() may oops */
  280. set_fs(MAKE_MM_SEG(wbs));
  282. switch (wbs & WBSIZ_040) {
  283. case BA_SIZE_BYTE:
  284. res = put_user(wbd & 0xff, (char *)wba);
  285. break;
  286. case BA_SIZE_WORD:
  287. res = put_user(wbd & 0xffff, (short *)wba);
  288. break;
  289. case BA_SIZE_LONG:
  290. res = put_user(wbd, (int *)wba);
  291. break;
  292. }
  294. /* set_fs can not be moved, otherwise put_user() may oops */
  295. set_fs(old_fs); 
  298. #ifdef DEBUG
  299. printk("do_040writeback1, res=%dn",res);
  300. #endif
  302. return res;
  303. }
  305. /* after an exception in a writeback the stack frame coresponding
  306.  * to that exception is discarded, set a few bits in the old frame 
  307.  * to simulate what it should look like
  308.  */
  309. static inline void fix_xframe040(struct frame *fp, unsigned long wba, unsigned short wbs)
  310. {
  311. fp->un.fmt7.faddr = wba;
  312. fp->un.fmt7.ssw = wbs & 0xff;
  313. if (wba != current->thread.faddr)
  314.     fp->un.fmt7.ssw |= MA_040;
  315. }
  317. static inline void do_040writebacks(struct frame *fp)
  318. {
  319. int res = 0;
  320. #if 0
  321. if (fp->un.fmt7.wb1s & WBV_040)
  322. printk("access_error040: cannot handle 1st writeback. oops.n");
  323. #endif
  325. if ((fp->un.fmt7.wb2s & WBV_040) &&
  326.     !(fp->un.fmt7.wb2s & WBTT_040)) {
  327. res = do_040writeback1(fp->un.fmt7.wb2s, fp->un.fmt7.wb2a,
  328.        fp->un.fmt7.wb2d);
  329. if (res)
  330. fix_xframe040(fp, fp->un.fmt7.wb2a, fp->un.fmt7.wb2s);
  331. else 
  332. fp->un.fmt7.wb2s = 0;
  333. }
  335. /* do the 2nd wb only if the first one was succesful (except for a kernel wb) */
  336. if (fp->un.fmt7.wb3s & WBV_040 && (!res || fp->un.fmt7.wb3s & 4)) {
  337. res = do_040writeback1(fp->un.fmt7.wb3s, fp->un.fmt7.wb3a,
  338.        fp->un.fmt7.wb3d);
  339. if (res)
  340.     {
  341. fix_xframe040(fp, fp->un.fmt7.wb3a, fp->un.fmt7.wb3s);
  343. fp->un.fmt7.wb2s = fp->un.fmt7.wb3s;
  344. fp->un.fmt7.wb3s &= (~WBV_040);
  345. fp->un.fmt7.wb2a = fp->un.fmt7.wb3a;
  346. fp->un.fmt7.wb2d = fp->un.fmt7.wb3d;
  347.     }
  348. else
  349. fp->un.fmt7.wb3s = 0;
  350. }
  352. if (res)
  353. send_fault_sig(&fp->ptregs);
  354. }
  356. /*
  357.  * called from sigreturn(), must ensure userspace code didn't
  358.  * manipulate exception frame to circumvent protection, then complete
  359.  * pending writebacks
  360.  * we just clear TM2 to turn it into an userspace access
  361.  */
  362. asmlinkage void berr_040cleanup(struct frame *fp)
  363. {
  364. fp->un.fmt7.wb2s &= ~4;
  365. fp->un.fmt7.wb3s &= ~4;
  367. do_040writebacks(fp);
  368. }
  370. static inline void access_error040(struct frame *fp)
  371. {
  372. unsigned short ssw = fp->un.fmt7.ssw;
  373. unsigned long mmusr;
  375. #ifdef DEBUG
  376. printk("ssw=%#x, fa=%#lxn", ssw, fp->un.fmt7.faddr);
  377.         printk("wb1s=%#x, wb2s=%#x, wb3s=%#xn", fp->un.fmt7.wb1s,  
  378. fp->un.fmt7.wb2s, fp->un.fmt7.wb3s);
  379. printk ("wb2a=%lx, wb3a=%lx, wb2d=%lx, wb3d=%lxn", 
  380. fp->un.fmt7.wb2a, fp->un.fmt7.wb3a,
  381. fp->un.fmt7.wb2d, fp->un.fmt7.wb3d);
  382. #endif
  384. if (ssw & ATC_040) {
  385. unsigned long addr = fp->un.fmt7.faddr;
  386. unsigned long errorcode;
  388. /*
  389.  * The MMU status has to be determined AFTER the address
  390.  * has been corrected if there was a misaligned access (MA).
  391.  */
  392. if (ssw & MA_040)
  393. addr = (addr + 7) & -8;
  395. /* MMU error, get the MMUSR info for this access */
  396. mmusr = probe040(!(ssw & RW_040), addr, ssw);
  397. #ifdef DEBUG
  398. printk("mmusr = %lxn", mmusr);
  399. #endif
  400. errorcode = 1;
  401. if (!(mmusr & MMU_R_040)) {
  402. /* clear the invalid atc entry */
  403. __flush_tlb040_one(addr);
  404. errorcode = 0;
  405. }
  407. /* despite what documentation seems to say, RMW 
  408.  * accesses have always both the LK and RW bits set */
  409. if (!(ssw & RW_040) || (ssw & LK_040))
  410. errorcode |= 2;
  412. if (do_page_fault(&fp->ptregs, addr, errorcode)) {
  413. #ifdef DEBUG
  414.         printk("do_page_fault() !=0 n");
  415. #endif
  416. if (user_mode(&fp->ptregs)){
  417. /* delay writebacks after signal delivery */
  418. #ifdef DEBUG
  419.         printk(".. was usermode - returnn");
  420. #endif
  421. return;
  422. }
  423. /* disable writeback into user space from kernel
  424.  * (if do_page_fault didn't fix the mapping,
  425.                          * the writeback won't do good)
  426.  */
  427. #ifdef DEBUG
  428. printk(".. disabling wb2n");
  429. #endif
  430. if (fp->un.fmt7.wb2a == fp->un.fmt7.faddr)
  431. fp->un.fmt7.wb2s &= ~WBV_040;
  432. }
  433. } else {
  434. printk("68040 access error, ssw=%xn", ssw);
  435. trap_c(fp);
  436. }
  438. do_040writebacks(fp);
  439. }
  440. #endif /* CONFIG_M68040 */
  442. #if defined(CONFIG_SUN3)
  443. #include <asm/sun3mmu.h>
  445. extern int mmu_emu_handle_fault (unsigned long, int, int);
  447. /* sun3 version of bus_error030 */
  449. extern inline void bus_error030 (struct frame *fp)
  450. {
  451. unsigned char buserr_type = sun3_get_buserr ();
  452. unsigned long addr, errorcode;
  453. unsigned short ssw = fp->un.fmtb.ssw;
  455. #if DEBUG
  456. if (ssw & (FC | FB))
  457. printk ("Instruction fault at %#010lxn",
  458. ssw & FC ?
  459. fp->ptregs.format == 0xa ? fp->ptregs.pc + 2 : fp->un.fmtb.baddr - 2
  460. :
  461. fp->ptregs.format == 0xa ? fp->ptregs.pc + 4 : fp->un.fmtb.baddr);
  462. if (ssw & DF) 
  463. printk ("Data %s fault at %#010lx in %s (pc=%#lx)n",
  464. ssw & RW ? "read" : "write",
  465. fp->un.fmtb.daddr,
  466. space_names[ssw & DFC], fp->ptregs.pc);
  467. #endif
  469. /*
  470.  * Check if this page should be demand-mapped. This needs to go before
  471.  * the testing for a bad kernel-space access (demand-mapping applies
  472.  * to kernel accesses too).
  473.  */
  475. if ((ssw & DF)
  476.     && (buserr_type & (SUN3_BUSERR_PROTERR | SUN3_BUSERR_INVALID))) {
  477. if (mmu_emu_handle_fault (fp->un.fmtb.daddr, ssw & RW, 0))
  478. return;
  479. }
  481. /* Check for kernel-space pagefault (BAD). */
  482. if (fp->ptregs.sr & PS_S) {
  483. /* kernel fault must be a data fault to user space */
  484. if (! ((ssw & DF) && ((ssw & DFC) == USER_DATA))) {
  485.      // try checking the kernel mappings before surrender
  486.      if (mmu_emu_handle_fault (fp->un.fmtb.daddr, ssw & RW, 1))
  487.   return;
  488. /* instruction fault or kernel data fault! */
  489. if (ssw & (FC | FB))
  490. printk ("Instruction fault at %#010lxn",
  491. fp->ptregs.pc);
  492. if (ssw & DF) {
  493. printk ("Data %s fault at %#010lx in %s (pc=%#lx)n",
  494. ssw & RW ? "read" : "write",
  495. fp->un.fmtb.daddr,
  496. space_names[ssw & DFC], fp->ptregs.pc);
  497. }
  498. printk ("BAD KERNEL BUSERRn");
  500. die_if_kernel("Oops", &fp->ptregs,0);
  501. force_sig(SIGKILL, current);
  502. return;
  503. }
  504. } else {
  505. /* user fault */
  506. if (!(ssw & (FC | FB)) && !(ssw & DF))
  507. /* not an instruction fault or data fault! BAD */
  508. panic ("USER BUSERR w/o instruction or data fault");
  509. }
  512. /* First handle the data fault, if any.  */
  513. if (ssw & DF) {
  514. addr = fp->un.fmtb.daddr;
  516. // errorcode bit 0: 0 -> no page 1 -> protection fault
  517. // errorcode bit 1: 0 -> read fault 1 -> write fault
  519. // (buserr_type & SUN3_BUSERR_PROTERR) -> protection fault
  520. // (buserr_type & SUN3_BUSERR_INVALID) -> invalid page fault
  522. if (buserr_type & SUN3_BUSERR_PROTERR)
  523. errorcode = 0x01;
  524. else if (buserr_type & SUN3_BUSERR_INVALID)
  525. errorcode = 0x00;
  526. else {
  527. #ifdef DEBUG
  528. printk ("*** unexpected busfault type=%#04xn", buserr_type);
  529. printk ("invalid %s access at %#lx from pc %#lxn",
  530. !(ssw & RW) ? "write" : "read", addr,
  531. fp->ptregs.pc);
  532. #endif
  533. die_if_kernel ("Oops", &fp->ptregs, buserr_type);
  534. force_sig (SIGBUS, current);
  535. return;
  536. }
  538. //todo: wtf is RM bit? --m
  539. if (!(ssw & RW) || ssw & RM)
  540. errorcode |= 0x02;
  542. /* Handle page fault. */
  543. do_page_fault (&fp->ptregs, addr, errorcode);
  545. /* Retry the data fault now. */
  546. return;
  547. }
  549. /* Now handle the instruction fault. */
  551. /* Get the fault address. */
  552. if (fp->ptregs.format == 0xA)
  553. addr = fp->ptregs.pc + 4;
  554. else
  555. addr = fp->un.fmtb.baddr;
  556. if (ssw & FC)
  557. addr -= 2;
  559. if (buserr_type & SUN3_BUSERR_INVALID) {
  560. if (!mmu_emu_handle_fault (fp->un.fmtb.daddr, 1, 0))
  561. do_page_fault (&fp->ptregs, addr, 0);
  562.        } else {
  563. #ifdef DEBUG
  564. printk ("protection fault on insn access (segv).n");
  565. #endif
  566. force_sig (SIGSEGV, current);
  567.        }
  568. }
  569. #else
  570. #if defined(CPU_M68020_OR_M68030)
  571. static inline void bus_error030 (struct frame *fp)
  572. {
  573. volatile unsigned short temp;
  574. unsigned short mmusr;
  575. unsigned long addr, errorcode;
  576. unsigned short ssw = fp->un.fmtb.ssw;
  577. int user_space_fault = 1;
  578. #if DEBUG
  579. unsigned long desc;
  580. #endif
  582. #if DEBUG
  583. printk ("pid = %x  ", current->pid);
  584. printk ("SSW=%#06x  ", ssw);
  586. if (ssw & (FC | FB))
  587. printk ("Instruction fault at %#010lxn",
  588. ssw & FC ?
  589. fp->ptregs.format == 0xa ? fp->ptregs.pc + 2 : fp->un.fmtb.baddr - 2
  590. :
  591. fp->ptregs.format == 0xa ? fp->ptregs.pc + 4 : fp->un.fmtb.baddr);
  592. if (ssw & DF)
  593. printk ("Data %s fault at %#010lx in %s (pc=%#lx)n",
  594. ssw & RW ? "read" : "write",
  595. fp->un.fmtb.daddr,
  596. space_names[ssw & DFC], fp->ptregs.pc);
  597. #endif
  599. if (fp->ptregs.sr & PS_S) {
  600. /* kernel fault must be a data fault to user space */
  601. if (! ((ssw & DF) && ((ssw & DFC) == USER_DATA))) {
  602. /* instruction fault or kernel data fault! */
  603. if (ssw & (FC | FB))
  604. printk ("Instruction fault at %#010lxn",
  605. fp->ptregs.pc);
  606. if (ssw & DF) {
  607. printk ("Data %s fault at %#010lx in %s (pc=%#lx)n",
  608. ssw & RW ? "read" : "write",
  609. fp->un.fmtb.daddr,
  610. space_names[ssw & DFC], fp->ptregs.pc);
  611. }
  612. printk ("BAD KERNEL BUSERRn");
  613. die_if_kernel("Oops",&fp->ptregs,0);
  614. force_sig(SIGKILL, current);
  615. return;
  616. }
  617. } else {
  618. /* user fault */
  619. if (!(ssw & (FC | FB)) && !(ssw & DF))
  620. /* not an instruction fault or data fault! BAD */
  621. panic ("USER BUSERR w/o instruction or data fault");
  622. user_space_fault = 1;
  623. #if DEBUG
  624. printk("User space bus-errorn");
  625. #endif
  626. }
  628. /* ++andreas: If a data fault and an instruction fault happen
  629.    at the same time map in both pages.  */
  631. /* First handle the data fault, if any.  */
  632. if (ssw & DF)
  633.   {
  634.     addr = fp->un.fmtb.daddr;
  636.     mmusr = MMU_I;
  637.     if (user_space_fault) {
  638. #if DEBUG
  639.     asm volatile ("ptestr #1,%2@,#7,%0nt"
  640.   "pmove %/psr,%1@"
  641.   : "=a&" (desc)
  642.   : "a" (&temp), "a" (addr));
  643. #else
  644.     asm volatile ("ptestr #1,%1@,#7nt"
  645.   "pmove %/psr,%0@"
  646.   : : "a" (&temp), "a" (addr));
  647. #endif
  648.     mmusr = temp;
  649.     }
  650.       
  651. #if DEBUG
  652.     printk ("mmusr is %#x for addr %#lx in task %pn",
  653.     mmusr, addr, current);
  654.     printk ("descriptor address is %#lx, contents %#lxn",
  655.     __va(desc), *(unsigned long *)__va(desc));
  656. #endif
  658.     errorcode = (mmusr & MMU_I) ? 0 : 1;
  659.     if (!(ssw & RW) || (ssw & RM))
  660.     errorcode |= 2;
  662.     if (mmusr & (MMU_I | MMU_WP)) {
  663. /* Don't try to do anything further if an exception was
  664.    handled. */
  665. if (do_page_fault (&fp->ptregs, addr, errorcode) < 0)
  666. return;
  667.     } else if (mmusr & (MMU_B|MMU_L|MMU_S)) {
  668.     printk ("invalid %s access at %#lx from pc %#lxn",
  669.     !(ssw & RW) ? "write" : "read", addr,
  670.     fp->ptregs.pc);
  671.     die_if_kernel("Oops",&fp->ptregs,mmusr);
  672.     force_sig(SIGSEGV, current);
  673.     return;
  674.     } else {
  675. #if 0
  676.     static volatile long tlong;
  677. #endif
  679.     printk ("weird %s access at %#lx from pc %#lx (ssw is %#x)n",
  680.     !(ssw & RW) ? "write" : "read", addr,
  681.     fp->ptregs.pc, ssw);
  682.     asm volatile ("ptestr #1,%1@,#0nt"
  683.   "pmove %/psr,%0@"
  684.   : /* no outputs */
  685.   : "a" (&temp), "a" (addr));
  686.     mmusr = temp;
  688.     printk ("level 0 mmusr is %#xn", mmusr);
  689. #if 0
  690.     asm volatile ("pmove %/tt0,%0@"
  691.   : /* no outputs */
  692.   : "a" (&tlong));
  693.     printk ("tt0 is %#lx, ", tlong);
  694.     asm volatile ("pmove %/tt1,%0@"
  695.   : /* no outputs */
  696.   : "a" (&tlong));
  697.     printk ("tt1 is %#lxn", tlong);
  698. #endif
  699. #if DEBUG
  700.     printk("Unknown SIGSEGV - 1n");
  701. #endif
  702.     die_if_kernel("Oops",&fp->ptregs,mmusr);
  703.     force_sig(SIGSEGV, current);
  704.     return;
  705.     }
  707.     /* setup an ATC entry for the access about to be retried */
  708.     if (!(ssw & RW))
  709.     asm volatile ("ploadw %1,%0@" : /* no outputs */
  710.   : "a" (addr), "d" (ssw));
  711.     else
  712.     asm volatile ("ploadr %1,%0@" : /* no outputs */
  713.   : "a" (addr), "d" (ssw));
  714.   }
  716. /* Now handle the instruction fault. */
  718. if (!(ssw & (FC|FB)))
  719. return;
  721. /* get the fault address */
  722. if (fp->ptregs.format == 10)
  723. addr = fp->ptregs.pc + 4;
  724. else
  725. addr = fp->un.fmtb.baddr;
  726. if (ssw & FC)
  727. addr -= 2;
  729. if ((ssw & DF) && ((addr ^ fp->un.fmtb.daddr) & PAGE_MASK) == 0)
  730. /* Insn fault on same page as data fault.  But we
  731.    should still create the ATC entry.  */
  732. goto create_atc_entry;
  734. mmusr = MMU_I;
  735. if (user_space_fault) {
  736. #if DEBUG
  737. asm volatile ("ptestr #1,%2@,#7,%0nt"
  738.       "pmove %/psr,%1@"
  739.       : "=a&" (desc)
  740.       : "a" (&temp), "a" (addr));
  741. #else
  742. asm volatile ("ptestr #1,%1@,#7nt"
  743.       "pmove %/psr,%0@"
  744.       : : "a" (&temp), "a" (addr));
  745. #endif
  746. mmusr = temp;
  747. }
  748.       
  749. #ifdef DEBUG
  750. printk ("mmusr is %#x for addr %#lx in task %pn",
  751. mmusr, addr, current);
  752. printk ("descriptor address is %#lx, contents %#lxn",
  753. __va(desc), *(unsigned long *)__va(desc));
  754. #endif
  756. if (mmusr & MMU_I)
  757. do_page_fault (&fp->ptregs, addr, 0);
  758. else if (mmusr & (MMU_B|MMU_L|MMU_S)) {
  759. printk ("invalid insn access at %#lx from pc %#lxn",
  760. addr, fp->ptregs.pc);
  761. #if DEBUG
  762. printk("Unknown SIGSEGV - 2n");
  763. #endif
  764. die_if_kernel("Oops",&fp->ptregs,mmusr);
  765. force_sig(SIGSEGV, current);
  766. return;
  767. }
  769. create_atc_entry:
  770. /* setup an ATC entry for the access about to be retried */
  771. asm volatile ("ploadr #2,%0@" : /* no outputs */
  772.       : "a" (addr));
  773. }
  774. #endif /* CPU_M68020_OR_M68030 */
  775. #endif /* !CONFIG_SUN3 */
  777. asmlinkage void buserr_c(struct frame *fp)
  778. {
  779. /* Only set esp0 if coming from user mode */
  780. if (user_mode(&fp->ptregs))
  781. current->thread.esp0 = (unsigned long) fp;
  783. #if DEBUG
  784. printk ("*** Bus Error *** Format is %xn", fp->ptregs.format);
  785. #endif
  787. switch (fp->ptregs.format) {
  788. #if defined (CONFIG_M68060)
  789. case 4: /* 68060 access error */
  790.   access_error060 (fp);
  791.   break;
  792. #endif
  793. #if defined (CONFIG_M68040)
  794. case 0x7: /* 68040 access error */
  795.   access_error040 (fp);
  796.   break;
  797. #endif
  798. #if defined (CPU_M68020_OR_M68030)
  799. case 0xa:
  800. case 0xb:
  801.   bus_error030 (fp);
  802.   break;
  803. #endif
  804. default:
  805.   die_if_kernel("bad frame format",&fp->ptregs,0);
  806. #if DEBUG
  807.   printk("Unknown SIGSEGV - 4n");
  808. #endif
  809.   force_sig(SIGSEGV, current);
  810. }
  811. }
  814. int kstack_depth_to_print = 48;
  815. extern struct module kernel_module;
  817. static inline int kernel_text_address(unsigned long addr)
  818. {
  819. #ifdef CONFIG_MODULES
  820. struct module *mod;
  821. #endif
  822. extern char _stext, _etext;
  824. if (addr >= (unsigned long) &_stext &&
  825.     addr <= (unsigned long) &_etext)
  826. return 1;
  828. #ifdef CONFIG_MODULES
  829. for (mod = module_list; mod != &kernel_module; mod = mod->next) {
  830. /* mod_bound tests for addr being inside the vmalloc'ed
  831.  * module area. Of course it'd be better to test only
  832.  * for the .text subset... */
  833. if (mod_bound(addr, 0, mod))
  834. return 1;
  835. }
  836. #endif
  838. return 0;
  839. }
  841. void show_trace(unsigned long *stack)
  842. {
  843. unsigned long *endstack;
  844. unsigned long addr;
  845. int i;
  847. printk("Call Trace:");
  848. addr = (unsigned long)stack + THREAD_SIZE - 1;
  849. endstack = (unsigned long *)(addr & -THREAD_SIZE);
  850. i = 0;
  851. while (stack + 1 <= endstack) {
  852. addr = *stack++;
  853. /*
  854.  * If the address is either in the text segment of the
  855.  * kernel, or in the region which contains vmalloc'ed
  856.  * memory, it *may* be the address of a calling
  857.  * routine; if so, print it so that someone tracing
  858.  * down the cause of the crash will be able to figure
  859.  * out the call path that was taken.
  860.  */
  861. if (kernel_text_address(addr)) {
  862. if (i % 4 == 0)
  863. printk("n       ");
  864. printk(" [<%08lx>]", addr);
  865. i++;
  866. }
  867. }
  868. printk("n");
  869. }
  871. void show_trace_task(struct task_struct *tsk)
  872. {
  873. show_trace((unsigned long *)tsk->thread.esp0);
  874. }
  876. static void show_stack(struct frame *fp)
  877. {
  878. unsigned long *stack, *endstack, addr;
  879. int i;
  881. if (fp == NULL)
  882.     fp = (struct frame *)&fp;
  884. addr = (unsigned long)&fp->un;
  885. printk("Frame format=%X ", fp->ptregs.format);
  886. switch (fp->ptregs.format) {
  887. case 0x2:
  888.     printk("instr addr=%08lxn", fp->un.fmt2.iaddr);
  889.     addr += sizeof(fp->un.fmt2);
  890.     break;
  891. case 0x3:
  892.     printk("eff addr=%08lxn", fp->un.fmt3.effaddr);
  893.     addr += sizeof(fp->un.fmt3);
  894.     break;
  895. case 0x4:
  896.     printk((CPU_IS_060 ? "fault addr=%08lx fslw=%08lxn"
  897.     : "eff addr=%08lx pc=%08lxn"),
  898.    fp->un.fmt4.effaddr, fp->un.fmt4.pc);
  899.     addr += sizeof(fp->un.fmt4);
  900.     break;
  901. case 0x7:
  902.     printk("eff addr=%08lx ssw=%04x faddr=%08lxn",
  903.    fp->un.fmt7.effaddr, fp->un.fmt7.ssw, fp->un.fmt7.faddr);
  904.     printk("wb 1 stat/addr/data: %04x %08lx %08lxn",
  905.    fp->un.fmt7.wb1s, fp->un.fmt7.wb1a, fp->un.fmt7.wb1dpd0);
  906.     printk("wb 2 stat/addr/data: %04x %08lx %08lxn",
  907.    fp->un.fmt7.wb2s, fp->un.fmt7.wb2a, fp->un.fmt7.wb2d);
  908.     printk("wb 3 stat/addr/data: %04x %08lx %08lxn",
  909.    fp->un.fmt7.wb3s, fp->un.fmt7.wb3a, fp->un.fmt7.wb3d);
  910.     printk("push data: %08lx %08lx %08lx %08lxn",
  911.    fp->un.fmt7.wb1dpd0, fp->un.fmt7.pd1, fp->un.fmt7.pd2,
  912.    fp->un.fmt7.pd3);
  913.     addr += sizeof(fp->un.fmt7);
  914.     break;
  915. case 0x9:
  916.     printk("instr addr=%08lxn", fp->un.fmt9.iaddr);
  917.     addr += sizeof(fp->un.fmt9);
  918.     break;
  919. case 0xa:
  920.     printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lxn",
  921.    fp->un.fmta.ssw, fp->un.fmta.isc, fp->un.fmta.isb,
  922.    fp->un.fmta.daddr, fp->un.fmta.dobuf);
  923.     addr += sizeof(fp->un.fmta);
  924.     break;
  925. case 0xb:
  926.     printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lxn",
  927.    fp->un.fmtb.ssw, fp->un.fmtb.isc, fp->un.fmtb.isb,
  928.    fp->un.fmtb.daddr, fp->un.fmtb.dobuf);
  929.     printk("baddr=%08lx dibuf=%08lx ver=%xn",
  930.    fp->un.fmtb.baddr, fp->un.fmtb.dibuf, fp->un.fmtb.ver);
  931.     addr += sizeof(fp->un.fmtb);
  932.     break;
  933. default:
  934.     printk("n");
  935. }
  937. stack = (unsigned long *)addr;
  938. endstack = (unsigned long *)((addr + THREAD_SIZE - 1) & -THREAD_SIZE);
  940. printk("Stack from %08lx:", (unsigned long)stack);
  941. for (i = 0; i < kstack_depth_to_print; i++) {
  942. if (stack + 1 > endstack)
  943. break;
  944. if (i % 8 == 0)
  945. printk("n       ");
  946. printk(" %08lx", *stack++);
  947. }
  948. printk("n");
  949. show_trace((unsigned long *)addr);
  951. printk("Code: ");
  952. for (i = 0; i < 10; i++)
  953. printk("%04x ", 0xffff & ((short *) fp->ptregs.pc)[i]);
  954. printk ("n");
  955. }
  957. /*
  958.  * The architecture-independent backtrace generator
  959.  */
  960. void dump_stack(void)
  961. {
  962. show_stack(0);
  963. }
  965. void bad_super_trap (struct frame *fp)
  966. {
  967. console_verbose();
  968. if (fp->ptregs.vector < 4*sizeof(vec_names)/sizeof(vec_names[0]))
  969. printk ("*** %s ***   FORMAT=%Xn",
  970. vec_names[(fp->ptregs.vector) >> 2],
  971. fp->ptregs.format);
  972. else
  973. printk ("*** Exception %d ***   FORMAT=%Xn",
  974. (fp->ptregs.vector) >> 2, 
  975. fp->ptregs.format);
  976. if (fp->ptregs.vector >> 2 == VEC_ADDRERR && CPU_IS_020_OR_030) {
  977. unsigned short ssw = fp->un.fmtb.ssw;
  979. printk ("SSW=%#06x  ", ssw);
  981. if (ssw & RC)
  982. printk ("Pipe stage C instruction fault at %#010lxn",
  983. (fp->ptregs.format) == 0xA ?
  984. fp->ptregs.pc + 2 : fp->un.fmtb.baddr - 2);
  985. if (ssw & RB)
  986. printk ("Pipe stage B instruction fault at %#010lxn",
  987. (fp->ptregs.format) == 0xA ?
  988. fp->ptregs.pc + 4 : fp->un.fmtb.baddr);
  989. if (ssw & DF)
  990. printk ("Data %s fault at %#010lx in %s (pc=%#lx)n",
  991. ssw & RW ? "read" : "write",
  992. fp->un.fmtb.daddr, space_names[ssw & DFC],
  993. fp->ptregs.pc);
  994. }
  995. printk ("Current process id is %dn", current->pid);
  996. die_if_kernel("BAD KERNEL TRAP", &fp->ptregs, 0);
  997. }
  999. asmlinkage void trap_c(struct frame *fp)
  1000. {
  1001. int sig;
  1002. siginfo_t info;
  1004. if (fp->ptregs.sr & PS_S) {
  1005. if ((fp->ptregs.vector >> 2) == VEC_TRACE) {
  1006. /* traced a trapping instruction */
  1007. current->ptrace |= PT_DTRACE;
  1008. } else
  1009. bad_super_trap(fp);
  1010. return;
  1011. }
  1013. /* send the appropriate signal to the user program */
  1014. switch ((fp->ptregs.vector) >> 2) {
  1015.     case VEC_ADDRERR:
  1016. info.si_code = BUS_ADRALN;
  1017. sig = SIGBUS;
  1018. break;
  1019.     case VEC_ILLEGAL:
  1020.     case VEC_LINE10:
  1021.     case VEC_LINE11:
  1022. info.si_code = ILL_ILLOPC;
  1023. sig = SIGILL;
  1024. break;
  1025.     case VEC_PRIV:
  1026. info.si_code = ILL_PRVOPC;
  1027. sig = SIGILL;
  1028. break;
  1029.     case VEC_COPROC:
  1030. info.si_code = ILL_COPROC;
  1031. sig = SIGILL;
  1032. break;
  1033.     case VEC_TRAP1:
  1034.     case VEC_TRAP2:
  1035.     case VEC_TRAP3:
  1036.     case VEC_TRAP4:
  1037.     case VEC_TRAP5:
  1038.     case VEC_TRAP6:
  1039.     case VEC_TRAP7:
  1040.     case VEC_TRAP8:
  1041.     case VEC_TRAP9:
  1042.     case VEC_TRAP10:
  1043.     case VEC_TRAP11:
  1044.     case VEC_TRAP12:
  1045.     case VEC_TRAP13:
  1046.     case VEC_TRAP14:
  1047. info.si_code = ILL_ILLTRP;
  1048. sig = SIGILL;
  1049. break;
  1050.     case VEC_FPBRUC:
  1051.     case VEC_FPOE:
  1052.     case VEC_FPNAN:
  1053. info.si_code = FPE_FLTINV;
  1054. sig = SIGFPE;
  1055. break;
  1056.     case VEC_FPIR:
  1057. info.si_code = FPE_FLTRES;
  1058. sig = SIGFPE;
  1059. break;
  1060.     case VEC_FPDIVZ:
  1061. info.si_code = FPE_FLTDIV;
  1062. sig = SIGFPE;
  1063. break;
  1064.     case VEC_FPUNDER:
  1065. info.si_code = FPE_FLTUND;
  1066. sig = SIGFPE;
  1067. break;
  1068.     case VEC_FPOVER:
  1069. info.si_code = FPE_FLTOVF;
  1070. sig = SIGFPE;
  1071. break;
  1072.     case VEC_ZERODIV:
  1073. info.si_code = FPE_INTDIV;
  1074. sig = SIGFPE;
  1075. break;
  1076.     case VEC_CHK:
  1077.     case VEC_TRAP:
  1078. info.si_code = FPE_INTOVF;
  1079. sig = SIGFPE;
  1080. break;
  1081.     case VEC_TRACE: /* ptrace single step */
  1082. info.si_code = TRAP_TRACE;
  1083. sig = SIGTRAP;
  1084. break;
  1085.     case VEC_TRAP15: /* breakpoint */
  1086. info.si_code = TRAP_BRKPT;
  1087. sig = SIGTRAP;
  1088. break;
  1089.     default:
  1090. info.si_code = ILL_ILLOPC;
  1091. sig = SIGILL;
  1092. break;
  1093. }
  1094. info.si_signo = sig;
  1095. info.si_errno = 0;
  1096. switch (fp->ptregs.format) {
  1097.     default:
  1098. info.si_addr = (void *) fp->ptregs.pc;
  1099. break;
  1100.     case 2:
  1101. info.si_addr = (void *) fp->un.fmt2.iaddr;
  1102. break;
  1103.     case 7:
  1104. info.si_addr = (void *) fp->un.fmt7.effaddr;
  1105. break;
  1106.     case 9:
  1107. info.si_addr = (void *) fp->un.fmt9.iaddr;
  1108. break;
  1109.     case 10:
  1110. info.si_addr = (void *) fp->un.fmta.daddr;
  1111. break;
  1112.     case 11:
  1113. info.si_addr = (void *) fp->un.fmtb.daddr;
  1114. break;
  1115. }
  1116. force_sig_info (sig, &info, current);
  1117. }
  1119. void die_if_kernel (char *str, struct pt_regs *fp, int nr)
  1120. {
  1121. if (!(fp->sr & PS_S))
  1122. return;
  1124. console_verbose();
  1125. printk("%s: %08xn",str,nr);
  1126. printk("PC: [<%08lx>]nSR: %04x  SP: %p  a2: %08lxn",
  1127.        fp->pc, fp->sr, fp, fp->a2);
  1128. printk("d0: %08lx    d1: %08lx    d2: %08lx    d3: %08lxn",
  1129.        fp->d0, fp->d1, fp->d2, fp->d3);
  1130. printk("d4: %08lx    d5: %08lx    a0: %08lx    a1: %08lxn",
  1131.        fp->d4, fp->d5, fp->a0, fp->a1);
  1133. printk("Process %s (pid: %d, stackpage=%08lx)n",
  1134. current->comm, current->pid, PAGE_SIZE+(unsigned long)current);
  1135. show_stack((struct frame *)fp);
  1136. do_exit(SIGSEGV);
  1137. }
  1139. /*
  1140.  * This function is called if an error occur while accessing
  1141.  * user-space from the fpsp040 code.
  1142.  */
  1143. asmlinkage void fpsp040_die(void)
  1144. {
  1145. do_exit(SIGSEGV);
  1146. }
  1148. #ifdef CONFIG_M68KFPU_EMU
  1149. asmlinkage void fpemu_signal(int signal, int code, void *addr)
  1150. {
  1151. siginfo_t info;
  1153. info.si_signo = signal;
  1154. info.si_errno = 0;
  1155. info.si_code = code;
  1156. info.si_addr = addr;
  1157. force_sig_info(signal, &info, current);
  1158. }
  1159. #endif