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

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

Linux/Unix编程

开发平台：

Unix_Linux

traps.c：源码内容
  1. /*
  2.  *  linux/arch/parisc/traps.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *  Copyright (C) 1999, 2000  Philipp Rumpf <prumpf@tux.org>
  6.  */
  8. /*
  9.  * 'Traps.c' handles hardware traps and faults after we have saved some
  10.  * state in 'asm.s'.
  11.  */
  13. #include <linux/config.h>
  14. #include <linux/sched.h>
  15. #include <linux/kernel.h>
  16. #include <linux/string.h>
  17. #include <linux/errno.h>
  18. #include <linux/ptrace.h>
  19. #include <linux/timer.h>
  20. #include <linux/mm.h>
  21. #include <linux/smp.h>
  22. #include <linux/smp_lock.h>
  23. #include <linux/spinlock.h>
  24. #include <linux/init.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/console.h>
  28. #include <asm/system.h>
  29. #include <asm/uaccess.h>
  30. #include <asm/io.h>
  31. #include <asm/irq.h>
  32. #include <asm/traps.h>
  33. #include <asm/unaligned.h>
  34. #include <asm/atomic.h>
  35. #include <asm/smp.h>
  36. #include <asm/pdc.h>
  38. #include "../math-emu/math-emu.h" /* for handle_fpe() */
  40. #ifdef CONFIG_KWDB
  41. #include <kdb/break.h> /* for BI2_KGDB_GDB */
  42. #include <kdb/kgdb_types.h> /* for __() */
  43. #include <kdb/save_state.h> /* for struct save_state */
  44. #include <kdb/kgdb_machine.h> /* for pt_regs_to_ssp and ssp_to_pt_regs */
  45. #include <kdb/trap.h> /* for I_BRK_INST */
  46. #endif /* CONFIG_KWDB */
  48. #define PRINT_USER_FAULTS /* (turn this on if you want user faults to be */
  49.   /*  dumped to the console via printk)          */
  51. static int printbinary(char *buf, unsigned long x, int nbits)
  52. {
  53. unsigned long mask = 1UL << (nbits - 1);
  54. while (mask != 0) {
  55. *buf++ = (mask & x ? '1' : '0');
  56. mask >>= 1;
  57. }
  58. *buf = '';
  60. return nbits;
  61. }
  63. #ifdef __LP64__
  64. #define RFMT "%016lx"
  65. #else
  66. #define RFMT "%08lx"
  67. #endif
  69. void show_regs(struct pt_regs *regs)
  70. {
  71. int i;
  72. char buf[128], *p;
  73. char *level;
  74. unsigned long cr30;
  75. unsigned long cr31;
  77. level = user_mode(regs) ? KERN_DEBUG : KERN_CRIT;
  79. printk("%sn", level); /* don't want to have that pretty register dump messed up */
  81. printk("%s     YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDIn", level);
  82. printbinary(buf, regs->gr[0], 32);
  83. printk("%sPSW: %s %sn", level, buf, print_tainted());
  85. for (i = 0; i < 32; i += 4) {
  86. int j;
  87. p = buf;
  88. p += sprintf(p, "%sr%02d-%02d ", level, i, i + 3);
  89. for (j = 0; j < 4; j++) {
  90. p += sprintf(p, " " RFMT, (i+j) == 0 ? 0 : regs->gr[i + j]);
  91. }
  92. printk("%sn", buf);
  93. }
  95. for (i = 0; i < 8; i += 4) {
  96. int j;
  97. p = buf;
  98. p += sprintf(p, "%ssr%d-%d  ", level, i, i + 3);
  99. for (j = 0; j < 4; j++) {
  100. p += sprintf(p, " " RFMT, regs->sr[i + j]);
  101. }
  102. printk("%sn", buf);
  103. }
  105. #if RIDICULOUSLY_VERBOSE
  106. for (i = 0; i < 32; i += 2)
  107. printk("%sFR%02d : %016lx  FR%2d : %016lx", level, i,
  108. regs->fr[i], i+1, regs->fr[i+1]);
  109. #endif
  111. cr30 = mfctl(30);
  112. cr31 = mfctl(31);
  113. printk("%sn", level);
  114. printk("%sIASQ: " RFMT " " RFMT " IAOQ: " RFMT " " RFMT "n",
  115.        level, regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]);
  116. printk("%s IIR: %08lx    ISR: " RFMT "  IOR: " RFMT "n",
  117.        level, regs->iir, regs->isr, regs->ior);
  118. printk("%s CPU: %8d   CR30: " RFMT " CR31: " RFMT "n",
  119.        level, ((struct task_struct *)cr30)->processor, cr30, cr31);
  120. printk("%s ORIG_R28: " RFMT "n", level, regs->orig_r28);
  121. }
  124. static void dump_stack(unsigned long from, unsigned long to, int istackflag)
  125. {
  126. unsigned int *fromptr;
  127. unsigned int *toptr;
  129. fromptr = (unsigned int *)from;
  130. toptr = (unsigned int *)to;
  132. printk("n");
  133. printk(KERN_CRIT "Dumping %sStack from 0x%p to 0x%p:n",
  134. istackflag ? "Interrupt " : "",
  135. fromptr, toptr);
  137. while (fromptr < toptr) {
  138. printk(KERN_CRIT "%04lx %08x %08x %08x %08x %08x %08x %08x %08xn",
  139.     ((unsigned long)fromptr) & 0xffff,
  140.     fromptr[0], fromptr[1], fromptr[2], fromptr[3],
  141.     fromptr[4], fromptr[5], fromptr[6], fromptr[7]);
  142. fromptr += 8;
  143. }
  144. }
  147. void show_stack(struct pt_regs *regs)
  148. {
  149. #if 1
  150. /* If regs->sr[7] == 0, we are on a kernel stack */
  151. if (regs->sr[7] == 0) {
  153. unsigned long sp = regs->gr[30];
  154. unsigned long cr30;
  155. unsigned long cr31;
  156. unsigned long stack_start;
  157. struct pt_regs *int_regs;
  159. cr30 = mfctl(30);
  160. cr31 = mfctl(31);
  161. stack_start = sp & ~(ISTACK_SIZE - 1);
  162. if (stack_start == cr31) {
  163.     /*
  164.      * We are on the interrupt stack, get the stack
  165.      * pointer from the first pt_regs structure on
  166.      * the interrupt stack, so we can dump the task
  167.      * stack first.
  168.      */
  170.     int_regs = (struct pt_regs *)cr31;
  171.     sp = int_regs->gr[30];
  172.     stack_start = sp & ~(INIT_TASK_SIZE - 1);
  173.     if (stack_start != cr30) {
  174. printk(KERN_CRIT "WARNING! Interrupt-Stack pointer and cr30 do not correspond!n");
  175. printk(KERN_CRIT "Dumping virtual address stack insteadn");
  176. dump_stack((unsigned long)__va(stack_start), (unsigned long)__va(sp), 0);
  177.     } else {
  178. dump_stack(stack_start, sp, 0);
  179.     };
  181.     printk("nn" KERN_DEBUG "Registers at Interrupt:n");
  182.     show_regs(int_regs);
  184.     /* Now dump the interrupt stack */
  186.     sp = regs->gr[30];
  187.     stack_start = sp & ~(ISTACK_SIZE - 1);
  188.     dump_stack(stack_start,sp,1);
  189. }
  190. else
  191. {
  192.     /* Stack Dump! */
  193.     printk(KERN_CRIT "WARNING! Stack pointer and cr30 do not correspond!n");
  194.     printk(KERN_CRIT "Dumping virtual address stack insteadn");
  195.     dump_stack((unsigned long)__va(stack_start), (unsigned long)__va(sp), 0);
  196. }
  197. }
  198. #endif
  199. }
  202. void die_if_kernel(char *str, struct pt_regs *regs, long err)
  203. {
  204. if (user_mode(regs)) {
  205. #ifdef PRINT_USER_FAULTS
  206. if (err == 0)
  207. return; /* STFU */
  209. /* XXX for debugging only */
  210. printk(KERN_DEBUG "%s (pid %d): %s (code %ld)n",
  211. current->comm, current->pid, str, err);
  212. show_regs(regs);
  213. #endif
  214. return;
  215. }
  217. /* unlock the pdc lock if necessary */
  218. pdc_emergency_unlock();
  220. /* maybe the kernel hasn't booted very far yet and hasn't been able 
  221.  * to initialize the serial or STI console. In that case we should 
  222.  * re-enable the pdc console, so that the user will be able to 
  223.  * identify the problem. */
  224. if (!console_drivers)
  225. pdc_console_restart();
  227. printk(KERN_CRIT "%s (pid %d): %s (code %ld)n",
  228. current->comm, current->pid, str, err);
  229. show_regs(regs);
  231. /* Wot's wrong wif bein' racy? */
  232. if (current->thread.flags & PARISC_KERNEL_DEATH) {
  233. printk(KERN_CRIT "%s() recursion detected.n", __FUNCTION__);
  234. sti();
  235. while (1);
  236. }
  238. current->thread.flags |= PARISC_KERNEL_DEATH;
  239. do_exit(SIGSEGV);
  240. }
  242. int syscall_ipi(int (*syscall) (struct pt_regs *), struct pt_regs *regs)
  243. {
  244. return syscall(regs);
  245. }
  247. /* gdb uses break 4,8 */
  248. #define GDB_BREAK_INSN 0x10004
  249. void handle_gdb_break(struct pt_regs *regs, int wot)
  250. {
  251. struct siginfo si;
  253. si.si_code = wot;
  254. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  255. si.si_signo = SIGTRAP;
  256. si.si_errno = 0;
  257. force_sig_info(SIGTRAP, &si, current);
  258. }
  260. void handle_break(unsigned iir, struct pt_regs *regs)
  261. {
  262. struct siginfo si;
  263. #ifdef CONFIG_KWDB
  264. struct save_state ssp;
  265. #endif /* CONFIG_KWDB */   
  267. switch(iir) {
  268. case 0x00:
  269. #ifdef PRINT_USER_FAULTS
  270. printk(KERN_DEBUG "break 0,0: pid=%d command='%s'n",
  271.        current->pid, current->comm);
  272. #endif
  273. die_if_kernel("Breakpoint", regs, 0);
  274. #ifdef PRINT_USER_FAULTS
  275. show_regs(regs);
  276. #endif
  277. si.si_code = TRAP_BRKPT;
  278. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  279. si.si_signo = SIGTRAP;
  280. force_sig_info(SIGTRAP, &si, current);
  281. break;
  283. case GDB_BREAK_INSN:
  284. die_if_kernel("Breakpoint", regs, 0);
  285. handle_gdb_break(regs, TRAP_BRKPT);
  286. break;
  288. #ifdef CONFIG_KWDB
  289. case KGDB_BREAK_INSN:
  290. mtctl(0, 15);
  291. pt_regs_to_ssp(regs, &ssp);
  292. kgdb_trap(I_BRK_INST, &ssp, 1);
  293. ssp_to_pt_regs(&ssp, regs);
  294. break;
  296. case KGDB_INIT_BREAK_INSN:
  297. mtctl(0, 15);
  298. pt_regs_to_ssp(regs, &ssp);
  299. kgdb_trap(I_BRK_INST, &ssp, 1);
  300. ssp_to_pt_regs(&ssp, regs);
  302. /* Advance pcoq to skip break */
  303. regs->iaoq[0] = regs->iaoq[1];
  304. regs->iaoq[1] += 4;
  305. break;
  306. #endif /* CONFIG_KWDB */
  308. default:
  309. #ifdef PRINT_USER_FAULTS
  310. printk(KERN_DEBUG "break %#08x: pid=%d command='%s'n",
  311.        iir, current->pid, current->comm);
  312. show_regs(regs);
  313. #endif
  314. si.si_signo = SIGTRAP;
  315. si.si_code = TRAP_BRKPT;
  316. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  317. force_sig_info(SIGTRAP, &si, current);
  318. return;
  319. }
  320. }
  323. int handle_toc(void)
  324. {
  325. printk(KERN_CRIT "TOC call.n");
  326. return 0;
  327. }
  329. static void default_trap(int code, struct pt_regs *regs)
  330. {
  331. printk(KERN_ERR "Trap %d on CPU %dn", code, smp_processor_id());
  332. show_regs(regs);
  333. }
  335. void (*cpu_lpmc) (int code, struct pt_regs *regs) = default_trap;
  338. #ifdef CONFIG_KWDB
  339. int debug_call (void)
  340. {
  341.     printk (KERN_DEBUG "Debug call.n");
  342.     return 0;
  343. }
  345. int debug_call_leaf (void)
  346. {
  347.     return 0;
  348. }
  349. #endif /* CONFIG_KWDB */
  352. void transfer_pim_to_trap_frame(struct pt_regs *regs)
  353. {
  354.     register int i;
  355.     extern unsigned int hpmc_pim_data[];
  356.     struct pdc_hpmc_pim_11 *pim_narrow;
  357.     struct pdc_hpmc_pim_20 *pim_wide;
  359.     if (boot_cpu_data.cpu_type >= pcxu) {
  361. pim_wide = (struct pdc_hpmc_pim_20 *)hpmc_pim_data;
  363. /*
  364.  * Note: The following code will probably generate a
  365.  * bunch of truncation error warnings from the compiler.
  366.  * Could be handled with an ifdef, but perhaps there
  367.  * is a better way.
  368.  */
  370. regs->gr[0] = pim_wide->cr[22];
  372. for (i = 1; i < 32; i++)
  373.     regs->gr[i] = pim_wide->gr[i];
  375. for (i = 0; i < 32; i++)
  376.     regs->fr[i] = pim_wide->fr[i];
  378. for (i = 0; i < 8; i++)
  379.     regs->sr[i] = pim_wide->sr[i];
  381. regs->iasq[0] = pim_wide->cr[17];
  382. regs->iasq[1] = pim_wide->iasq_back;
  383. regs->iaoq[0] = pim_wide->cr[18];
  384. regs->iaoq[1] = pim_wide->iaoq_back;
  386. regs->sar  = pim_wide->cr[11];
  387. regs->iir  = pim_wide->cr[19];
  388. regs->isr  = pim_wide->cr[20];
  389. regs->ior  = pim_wide->cr[21];
  390.     }
  391.     else {
  392. pim_narrow = (struct pdc_hpmc_pim_11 *)hpmc_pim_data;
  394. regs->gr[0] = pim_narrow->cr[22];
  396. for (i = 1; i < 32; i++)
  397.     regs->gr[i] = pim_narrow->gr[i];
  399. for (i = 0; i < 32; i++)
  400.     regs->fr[i] = pim_narrow->fr[i];
  402. for (i = 0; i < 8; i++)
  403.     regs->sr[i] = pim_narrow->sr[i];
  405. regs->iasq[0] = pim_narrow->cr[17];
  406. regs->iasq[1] = pim_narrow->iasq_back;
  407. regs->iaoq[0] = pim_narrow->cr[18];
  408. regs->iaoq[1] = pim_narrow->iaoq_back;
  410. regs->sar  = pim_narrow->cr[11];
  411. regs->iir  = pim_narrow->cr[19];
  412. regs->isr  = pim_narrow->cr[20];
  413. regs->ior  = pim_narrow->cr[21];
  414.     }
  416.     /*
  417.      * The following fields only have meaning if we came through
  418.      * another path. So just zero them here.
  419.      */
  421.     regs->ksp = 0;
  422.     regs->kpc = 0;
  423.     regs->orig_r28 = 0;
  424. }
  427. /*
  428.  * This routine handles page faults.  It determines the address,
  429.  * and the problem, and then passes it off to one of the appropriate
  430.  * routines.
  431.  */
  432. void parisc_terminate(char *msg, struct pt_regs *regs, int code, unsigned long offset)
  433. {
  434. static spinlock_t terminate_lock = SPIN_LOCK_UNLOCKED;
  436. set_eiem(0);
  437. __cli();
  438. spin_lock(&terminate_lock);
  440. /* unlock the pdc lock if necessary */
  441. pdc_emergency_unlock();
  443. /* restart pdc console if necessary */
  444. if (!console_drivers)
  445. pdc_console_restart();
  447. if (code == 1)
  448.     transfer_pim_to_trap_frame(regs);
  450. show_stack(regs);
  452. printk("n");
  453. printk(KERN_CRIT "%s: Code=%d regs=%p (Addr=" RFMT ")n",
  454. msg, code, regs, offset);
  455. show_regs(regs);
  457. spin_unlock(&terminate_lock);
  459. /* put soft power button back under hardware control;
  460.  * if the user had pressed it once at any time, the 
  461.  * system will shut down immediately right here. */
  462. pdc_soft_power_button(0);
  464. for(;;)
  465.     ;
  466. }
  468. void handle_interruption(int code, struct pt_regs *regs)
  469. {
  470. unsigned long fault_address = 0;
  471. unsigned long fault_space = 0;
  472. struct siginfo si;
  473. #ifdef CONFIG_KWDB
  474. struct save_state ssp;
  475. #endif /* CONFIG_KWDB */   
  477. if (code == 1)
  478.     pdc_console_restart();  /* switch back to pdc if HPMC */
  479. else
  480.     sti();
  482. #if 0
  483. printk(KERN_CRIT "Interruption # %dn", code);
  484. #endif
  486. switch(code) {
  488. case  1:
  489. /* High-priority machine check (HPMC) */
  490. parisc_terminate("High Priority Machine Check (HPMC)",
  491. regs, code, 0);
  492. /* NOT REACHED */
  494. case  2:
  495. /* Power failure interrupt */
  496. printk(KERN_CRIT "Power failure interrupt !n");
  497. return;
  499. case  3:
  500. /* Recovery counter trap */
  501. regs->gr[0] &= ~PSW_R;
  502. if (regs->iasq[0])
  503. handle_gdb_break(regs, TRAP_TRACE);
  504. /* else this must be the start of a syscall - just let it run */
  505. return;
  507. case  5:
  508. /* Low-priority machine check */
  509. flush_all_caches();
  510. cpu_lpmc(5, regs);
  511. return;
  513. case  6:
  514. /* Instruction TLB miss fault/Instruction page fault */
  515. fault_address = regs->iaoq[0];
  516. fault_space   = regs->iasq[0];
  517. break;
  519. case  8:
  520. /* Illegal instruction trap */
  521. die_if_kernel("Illegal instruction", regs, code);
  522. si.si_code = ILL_ILLOPC;
  523. goto give_sigill;
  525. case  9:
  526. /* Break instruction trap */
  527. handle_break(regs->iir,regs);
  528. return;
  530. case 10:
  531. /* Privileged operation trap */
  532. die_if_kernel("Privileged operation", regs, code);
  533. si.si_code = ILL_PRVOPC;
  534. goto give_sigill;
  536. case 11:
  537. /* Privileged register trap */
  538. if ((regs->iir & 0xffdfffe0) == 0x034008a0) {
  540. /* This is a MFCTL cr26/cr27 to gr instruction.
  541.  * PCXS traps on this, so we need to emulate it.
  542.  */
  544. if (regs->iir & 0x00200000)
  545. regs->gr[regs->iir & 0x1f] = mfctl(27);
  546. else
  547. regs->gr[regs->iir & 0x1f] = mfctl(26);
  549. regs->iaoq[0] = regs->iaoq[1];
  550. regs->iaoq[1] += 4;
  551. regs->iasq[0] = regs->iasq[1];
  552. return;
  553. }
  555. die_if_kernel("Privileged register usage", regs, code);
  556. si.si_code = ILL_PRVREG;
  557. give_sigill:
  558. si.si_signo = SIGILL;
  559. si.si_errno = 0;
  560. si.si_addr = (void *) regs->iaoq[0];
  561. force_sig_info(SIGILL, &si, current);
  562. return;
  564. case 14:
  565. /* Assist Exception Trap, i.e. floating point exception. */
  566. die_if_kernel("Floating point exception", regs, 0); /* quiet */
  567. handle_fpe(regs);
  568. return;
  570. case 17:
  571. /* Non-access data TLB miss fault/Non-access data page fault */
  572. /* TODO: Still need to add slow path emulation code here */
  573. fault_address = regs->ior;
  574. parisc_terminate("Non access data tlb fault!",regs,code,fault_address);
  576. case 18:
  577. /* PCXS only -- later cpu's split this into types 26,27 & 28 */
  578. /* Check for unaligned access */
  579. if (check_unaligned(regs)) {
  580. handle_unaligned(regs);
  581. return;
  582. }
  583. /* Fall Through */
  585. case 15: /* Data TLB miss fault/Data page fault */
  586. case 26: /* PCXL: Data memory access rights trap */
  587. fault_address = regs->ior;
  588. fault_space   = regs->isr;
  589. break;
  591. case 19:
  592. /* Data memory break trap */
  593. regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
  594. /* fall thru */
  595. case 21:
  596. /* Page reference trap */
  597. handle_gdb_break(regs, TRAP_HWBKPT);
  598. return;
  600. case 25:
  601. /* Taken branch trap */
  602. #ifndef CONFIG_KWDB
  603. regs->gr[0] &= ~PSW_T;
  604. if (regs->iasq[0])
  605. handle_gdb_break(regs, TRAP_BRANCH);
  606. /* else this must be the start of a syscall - just let it
  607.  * run.
  608.  */
  609. return;
  610. #else
  611. /* Kernel debugger: */
  612. mtctl(0, 15);
  613. pt_regs_to_ssp(regs, &ssp);
  614. kgdb_trap(I_TAKEN_BR, &ssp, 1);
  615. ssp_to_pt_regs(&ssp, regs);
  616. break;
  617. #endif /* CONFIG_KWDB */
  619. case  7:  
  620. /* Instruction access rights */
  621. /* PCXL: Instruction memory protection trap */
  623. /*
  624.  * This could be caused by either: 1) a process attempting
  625.  * to execute within a vma that does not have execute
  626.  * permission, or 2) an access rights violation caused by a
  627.  * flush only translation set up by ptep_get_and_clear().
  628.  * So we check the vma permissions to differentiate the two.
  629.  * If the vma indicates we have execute permission, then
  630.  * the cause is the latter one. In this case, we need to
  631.  * call do_page_fault() to fix the problem.
  632.  */
  634. if (user_mode(regs)) {
  635. struct vm_area_struct *vma;
  637. down_read(&current->mm->mmap_sem);
  638. vma = find_vma(current->mm,regs->iaoq[0]);
  639. if (vma && (regs->iaoq[0] >= vma->vm_start)
  640. && (vma->vm_flags & VM_EXEC)) {
  642. fault_address = regs->iaoq[0];
  643. fault_space = regs->iasq[0];
  645. up_read(&current->mm->mmap_sem);
  646. break; /* call do_page_fault() */
  647. }
  648. up_read(&current->mm->mmap_sem);
  649. }
  650. /* Fall Through */
  652. case 27: 
  653. /* Data memory protection ID trap */
  654. die_if_kernel("Protection id trap", regs, code);
  655. si.si_code = SEGV_MAPERR;
  656. si.si_signo = SIGSEGV;
  657. si.si_errno = 0;
  658. if (code == 7)
  659.     si.si_addr = (void *) regs->iaoq[0];
  660. else
  661.     si.si_addr = (void *) regs->ior;
  662. force_sig_info(SIGSEGV, &si, current);
  663. return;
  665. case 28: 
  666. /* Unaligned data reference trap */
  667. handle_unaligned(regs);
  668. return;
  670. default:
  671. if (user_mode(regs)) {
  672. #ifdef PRINT_USER_FAULTS
  673. printk(KERN_DEBUG "nhandle_interruption() pid=%d command='%s'n",
  674.     current->pid, current->comm);
  675. show_regs(regs);
  676. #endif
  677. /* SIGBUS, for lack of a better one. */
  678. si.si_signo = SIGBUS;
  679. si.si_code = BUS_OBJERR;
  680. si.si_errno = 0;
  681. si.si_addr = (void *) regs->ior;
  682. force_sig_info(SIGBUS, &si, current);
  683. return;
  684. }
  685. parisc_terminate("Unexpected interruption", regs, code, 0);
  686. /* NOT REACHED */
  687. }
  689. if (user_mode(regs)) {
  690.     if (fault_space != regs->sr[7]) {
  691. #ifdef PRINT_USER_FAULTS
  692. if (fault_space == 0)
  693. printk(KERN_DEBUG "User Fault on Kernel Space ");
  694. else
  695. printk(KERN_DEBUG "User Fault (long pointer) ");
  696. printk("pid=%d command='%s'n", current->pid, current->comm);
  697. show_regs(regs);
  698. #endif
  699. si.si_signo = SIGSEGV;
  700. si.si_errno = 0;
  701. si.si_code = SEGV_MAPERR;
  702. si.si_addr = (void *) regs->ior;
  703. force_sig_info(SIGSEGV, &si, current);
  704. return;
  705.     }
  706. }
  707. else {
  709.     /*
  710.      * The kernel should never fault on its own address space.
  711.      */
  713.     if (fault_space == 0)
  714.     parisc_terminate("Kernel Fault", regs, code, fault_address);
  715. }
  717. #ifdef CONFIG_KWDB
  718. debug_call_leaf ();
  719. #endif /* CONFIG_KWDB */
  721. do_page_fault(regs, code, fault_address);
  722. }
  725. void show_trace_task(struct task_struct *tsk)
  726. {
  727.      BUG();
  728. }
  732. int __init check_ivt(void *iva)
  733. {
  734. int i;
  735. u32 check = 0;
  736. u32 *ivap;
  737. u32 *hpmcp;
  738. u32 length;
  739. extern void os_hpmc(void);
  740. extern void os_hpmc_end(void);
  742. if (strcmp((char *)iva, "cows can fly"))
  743. return -1;
  745. ivap = (u32 *)iva;
  747. for (i = 0; i < 8; i++)
  748.     *ivap++ = 0;
  750. /* Compute Checksum for HPMC handler */
  752. length = (u32)((unsigned long)os_hpmc_end - (unsigned long)os_hpmc);
  753. ivap[7] = length;
  755. hpmcp = (u32 *)os_hpmc;
  757. for (i=0; i<length/4; i++)
  758.     check += *hpmcp++;
  760. for (i=0; i<8; i++)
  761.     check += ivap[i];
  763. ivap[5] = -check;
  765. return 0;
  766. }
  768. #ifndef __LP64__
  769. extern const void fault_vector_11;
  770. #endif
  771. extern const void fault_vector_20;
  773. void __init trap_init(void)
  774. {
  775. void *iva;
  777. if (boot_cpu_data.cpu_type >= pcxu)
  778. iva = (void *) &fault_vector_20;
  779. else
  780. #ifdef __LP64__
  781. panic("Can't boot 64-bit OS on PA1.1 processor!");
  782. #else
  783. iva = (void *) &fault_vector_11;
  784. #endif
  786. if (check_ivt(iva))
  787. panic("IVT invalid");
  788. }