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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
traps.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：18k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

traps.c：源码内容
  1. /*
  2.  *  arch/s390/kernel/traps.c
  3.  *
  4.  *  S390 version
  5.  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6.  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  7.  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  8.  *
  9.  *  Derived from "arch/i386/kernel/traps.c"
  10.  *    Copyright (C) 1991, 1992 Linus Torvalds
  11.  */
  13. /*
  14.  * 'Traps.c' handles hardware traps and faults after we have saved some
  15.  * state in 'asm.s'.
  16.  */
  17. #include <linux/config.h>
  18. #include <linux/sched.h>
  19. #include <linux/kernel.h>
  20. #include <linux/string.h>
  21. #include <linux/errno.h>
  22. #include <linux/ptrace.h>
  23. #include <linux/timer.h>
  24. #include <linux/mm.h>
  25. #include <linux/smp.h>
  26. #include <linux/smp_lock.h>
  27. #include <linux/init.h>
  28. #include <linux/delay.h>
  29. #include <linux/module.h>
  31. #include <asm/system.h>
  32. #include <asm/uaccess.h>
  33. #include <asm/io.h>
  34. #include <asm/atomic.h>
  35. #include <asm/mathemu.h>
  36. #include <asm/cpcmd.h>
  37. #include <asm/s390_ext.h>
  39. /* Called from entry.S only */
  40. extern void handle_per_exception(struct pt_regs *regs);
  42. typedef void pgm_check_handler_t(struct pt_regs *, long);
  43. pgm_check_handler_t *pgm_check_table[128];
  45. #ifdef CONFIG_SYSCTL
  46. #ifdef CONFIG_PROCESS_DEBUG
  47. int sysctl_userprocess_debug = 1;
  48. #else
  49. int sysctl_userprocess_debug = 0;
  50. #endif
  51. #endif
  53. extern pgm_check_handler_t do_page_fault;
  54. extern pgm_check_handler_t do_pseudo_page_fault;
  55. #ifdef CONFIG_PFAULT
  56. extern int pfault_init(void);
  57. extern void pfault_fini(void);
  58. extern void pfault_interrupt(struct pt_regs *regs, __u16 error_code);
  59. #endif
  61. int kstack_depth_to_print = 12;
  63. /*
  64.  * If the address is either in the .text section of the
  65.  * kernel, or in the vmalloc'ed module regions, it *may* 
  66.  * be the address of a calling routine
  67.  */
  68. extern char _stext, _etext;
  70. #ifdef CONFIG_MODULES
  72. extern struct module *module_list;
  73. extern struct module kernel_module;
  75. static inline int kernel_text_address(unsigned long addr)
  76. {
  77. int retval = 0;
  78. struct module *mod;
  80. if (addr >= (unsigned long) &_stext &&
  81.     addr <= (unsigned long) &_etext)
  82. return 1;
  84. for (mod = module_list; mod != &kernel_module; mod = mod->next) {
  85. /* mod_bound tests for addr being inside the vmalloc'ed
  86.  * module area. Of course it'd be better to test only
  87.  * for the .text subset... */
  88. if (mod_bound(addr, 0, mod)) {
  89. retval = 1;
  90. break;
  91. }
  92. }
  94. return retval;
  95. }
  97. #else
  99. static inline int kernel_text_address(unsigned long addr)
  100. {
  101. return (addr >= (unsigned long) &_stext &&
  102. addr <= (unsigned long) &_etext);
  103. }
  105. #endif
  107. void show_trace(unsigned long * stack)
  108. {
  109. unsigned long backchain, low_addr, high_addr, ret_addr;
  110. int i;
  112. if (!stack)
  113. stack = (unsigned long*)&stack;
  115. printk("Call Trace: ");
  116. low_addr = ((unsigned long) stack) & PSW_ADDR_MASK;
  117. high_addr = (low_addr & (-THREAD_SIZE)) + THREAD_SIZE;
  118. /* Skip the first frame (biased stack) */
  119. backchain = *((unsigned long *) low_addr) & PSW_ADDR_MASK;
  120. /* Print up to 8 lines */
  121. for (i = 0; i < 8; i++) {
  122. if (backchain < low_addr || backchain >= high_addr)
  123. break;
  124. ret_addr = *((unsigned long *) (backchain+56)) & PSW_ADDR_MASK;
  125. if (!kernel_text_address(ret_addr))
  126. break;
  127. if (i && ((i % 6) == 0))
  128. printk("n   ");
  129. printk("[<%08lx>] ", ret_addr);
  130. low_addr = backchain;
  131. backchain = *((unsigned long *) backchain) & PSW_ADDR_MASK;
  132. }
  133. printk("n");
  134. }
  136. void show_trace_task(struct task_struct *tsk)
  137. {
  138. /*
  139.  * We can't print the backtrace of a running process. It is
  140.  * unreliable at best and can cause kernel oopses.
  141.  */
  142. if (task_has_cpu(tsk))
  143. return;
  144. show_trace((unsigned long *) tsk->thread.ksp);
  145. }
  147. void show_stack(unsigned long *sp)
  148. {
  149. unsigned long *stack;
  150. int i;
  152. // debugging aid: "show_stack(NULL);" prints the
  153. // back trace for this cpu.
  155. if(sp == NULL)
  156. sp = (unsigned long*) &sp;
  158. stack = sp;
  159. for (i = 0; i < kstack_depth_to_print; i++) {
  160. if (((addr_t) stack & (THREAD_SIZE-1)) == 0)
  161. break;
  162. if (i && ((i % 8) == 0))
  163. printk("n       ");
  164. printk("%08lx ", *stack++);
  165. }
  166. printk("n");
  167. show_trace(sp);
  168. }
  170. void show_registers(struct pt_regs *regs)
  171. {
  172. mm_segment_t old_fs;
  173. char *mode;
  174. int i;
  176. mode = (regs->psw.mask & PSW_PROBLEM_STATE) ? "User" : "Krnl";
  177. printk("%s PSW : %08lx %08lxn",
  178.        mode, (unsigned long) regs->psw.mask,
  179.        (unsigned long) regs->psw.addr);
  180. printk("%s GPRS: %08x %08x %08x %08xn", mode,
  181.        regs->gprs[0], regs->gprs[1], regs->gprs[2], regs->gprs[3]);
  182. printk("           %08x %08x %08x %08xn",
  183.        regs->gprs[4], regs->gprs[5], regs->gprs[6], regs->gprs[7]);
  184. printk("           %08x %08x %08x %08xn",
  185.        regs->gprs[8], regs->gprs[9], regs->gprs[10], regs->gprs[11]);
  186. printk("           %08x %08x %08x %08xn",
  187.        regs->gprs[12], regs->gprs[13], regs->gprs[14], regs->gprs[15]);
  188. printk("%s ACRS: %08x %08x %08x %08xn", mode,
  189.        regs->acrs[0], regs->acrs[1], regs->acrs[2], regs->acrs[3]);
  190. printk("           %08x %08x %08x %08xn",
  191.        regs->acrs[4], regs->acrs[5], regs->acrs[6], regs->acrs[7]);
  192. printk("           %08x %08x %08x %08xn",
  193.        regs->acrs[8], regs->acrs[9], regs->acrs[10], regs->acrs[11]);
  194. printk("           %08x %08x %08x %08xn",
  195.        regs->acrs[12], regs->acrs[13], regs->acrs[14], regs->acrs[15]);
  197. /*
  198.  * Print the first 20 byte of the instruction stream at the
  199.  * time of the fault.
  200.  */
  201. old_fs = get_fs();
  202. if (regs->psw.mask & PSW_PROBLEM_STATE)
  203. set_fs(USER_DS);
  204. else
  205. set_fs(KERNEL_DS);
  206. printk("%s Code: ", mode);
  207. for (i = 0; i < 20; i++) {
  208. unsigned char c;
  209. if (__get_user(c, (char *)(regs->psw.addr + i))) {
  210. printk(" Bad PSW.");
  211. break;
  212. }
  213. printk("%02x ", c);
  214. }
  215. set_fs(old_fs);
  217. printk("n");
  218. }
  220. /* This is called from fs/proc/array.c */
  221. char *task_show_regs(struct task_struct *task, char *buffer)
  222. {
  223. struct pt_regs *regs;
  225. regs = __KSTK_PTREGS(task);
  226. buffer += sprintf(buffer, "task: %08lx, ksp: %08xn",
  227.   (unsigned long) task, task->thread.ksp);
  228. buffer += sprintf(buffer, "User PSW : %08lx %08lxn",
  229.   (unsigned long) regs->psw.mask, 
  230.   (unsigned long) regs->psw.addr);
  231. buffer += sprintf(buffer, "User GPRS: %08x %08x %08x %08xn",
  232.   regs->gprs[0], regs->gprs[1],
  233.   regs->gprs[2], regs->gprs[3]);
  234. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  235.   regs->gprs[4], regs->gprs[5],
  236.   regs->gprs[6], regs->gprs[7]);
  237. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  238.   regs->gprs[8], regs->gprs[9],
  239.   regs->gprs[10], regs->gprs[11]);
  240. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  241.   regs->gprs[12], regs->gprs[13],
  242.   regs->gprs[14], regs->gprs[15]);
  243. buffer += sprintf(buffer, "User ACRS: %08x %08x %08x %08xn",
  244.   regs->acrs[0], regs->acrs[1],
  245.   regs->acrs[2], regs->acrs[3]);
  246. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  247.   regs->acrs[4], regs->acrs[5],
  248.   regs->acrs[6], regs->acrs[7]);
  249. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  250.   regs->acrs[8], regs->acrs[9],
  251.   regs->acrs[10], regs->acrs[11]);
  252. buffer += sprintf(buffer, "           %08x %08x %08x %08xn",
  253.   regs->acrs[12], regs->acrs[13],
  254.   regs->acrs[14], regs->acrs[15]);
  255. return buffer;
  256. }
  258. spinlock_t die_lock = SPIN_LOCK_UNLOCKED;
  260. void die(const char * str, struct pt_regs * regs, long err)
  261. {
  262.         console_verbose();
  263.         spin_lock_irq(&die_lock);
  264. bust_spinlocks(1);
  265.         printk("%s: %04lxn", str, err & 0xffff);
  266.         show_regs(regs);
  267. bust_spinlocks(0);
  268.         spin_unlock_irq(&die_lock);
  269.         do_exit(SIGSEGV);
  270. }
  272. #define DO_ERROR(signr, str, name) 
  273. asmlinkage void name(struct pt_regs * regs, long interruption_code) 
  274. { 
  275. do_trap(interruption_code, signr, str, regs, NULL); 
  276. }
  278. #define DO_ERROR_INFO(signr, str, name, sicode, siaddr) 
  279. asmlinkage void name(struct pt_regs * regs, long interruption_code) 
  280. { 
  281.         siginfo_t info; 
  282.         info.si_signo = signr; 
  283.         info.si_errno = 0; 
  284.         info.si_code = sicode; 
  285.         info.si_addr = (void *)siaddr; 
  286.         do_trap(interruption_code, signr, str, regs, &info); 
  287. }
  289. static void inline do_trap(long interruption_code, int signr, char *str,
  290.                            struct pt_regs *regs, siginfo_t *info)
  291. {
  292. /*
  293.  * We got all needed information from the lowcore and can
  294.  * now safely switch on interrupts.
  295.  */
  296.         if (regs->psw.mask & PSW_PROBLEM_STATE)
  297. __sti();
  299.         if (regs->psw.mask & PSW_PROBLEM_STATE) {
  300.                 struct task_struct *tsk = current;
  302.                 tsk->thread.trap_no = interruption_code;
  303. if (info)
  304. force_sig_info(signr, info, tsk);
  305. else
  306.                  force_sig(signr, tsk);
  307. #ifndef CONFIG_SYSCTL
  308. #ifdef CONFIG_PROCESS_DEBUG
  309.                 printk("User process fault: interruption code 0x%lXn",
  310.                        interruption_code);
  311.                 show_regs(regs);
  312. #endif
  313. #else
  314. if (sysctl_userprocess_debug) {
  315. printk("User process fault: interruption code 0x%lXn",
  316.        interruption_code);
  317. show_regs(regs);
  318. }
  319. #endif
  320.         } else {
  321.                 unsigned long fixup = search_exception_table(regs->psw.addr);
  322.                 if (fixup)
  323.                         regs->psw.addr = fixup;
  324.                 else
  325.                         die(str, regs, interruption_code);
  326.         }
  327. }
  329. int do_debugger_trap(struct pt_regs *regs,int signal)
  330. {
  331. if(regs->psw.mask&PSW_PROBLEM_STATE)
  332. {
  333. if(current->ptrace & PT_PTRACED)
  334. force_sig(signal,current);
  335. else
  336. return 1;
  337. }
  338. else
  339. {
  340. #if CONFIG_REMOTE_DEBUG
  341. if(gdb_stub_initialised)
  342. {
  343. gdb_stub_handle_exception(regs, signal);
  344. return 0;
  345. }
  346. #endif
  347. return 1;
  348. }
  349. return 0;
  350. }
  352. DO_ERROR(SIGSEGV, "Unknown program exception", default_trap_handler)
  353. DO_ERROR(SIGILL,  "privileged operation", privileged_op)
  354. DO_ERROR(SIGILL,  "execute exception", execute_exception)
  355. DO_ERROR(SIGSEGV, "addressing exception", addressing_exception)
  356. DO_ERROR(SIGFPE,  "fixpoint divide exception", divide_exception)
  357. DO_ERROR(SIGILL,  "translation exception", translation_exception)
  358. DO_ERROR(SIGILL,  "special operand exception", special_op_exception)
  359. DO_ERROR(SIGILL,  "operand exception", operand_exception)
  361. asmlinkage void illegal_op(struct pt_regs * regs, long interruption_code)
  362. {
  363.         __u8 opcode[6];
  364. __u16 *location;
  365. int signal = 0;
  367. location = (__u16 *)(regs->psw.addr-S390_lowcore.pgm_ilc);
  369. /*
  370.  * We got all needed information from the lowcore and can
  371.  * now safely switch on interrupts.
  372.  */
  373. if (regs->psw.mask & PSW_PROBLEM_STATE)
  374. __sti();
  376. if (regs->psw.mask & PSW_PROBLEM_STATE)
  377. get_user(*((__u16 *) opcode), location);
  378. else
  379. *((__u16 *)opcode)=*((__u16 *)location);
  380. if (*((__u16 *)opcode)==S390_BREAKPOINT_U16)
  381.         {
  382. if(do_debugger_trap(regs,SIGTRAP))
  383. signal = SIGILL;
  384. }
  385. #ifdef CONFIG_MATHEMU
  386.         else if (regs->psw.mask & PSW_PROBLEM_STATE)
  387. {
  388. if (opcode[0] == 0xb3) {
  389. get_user(*((__u16 *) (opcode+2)), location+1);
  390. signal = math_emu_b3(opcode, regs);
  391.                 } else if (opcode[0] == 0xed) {
  392. get_user(*((__u32 *) (opcode+2)),
  393.  (__u32 *)(location+1));
  394. signal = math_emu_ed(opcode, regs);
  395. } else if (*((__u16 *) opcode) == 0xb299) {
  396. get_user(*((__u16 *) (opcode+2)), location+1);
  397. signal = math_emu_srnm(opcode, regs);
  398. } else if (*((__u16 *) opcode) == 0xb29c) {
  399. get_user(*((__u16 *) (opcode+2)), location+1);
  400. signal = math_emu_stfpc(opcode, regs);
  401. } else if (*((__u16 *) opcode) == 0xb29d) {
  402. get_user(*((__u16 *) (opcode+2)), location+1);
  403. signal = math_emu_lfpc(opcode, regs);
  404. } else
  405. signal = SIGILL;
  406.         }
  407. #endif 
  408. else
  409. signal = SIGILL;
  410.         if (signal == SIGFPE) {
  411. current->thread.ieee_instruction_pointer = (addr_t) location;
  412. do_trap(interruption_code, signal,
  413. "floating point exception", regs, NULL);
  414.         } else if (signal)
  415. do_trap(interruption_code, signal,
  416. "illegal operation", regs, NULL);
  417. }
  421. #ifdef CONFIG_MATHEMU
  422. asmlinkage void 
  423. specification_exception(struct pt_regs * regs, long interruption_code)
  424. {
  425.         __u8 opcode[6];
  426. __u16 *location = NULL;
  427. int signal = 0;
  429. location = (__u16 *)(regs->psw.addr-S390_lowcore.pgm_ilc);
  431. /*
  432.  * We got all needed information from the lowcore and can
  433.  * now safely switch on interrupts.
  434.  */
  435. if (regs->psw.mask & PSW_PROBLEM_STATE)
  436. __sti();
  438.         if (regs->psw.mask & PSW_PROBLEM_STATE) {
  439. get_user(*((__u16 *) opcode), location);
  440. switch (opcode[0]) {
  441. case 0x28: /* LDR Rx,Ry   */
  442. signal = math_emu_ldr(opcode);
  443. break;
  444. case 0x38: /* LER Rx,Ry   */
  445. signal = math_emu_ler(opcode);
  446. break;
  447. case 0x60: /* STD R,D(X,B) */
  448. get_user(*((__u16 *) (opcode+2)), location+1);
  449. signal = math_emu_std(opcode, regs);
  450. break;
  451. case 0x68: /* LD R,D(X,B) */
  452. get_user(*((__u16 *) (opcode+2)), location+1);
  453. signal = math_emu_ld(opcode, regs);
  454. break;
  455. case 0x70: /* STE R,D(X,B) */
  456. get_user(*((__u16 *) (opcode+2)), location+1);
  457. signal = math_emu_ste(opcode, regs);
  458. break;
  459. case 0x78: /* LE R,D(X,B) */
  460. get_user(*((__u16 *) (opcode+2)), location+1);
  461. signal = math_emu_le(opcode, regs);
  462. break;
  463. default:
  464. signal = SIGILL;
  465. break;
  466.                 }
  467.         } else
  468. signal = SIGILL;
  469.         if (signal == SIGFPE) {
  470. current->thread.ieee_instruction_pointer = (addr_t) location;
  471. do_trap(interruption_code, signal,
  472. "floating point exception", regs, NULL);
  473.         } else if (signal)
  474.                 do_trap(interruption_code, signal,
  475. "specification exception", regs, NULL);
  476. }
  477. #else
  478. DO_ERROR(SIGILL, "specification exception", specification_exception)
  479. #endif
  481. asmlinkage void data_exception(struct pt_regs * regs, long interruption_code)
  482. {
  483.         __u8 opcode[6];
  484. __u16 *location;
  485. int signal = 0;
  487. location = (__u16 *)(regs->psw.addr-S390_lowcore.pgm_ilc);
  489. /*
  490.  * We got all needed information from the lowcore and can
  491.  * now safely switch on interrupts.
  492.  */
  493. if (regs->psw.mask & PSW_PROBLEM_STATE)
  494. __sti();
  496. if (MACHINE_HAS_IEEE)
  497. __asm__ volatile ("stfpc %0nt" 
  498.   : "=m" (current->thread.fp_regs.fpc));
  500. #ifdef CONFIG_MATHEMU
  501.         else if (regs->psw.mask & PSW_PROBLEM_STATE) {
  502. get_user(*((__u16 *) opcode), location);
  503. switch (opcode[0]) {
  504. case 0x28: /* LDR Rx,Ry   */
  505. signal = math_emu_ldr(opcode);
  506. break;
  507. case 0x38: /* LER Rx,Ry   */
  508. signal = math_emu_ler(opcode);
  509. break;
  510. case 0x60: /* STD R,D(X,B) */
  511. get_user(*((__u16 *) (opcode+2)), location+1);
  512. signal = math_emu_std(opcode, regs);
  513. break;
  514. case 0x68: /* LD R,D(X,B) */
  515. get_user(*((__u16 *) (opcode+2)), location+1);
  516. signal = math_emu_ld(opcode, regs);
  517. break;
  518. case 0x70: /* STE R,D(X,B) */
  519. get_user(*((__u16 *) (opcode+2)), location+1);
  520. signal = math_emu_ste(opcode, regs);
  521. break;
  522. case 0x78: /* LE R,D(X,B) */
  523. get_user(*((__u16 *) (opcode+2)), location+1);
  524. signal = math_emu_le(opcode, regs);
  525. break;
  526. case 0xb3:
  527. get_user(*((__u16 *) (opcode+2)), location+1);
  528. signal = math_emu_b3(opcode, regs);
  529. break;
  530.                 case 0xed:
  531. get_user(*((__u32 *) (opcode+2)),
  532.  (__u32 *)(location+1));
  533. signal = math_emu_ed(opcode, regs);
  534. break;
  535.         case 0xb2:
  536. if (opcode[1] == 0x99) {
  537. get_user(*((__u16 *) (opcode+2)), location+1);
  538. signal = math_emu_srnm(opcode, regs);
  539. } else if (opcode[1] == 0x9c) {
  540. get_user(*((__u16 *) (opcode+2)), location+1);
  541. signal = math_emu_stfpc(opcode, regs);
  542. } else if (opcode[1] == 0x9d) {
  543. get_user(*((__u16 *) (opcode+2)), location+1);
  544. signal = math_emu_lfpc(opcode, regs);
  545. } else
  546. signal = SIGILL;
  547. break;
  548. default:
  549. signal = SIGILL;
  550. break;
  551.                 }
  552.         }
  553. #endif 
  554. if (current->thread.fp_regs.fpc & FPC_DXC_MASK)
  555. signal = SIGFPE;
  556. else
  557. signal = SIGILL;
  558.         if (signal == SIGFPE) {
  559. current->thread.ieee_instruction_pointer = (addr_t) location;
  560. do_trap(interruption_code, signal,
  561. "floating point exception", regs, NULL);
  562. } else if (signal) 
  563.                 do_trap(interruption_code, signal,
  564. "data exception", regs, NULL);
  565. }
  569. /* init is done in lowcore.S and head.S */
  571. void __init trap_init(void)
  572. {
  573.         int i;
  575.         for (i = 0; i < 128; i++)
  576.           pgm_check_table[i] = &default_trap_handler;
  577.         pgm_check_table[1] = &illegal_op;
  578.         pgm_check_table[2] = &privileged_op;
  579.         pgm_check_table[3] = &execute_exception;
  580.         pgm_check_table[4] = &do_page_fault;
  581.         pgm_check_table[5] = &addressing_exception;
  582.         pgm_check_table[6] = &specification_exception;
  583.         pgm_check_table[7] = &data_exception;
  584.         pgm_check_table[9] = &divide_exception;
  585.         pgm_check_table[0x10] = &do_page_fault;
  586.         pgm_check_table[0x11] = &do_page_fault;
  587.         pgm_check_table[0x12] = &translation_exception;
  588.         pgm_check_table[0x13] = &special_op_exception;
  589.   pgm_check_table[0x14] = &do_pseudo_page_fault;
  590.         pgm_check_table[0x15] = &operand_exception;
  591.         pgm_check_table[0x1C] = &privileged_op;
  592. #ifdef CONFIG_PFAULT
  593. if (MACHINE_IS_VM) {
  594. /* request the 0x2603 external interrupt */
  595. if (register_external_interrupt(0x2603, pfault_interrupt) != 0)
  596. panic("Couldn't request external interrupt 0x2603");
  597. /*
  598.  * First try to get pfault pseudo page faults going.
  599.  * If this isn't available turn on pagex page faults.
  600.  */
  601. if (pfault_init() != 0) {
  602. /* Tough luck, no pfault. */
  603. unregister_external_interrupt(0x2603,
  604.       pfault_interrupt);
  605. cpcmd("SET PAGEX ON", NULL, 0);
  606. }
  607. }
  608. #else
  609. if (MACHINE_IS_VM)
  610. cpcmd("SET PAGEX ON", NULL, 0);
  611. #endif
  612. }
  615. void handle_per_exception(struct pt_regs *regs)
  616. {
  617. if(regs->psw.mask&PSW_PROBLEM_STATE)
  618. {
  619. per_struct *per_info=&current->thread.per_info;
  620. per_info->lowcore.words.perc_atmid=S390_lowcore.per_perc_atmid;
  621. per_info->lowcore.words.address=S390_lowcore.per_address;
  622. per_info->lowcore.words.access_id=S390_lowcore.per_access_id;
  623. }
  624. if(do_debugger_trap(regs,SIGTRAP))
  625. {
  626. /* I've seen this possibly a task structure being reused ? */
  627. printk("Spurious per exception detectedn");
  628. printk("switching off per tracing for this task.n");
  629. show_regs(regs);
  630. /* Hopefully switching off per tracing will help us survive */
  631. regs->psw.mask &= ~PSW_PER_MASK;
  632. }
  633. }