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

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

Linux/Unix编程

开发平台：

Unix_Linux

traps.c：源码内容
  1. /*
  2.  * arch/alpha/kernel/traps.c
  3.  *
  4.  * (C) Copyright 1994 Linus Torvalds
  5.  */
  7. /*
  8.  * This file initializes the trap entry points
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/mm.h>
  13. #include <linux/sched.h>
  14. #include <linux/tty.h>
  15. #include <linux/delay.h>
  16. #include <linux/smp_lock.h>
  18. #include <asm/gentrap.h>
  19. #include <asm/uaccess.h>
  20. #include <asm/unaligned.h>
  21. #include <asm/sysinfo.h>
  22. #include <asm/hwrpb.h>
  23. #include <asm/mmu_context.h>
  25. #include "proto.h"
  27. /* data/code implementing a work-around for some SRMs which
  28.    mishandle opDEC faults
  29. */
  30. static int opDEC_testing = 0;
  31. static int opDEC_fix = 0;
  32. static unsigned long opDEC_test_pc = 0;
  34. static void
  35. opDEC_check(void)
  36. {
  37. unsigned long test_pc;
  39. lock_kernel();
  40. opDEC_testing = 1;
  42. __asm__ __volatile__(
  43. "       br      %0,1fn"
  44. "1:     addq    %0,8,%0n"
  45. "       stq     %0,%1n"
  46. "       cvttq/svm $f31,$f31n"
  47. : "=&r"(test_pc), "=m"(opDEC_test_pc)
  48. : );
  50. opDEC_testing = 0;
  51. unlock_kernel();
  52. }
  54. void
  55. dik_show_regs(struct pt_regs *regs, unsigned long *r9_15)
  56. {
  57. printk("pc = [<%016lx>]  ra = [<%016lx>]  ps = %04lx    %sn",
  58.        regs->pc, regs->r26, regs->ps, print_tainted());
  59. printk("v0 = %016lx  t0 = %016lx  t1 = %016lxn",
  60.        regs->r0, regs->r1, regs->r2);
  61. printk("t2 = %016lx  t3 = %016lx  t4 = %016lxn",
  62.          regs->r3, regs->r4, regs->r5);
  63. printk("t5 = %016lx  t6 = %016lx  t7 = %016lxn",
  64.        regs->r6, regs->r7, regs->r8);
  66. if (r9_15) {
  67. printk("s0 = %016lx  s1 = %016lx  s2 = %016lxn",
  68.        r9_15[9], r9_15[10], r9_15[11]);
  69. printk("s3 = %016lx  s4 = %016lx  s5 = %016lxn",
  70.        r9_15[12], r9_15[13], r9_15[14]);
  71. printk("s6 = %016lxn", r9_15[15]);
  72. }
  74. printk("a0 = %016lx  a1 = %016lx  a2 = %016lxn",
  75.        regs->r16, regs->r17, regs->r18);
  76. printk("a3 = %016lx  a4 = %016lx  a5 = %016lxn",
  77.          regs->r19, regs->r20, regs->r21);
  78.   printk("t8 = %016lx  t9 = %016lx  t10= %016lxn",
  79.        regs->r22, regs->r23, regs->r24);
  80. printk("t11= %016lx  pv = %016lx  at = %016lxn",
  81.        regs->r25, regs->r27, regs->r28);
  82. printk("gp = %016lx  sp = %pn", regs->gp, regs+1);
  83. #if 0
  84. __halt();
  85. #endif
  86. }
  88. #if 0
  89. static char * ireg_name[] = {"v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
  90.    "t7", "s0", "s1", "s2", "s3", "s4", "s5", "s6",
  91.    "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
  92.    "t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};
  93. #endif
  95. static void
  96. dik_show_code(unsigned int *pc)
  97. {
  98. long i;
  100. printk("Code:");
  101. for (i = -6; i < 2; i++) {
  102. unsigned int insn;
  103. if (__get_user(insn, pc+i))
  104. break;
  105. printk("%c%08x%c", i ? ' ' : '<', insn, i ? ' ' : '>');
  106. }
  107. printk("n");
  108. }
  110. static void
  111. dik_show_trace(unsigned long *sp)
  112. {
  113. long i = 0;
  114. printk("Trace:");
  115. while (0x1ff8 & (unsigned long) sp) {
  116. extern unsigned long _stext, _etext;
  117. unsigned long tmp = *sp;
  118. sp++;
  119. if (tmp < (unsigned long) &_stext)
  120. continue;
  121. if (tmp >= (unsigned long) &_etext)
  122. continue;
  123. printk("%lx%c", tmp, ' ');
  124. if (i > 40) {
  125. printk(" ...");
  126. break;
  127. }
  128. }
  129. printk("n");
  130. }
  132. void show_trace_task(struct task_struct * tsk)
  133. {
  134. struct thread_struct * thread = &tsk->thread;
  135. unsigned long fp, sp = thread->ksp, base = (unsigned long) thread;
  136.  
  137. if (sp > base && sp+6*8 < base + 16*1024) {
  138. fp = ((unsigned long*)sp)[6];
  139. if (fp > sp && fp < base + 16*1024)
  140. dik_show_trace((unsigned long *)fp);
  141. }
  142. }
  144. int kstack_depth_to_print = 24;
  146. void show_stack(unsigned long *sp)
  147. {
  148. unsigned long *stack;
  149. int i;
  151. /*
  152.  * debugging aid: "show_stack(NULL);" prints the
  153.  * back trace for this cpu.
  154.  */
  155. if(sp==NULL)
  156. sp=(unsigned long*)&sp;
  158. stack = sp;
  159. for(i=0; i < kstack_depth_to_print; i++) {
  160. if (((long) stack & (THREAD_SIZE-1)) == 0)
  161. break;
  162. if (i && ((i % 4) == 0))
  163. printk("n       ");
  164. printk("%016lx ", *stack++);
  165. }
  166. printk("n");
  167. dik_show_trace(sp);
  168. }
  170. void dump_stack(void)
  171. {
  172. show_stack(NULL);
  173. }
  175. void
  176. die_if_kernel(char * str, struct pt_regs *regs, long err, unsigned long *r9_15)
  177. {
  178. if (regs->ps & 8)
  179. return;
  180. #ifdef CONFIG_SMP
  181. printk("CPU %d ", hard_smp_processor_id());
  182. #endif
  183. printk("%s(%d): %s %ldn", current->comm, current->pid, str, err);
  184. dik_show_regs(regs, r9_15);
  185. dik_show_trace((unsigned long *)(regs+1));
  186. dik_show_code((unsigned int *)regs->pc);
  188. if (current->thread.flags & (1UL << 63)) {
  189. printk("die_if_kernel recursion detected.n");
  190. sti();
  191. while (1);
  192. }
  193. current->thread.flags |= (1UL << 63);
  194. do_exit(SIGSEGV);
  195. }
  197. #ifndef CONFIG_MATHEMU
  198. static long dummy_emul(void) { return 0; }
  199. long (*alpha_fp_emul_imprecise)(struct pt_regs *regs, unsigned long writemask)
  200.   = (void *)dummy_emul;
  201. long (*alpha_fp_emul) (unsigned long pc)
  202.   = (void *)dummy_emul;
  203. #else
  204. long alpha_fp_emul_imprecise(struct pt_regs *regs, unsigned long writemask);
  205. long alpha_fp_emul (unsigned long pc);
  206. #endif
  208. asmlinkage void
  209. do_entArith(unsigned long summary, unsigned long write_mask,
  210.     unsigned long a2, unsigned long a3, unsigned long a4,
  211.     unsigned long a5, struct pt_regs regs)
  212. {
  213. if (summary & 1) {
  214. /* Software-completion summary bit is set, so try to
  215.    emulate the instruction.  */
  216. if (!amask(AMASK_PRECISE_TRAP)) {
  217. /* 21264 (except pass 1) has precise exceptions.  */
  218. if (alpha_fp_emul(regs.pc - 4))
  219. return;
  220. } else {
  221. if (alpha_fp_emul_imprecise(&regs, write_mask))
  222. return;
  223. }
  224. }
  226. #if 0
  227. printk("%s: arithmetic trap at %016lx: %02lx %016lxn",
  228. current->comm, regs.pc, summary, write_mask);
  229. #endif
  230. die_if_kernel("Arithmetic fault", &regs, 0, 0);
  231. send_sig(SIGFPE, current, 1);
  232. }
  234. asmlinkage void
  235. do_entIF(unsigned long type, unsigned long a1,
  236.  unsigned long a2, unsigned long a3, unsigned long a4,
  237.  unsigned long a5, struct pt_regs regs)
  238. {
  239. if (!opDEC_testing || type != 4) {
  240. die_if_kernel((type == 1 ? "Kernel Bug" : "Instruction fault"),
  241.       &regs, type, 0);
  242. }
  244. switch (type) {
  245.       case 0: /* breakpoint */
  246. if (ptrace_cancel_bpt(current)) {
  247. regs.pc -= 4; /* make pc point to former bpt */
  248. }
  249. send_sig(SIGTRAP, current, 1);
  250. return;
  252.       case 1: /* bugcheck */
  253. send_sig(SIGTRAP, current, 1);
  254. return;
  256.       case 2: /* gentrap */
  257. /*
  258.  * The exception code should be passed on to the signal
  259.  * handler as the second argument.  Linux doesn't do that
  260.  * yet (also notice that Linux *always* behaves like
  261.  * DEC Unix with SA_SIGINFO off; see DEC Unix man page
  262.  * for sigaction(2)).
  263.  */
  264. switch ((long) regs.r16) {
  265.       case GEN_INTOVF: case GEN_INTDIV: case GEN_FLTOVF:
  266.       case GEN_FLTDIV: case GEN_FLTUND: case GEN_FLTINV:
  267.       case GEN_FLTINE: case GEN_ROPRAND:
  268. send_sig(SIGFPE, current, 1);
  269. return;
  271.       case GEN_DECOVF:
  272.       case GEN_DECDIV:
  273.       case GEN_DECINV:
  274.       case GEN_ASSERTERR:
  275.       case GEN_NULPTRERR:
  276.       case GEN_STKOVF:
  277.       case GEN_STRLENERR:
  278.       case GEN_SUBSTRERR:
  279.       case GEN_RANGERR:
  280.       case GEN_SUBRNG:
  281.       case GEN_SUBRNG1:
  282.       case GEN_SUBRNG2:
  283.       case GEN_SUBRNG3:
  284.       case GEN_SUBRNG4:
  285.       case GEN_SUBRNG5:
  286.       case GEN_SUBRNG6:
  287.       case GEN_SUBRNG7:
  288. send_sig(SIGTRAP, current, 1);
  289. return;
  290. }
  291. break;
  293.       case 4: /* opDEC */
  294. if (implver() == IMPLVER_EV4) {
  295. /* The some versions of SRM do not handle
  296.    the opDEC properly - they return the PC of the
  297.    opDEC fault, not the instruction after as the
  298.    Alpha architecture requires.  Here we fix it up.
  299.    We do this by intentionally causing an opDEC
  300.    fault during the boot sequence and testing if
  301.    we get the correct PC.  If not, we set a flag
  302.    to correct it every time through.
  303. */
  304. if (opDEC_testing) {
  305. if (regs.pc == opDEC_test_pc) {
  306. opDEC_fix = 4;
  307. regs.pc += 4;
  308. printk("opDEC fixup enabled.n");
  309. }
  310. return;
  311. }
  312. regs.pc += opDEC_fix; 
  314. /* EV4 does not implement anything except normal
  315.    rounding.  Everything else will come here as
  316.    an illegal instruction.  Emulate them.  */
  317. if (alpha_fp_emul(regs.pc-4))
  318. return;
  319. }
  320. break;
  322.       case 3: /* FEN fault */
  323. /* Irritating users can call PAL_clrfen to disable the
  324.    FPU for the process.  The kernel will then trap in
  325.    do_switch_stack and undo_switch_stack when we try
  326.    to save and restore the FP registers.
  328.    Given that GCC by default generates code that uses the
  329.    FP registers, PAL_clrfen is not useful except for DoS
  330.    attacks.  So turn the bleeding FPU back on and be done
  331.    with it.  */
  332. current->thread.pal_flags |= 1;
  333. __reload_thread(&current->thread);
  334. return;
  336.       case 5: /* illoc */
  337.       default: /* unexpected instruction-fault type */
  338.       ;
  339. }
  340. send_sig(SIGILL, current, 1);
  341. }
  343. /* There is an ifdef in the PALcode in MILO that enables a 
  344.    "kernel debugging entry point" as an unpriviledged call_pal.
  346.    We don't want to have anything to do with it, but unfortunately
  347.    several versions of MILO included in distributions have it enabled,
  348.    and if we don't put something on the entry point we'll oops.  */
  350. asmlinkage void
  351. do_entDbg(unsigned long type, unsigned long a1,
  352.   unsigned long a2, unsigned long a3, unsigned long a4,
  353.   unsigned long a5, struct pt_regs regs)
  354. {
  355. die_if_kernel("Instruction fault", &regs, type, 0);
  356. force_sig(SIGILL, current);
  357. }
  360. /*
  361.  * entUna has a different register layout to be reasonably simple. It
  362.  * needs access to all the integer registers (the kernel doesn't use
  363.  * fp-regs), and it needs to have them in order for simpler access.
  364.  *
  365.  * Due to the non-standard register layout (and because we don't want
  366.  * to handle floating-point regs), user-mode unaligned accesses are
  367.  * handled separately by do_entUnaUser below.
  368.  *
  369.  * Oh, btw, we don't handle the "gp" register correctly, but if we fault
  370.  * on a gp-register unaligned load/store, something is _very_ wrong
  371.  * in the kernel anyway..
  372.  */
  373. struct allregs {
  374. unsigned long regs[32];
  375. unsigned long ps, pc, gp, a0, a1, a2;
  376. };
  378. struct unaligned_stat {
  379. unsigned long count, va, pc;
  380. } unaligned[2];
  383. /* Macro for exception fixup code to access integer registers.  */
  384. #define una_reg(r)  (regs.regs[(r) >= 16 && (r) <= 18 ? (r)+19 : (r)])
  387. asmlinkage void
  388. do_entUna(void * va, unsigned long opcode, unsigned long reg,
  389.   unsigned long a3, unsigned long a4, unsigned long a5,
  390.   struct allregs regs)
  391. {
  392. long error, tmp1, tmp2, tmp3, tmp4;
  393. unsigned long pc = regs.pc - 4;
  394. unsigned fixup;
  396. unaligned[0].count++;
  397. unaligned[0].va = (unsigned long) va;
  398. unaligned[0].pc = pc;
  400. /* We don't want to use the generic get/put unaligned macros as
  401.    we want to trap exceptions.  Only if we actually get an
  402.    exception will we decide whether we should have caught it.  */
  404. switch (opcode) {
  405. case 0x0c: /* ldwu */
  406. __asm__ __volatile__(
  407. "1: ldq_u %1,0(%3)n"
  408. "2: ldq_u %2,1(%3)n"
  409. " extwl %1,%3,%1n"
  410. " extwh %2,%3,%2n"
  411. "3:n"
  412. ".section __ex_table,"a"n"
  413. " .gprel32 1bn"
  414. " lda %1,3b-1b(%0)n"
  415. " .gprel32 2bn"
  416. " lda %2,3b-2b(%0)n"
  417. ".previous"
  418. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  419. : "r"(va), "0"(0));
  420. if (error)
  421. goto got_exception;
  422. una_reg(reg) = tmp1|tmp2;
  423. return;
  425. case 0x28: /* ldl */
  426. __asm__ __volatile__(
  427. "1: ldq_u %1,0(%3)n"
  428. "2: ldq_u %2,3(%3)n"
  429. " extll %1,%3,%1n"
  430. " extlh %2,%3,%2n"
  431. "3:n"
  432. ".section __ex_table,"a"n"
  433. " .gprel32 1bn"
  434. " lda %1,3b-1b(%0)n"
  435. " .gprel32 2bn"
  436. " lda %2,3b-2b(%0)n"
  437. ".previous"
  438. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  439. : "r"(va), "0"(0));
  440. if (error)
  441. goto got_exception;
  442. una_reg(reg) = (int)(tmp1|tmp2);
  443. return;
  445. case 0x29: /* ldq */
  446. __asm__ __volatile__(
  447. "1: ldq_u %1,0(%3)n"
  448. "2: ldq_u %2,7(%3)n"
  449. " extql %1,%3,%1n"
  450. " extqh %2,%3,%2n"
  451. "3:n"
  452. ".section __ex_table,"a"n"
  453. " .gprel32 1bn"
  454. " lda %1,3b-1b(%0)n"
  455. " .gprel32 2bn"
  456. " lda %2,3b-2b(%0)n"
  457. ".previous"
  458. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  459. : "r"(va), "0"(0));
  460. if (error)
  461. goto got_exception;
  462. una_reg(reg) = tmp1|tmp2;
  463. return;
  465. /* Note that the store sequences do not indicate that they change
  466.    memory because it _should_ be affecting nothing in this context.
  467.    (Otherwise we have other, much larger, problems.)  */
  468. case 0x0d: /* stw */
  469. __asm__ __volatile__(
  470. "1: ldq_u %2,1(%5)n"
  471. "2: ldq_u %1,0(%5)n"
  472. " inswh %6,%5,%4n"
  473. " inswl %6,%5,%3n"
  474. " mskwh %2,%5,%2n"
  475. " mskwl %1,%5,%1n"
  476. " or %2,%4,%2n"
  477. " or %1,%3,%1n"
  478. "3: stq_u %2,1(%5)n"
  479. "4: stq_u %1,0(%5)n"
  480. "5:n"
  481. ".section __ex_table,"a"n"
  482. " .gprel32 1bn"
  483. " lda %2,5b-1b(%0)n"
  484. " .gprel32 2bn"
  485. " lda %1,5b-2b(%0)n"
  486. " .gprel32 3bn"
  487. " lda $31,5b-3b(%0)n"
  488. " .gprel32 4bn"
  489. " lda $31,5b-4b(%0)n"
  490. ".previous"
  491. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  492.   "=&r"(tmp3), "=&r"(tmp4)
  493. : "r"(va), "r"(una_reg(reg)), "0"(0));
  494. if (error)
  495. goto got_exception;
  496. return;
  498. case 0x2c: /* stl */
  499. __asm__ __volatile__(
  500. "1: ldq_u %2,3(%5)n"
  501. "2: ldq_u %1,0(%5)n"
  502. " inslh %6,%5,%4n"
  503. " insll %6,%5,%3n"
  504. " msklh %2,%5,%2n"
  505. " mskll %1,%5,%1n"
  506. " or %2,%4,%2n"
  507. " or %1,%3,%1n"
  508. "3: stq_u %2,3(%5)n"
  509. "4: stq_u %1,0(%5)n"
  510. "5:n"
  511. ".section __ex_table,"a"n"
  512. " .gprel32 1bn"
  513. " lda %2,5b-1b(%0)n"
  514. " .gprel32 2bn"
  515. " lda %1,5b-2b(%0)n"
  516. " .gprel32 3bn"
  517. " lda $31,5b-3b(%0)n"
  518. " .gprel32 4bn"
  519. " lda $31,5b-4b(%0)n"
  520. ".previous"
  521. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  522.   "=&r"(tmp3), "=&r"(tmp4)
  523. : "r"(va), "r"(una_reg(reg)), "0"(0));
  524. if (error)
  525. goto got_exception;
  526. return;
  528. case 0x2d: /* stq */
  529. __asm__ __volatile__(
  530. "1: ldq_u %2,7(%5)n"
  531. "2: ldq_u %1,0(%5)n"
  532. " insqh %6,%5,%4n"
  533. " insql %6,%5,%3n"
  534. " mskqh %2,%5,%2n"
  535. " mskql %1,%5,%1n"
  536. " or %2,%4,%2n"
  537. " or %1,%3,%1n"
  538. "3: stq_u %2,7(%5)n"
  539. "4: stq_u %1,0(%5)n"
  540. "5:n"
  541. ".section __ex_table,"a"nt"
  542. " .gprel32 1bn"
  543. " lda %2,5b-1b(%0)n"
  544. " .gprel32 2bn"
  545. " lda %1,5b-2b(%0)n"
  546. " .gprel32 3bn"
  547. " lda $31,5b-3b(%0)n"
  548. " .gprel32 4bn"
  549. " lda $31,5b-4b(%0)n"
  550. ".previous"
  551. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  552.   "=&r"(tmp3), "=&r"(tmp4)
  553. : "r"(va), "r"(una_reg(reg)), "0"(0));
  554. if (error)
  555. goto got_exception;
  556. return;
  557. }
  559. lock_kernel();
  560. printk("Bad unaligned kernel access at %016lx: %p %lx %ldn",
  561. pc, va, opcode, reg);
  562. do_exit(SIGSEGV);
  564. got_exception:
  565. /* Ok, we caught the exception, but we don't want it.  Is there
  566.    someone to pass it along to?  */
  567. if ((fixup = search_exception_table(pc, regs.gp)) != 0) {
  568. unsigned long newpc;
  569. newpc = fixup_exception(una_reg, fixup, pc);
  571. printk("Forwarding unaligned exception at %lx (%lx)n",
  572.        pc, newpc);
  574. (&regs)->pc = newpc;
  575. return;
  576. }
  578. /*
  579.  * Yikes!  No one to forward the exception to.
  580.  * Since the registers are in a weird format, dump them ourselves.
  581.    */
  582. lock_kernel();
  584. printk("%s(%d): unhandled unaligned exceptionn",
  585.        current->comm, current->pid);
  587. printk("pc = [<%016lx>]  ra = [<%016lx>]  ps = %04lxn",
  588.        pc, una_reg(26), regs.ps);
  589. printk("r0 = %016lx  r1 = %016lx  r2 = %016lxn",
  590.        una_reg(0), una_reg(1), una_reg(2));
  591. printk("r3 = %016lx  r4 = %016lx  r5 = %016lxn",
  592.          una_reg(3), una_reg(4), una_reg(5));
  593. printk("r6 = %016lx  r7 = %016lx  r8 = %016lxn",
  594.        una_reg(6), una_reg(7), una_reg(8));
  595. printk("r9 = %016lx  r10= %016lx  r11= %016lxn",
  596.        una_reg(9), una_reg(10), una_reg(11));
  597. printk("r12= %016lx  r13= %016lx  r14= %016lxn",
  598.        una_reg(12), una_reg(13), una_reg(14));
  599. printk("r15= %016lxn", una_reg(15));
  600. printk("r16= %016lx  r17= %016lx  r18= %016lxn",
  601.        una_reg(16), una_reg(17), una_reg(18));
  602. printk("r19= %016lx  r20= %016lx  r21= %016lxn",
  603.          una_reg(19), una_reg(20), una_reg(21));
  604.   printk("r22= %016lx  r23= %016lx  r24= %016lxn",
  605.        una_reg(22), una_reg(23), una_reg(24));
  606. printk("r25= %016lx  r27= %016lx  r28= %016lxn",
  607.        una_reg(25), una_reg(27), una_reg(28));
  608. printk("gp = %016lx  sp = %pn", regs.gp, &regs+1);
  610. dik_show_code((unsigned int *)pc);
  611. dik_show_trace((unsigned long *)(&regs+1));
  613. if (current->thread.flags & (1UL << 63)) {
  614. printk("die_if_kernel recursion detected.n");
  615. sti();
  616. while (1);
  617. }
  618. current->thread.flags |= (1UL << 63);
  619. do_exit(SIGSEGV);
  620. }
  622. /*
  623.  * Convert an s-floating point value in memory format to the
  624.  * corresponding value in register format.  The exponent
  625.  * needs to be remapped to preserve non-finite values
  626.  * (infinities, not-a-numbers, denormals).
  627.  */
  628. static inline unsigned long
  629. s_mem_to_reg (unsigned long s_mem)
  630. {
  631. unsigned long frac    = (s_mem >>  0) & 0x7fffff;
  632. unsigned long sign    = (s_mem >> 31) & 0x1;
  633. unsigned long exp_msb = (s_mem >> 30) & 0x1;
  634. unsigned long exp_low = (s_mem >> 23) & 0x7f;
  635. unsigned long exp;
  637. exp = (exp_msb << 10) | exp_low; /* common case */
  638. if (exp_msb) {
  639. if (exp_low == 0x7f) {
  640. exp = 0x7ff;
  641. }
  642. } else {
  643. if (exp_low == 0x00) {
  644. exp = 0x000;
  645. } else {
  646. exp |= (0x7 << 7);
  647. }
  648. }
  649. return (sign << 63) | (exp << 52) | (frac << 29);
  650. }
  652. /*
  653.  * Convert an s-floating point value in register format to the
  654.  * corresponding value in memory format.
  655.  */
  656. static inline unsigned long
  657. s_reg_to_mem (unsigned long s_reg)
  658. {
  659. return ((s_reg >> 62) << 30) | ((s_reg << 5) >> 34);
  660. }
  662. /*
  663.  * Handle user-level unaligned fault.  Handling user-level unaligned
  664.  * faults is *extremely* slow and produces nasty messages.  A user
  665.  * program *should* fix unaligned faults ASAP.
  666.  *
  667.  * Notice that we have (almost) the regular kernel stack layout here,
  668.  * so finding the appropriate registers is a little more difficult
  669.  * than in the kernel case.
  670.  *
  671.  * Finally, we handle regular integer load/stores only.  In
  672.  * particular, load-linked/store-conditionally and floating point
  673.  * load/stores are not supported.  The former make no sense with
  674.  * unaligned faults (they are guaranteed to fail) and I don't think
  675.  * the latter will occur in any decent program.
  676.  *
  677.  * Sigh. We *do* have to handle some FP operations, because GCC will
  678.  * uses them as temporary storage for integer memory to memory copies.
  679.  * However, we need to deal with stt/ldt and sts/lds only.
  680.  */
  682. #define OP_INT_MASK ( 1L << 0x28 | 1L << 0x2c   /* ldl stl */
  683. | 1L << 0x29 | 1L << 0x2d   /* ldq stq */
  684. | 1L << 0x0c | 1L << 0x0d   /* ldwu stw */
  685. | 1L << 0x0a | 1L << 0x0e ) /* ldbu stb */
  687. #define OP_WRITE_MASK ( 1L << 0x26 | 1L << 0x27   /* sts stt */
  688. | 1L << 0x2c | 1L << 0x2d   /* stl stq */
  689. | 1L << 0x0d | 1L << 0x0e ) /* stw stb */
  691. #define R(x) ((size_t) &((struct pt_regs *)0)->x)
  693. static int unauser_reg_offsets[32] = {
  694. R(r0), R(r1), R(r2), R(r3), R(r4), R(r5), R(r6), R(r7), R(r8),
  695. /* r9 ... r15 are stored in front of regs.  */
  696. -56, -48, -40, -32, -24, -16, -8,
  697. R(r16), R(r17), R(r18),
  698. R(r19), R(r20), R(r21), R(r22), R(r23), R(r24), R(r25), R(r26),
  699. R(r27), R(r28), R(gp),
  700. 0, 0
  701. };
  703. #undef R
  705. asmlinkage void
  706. do_entUnaUser(void * va, unsigned long opcode,
  707.       unsigned long reg, struct pt_regs *regs)
  708. {
  709. static int cnt = 0;
  710. static long last_time = 0;
  712. unsigned long tmp1, tmp2, tmp3, tmp4;
  713. unsigned long fake_reg, *reg_addr = &fake_reg;
  714. unsigned long uac_bits;
  715. long error;
  717. /* Check the UAC bits to decide what the user wants us to do
  718.    with the unaliged access.  */
  720. uac_bits = (current->thread.flags >> UAC_SHIFT) & UAC_BITMASK;
  721. if (!(uac_bits & UAC_NOPRINT)) {
  722. if (cnt >= 5 && jiffies - last_time > 5*HZ) {
  723. cnt = 0;
  724. }
  725. if (++cnt < 5) {
  726. printk("%s(%d): unaligned trap at %016lx: %p %lx %ldn",
  727.        current->comm, current->pid,
  728.        regs->pc - 4, va, opcode, reg);
  729. }
  730. last_time = jiffies;
  731. }
  732. if (uac_bits & UAC_SIGBUS) {
  733. goto give_sigbus;
  734. }
  735. if (uac_bits & UAC_NOFIX) {
  736. /* Not sure why you'd want to use this, but... */
  737. return;
  738. }
  740. /* Don't bother reading ds in the access check since we already
  741.    know that this came from the user.  Also rely on the fact that
  742.    the page at TASK_SIZE is unmapped and so can't be touched anyway. */
  743. if (!__access_ok((unsigned long)va, 0, USER_DS))
  744. goto give_sigsegv;
  746. ++unaligned[1].count;
  747. unaligned[1].va = (unsigned long)va;
  748. unaligned[1].pc = regs->pc - 4;
  750. if ((1L << opcode) & OP_INT_MASK) {
  751. /* it's an integer load/store */
  752. if (reg < 30) {
  753. reg_addr = (unsigned long *)
  754.   ((char *)regs + unauser_reg_offsets[reg]);
  755. } else if (reg == 30) {
  756. /* usp in PAL regs */
  757. fake_reg = rdusp();
  758. } else {
  759. /* zero "register" */
  760. fake_reg = 0;
  761. }
  762. }
  764. /* We don't want to use the generic get/put unaligned macros as
  765.    we want to trap exceptions.  Only if we actually get an
  766.    exception will we decide whether we should have caught it.  */
  768. switch (opcode) {
  769. case 0x0c: /* ldwu */
  770. __asm__ __volatile__(
  771. "1: ldq_u %1,0(%3)n"
  772. "2: ldq_u %2,1(%3)n"
  773. " extwl %1,%3,%1n"
  774. " extwh %2,%3,%2n"
  775. "3:n"
  776. ".section __ex_table,"a"n"
  777. " .gprel32 1bn"
  778. " lda %1,3b-1b(%0)n"
  779. " .gprel32 2bn"
  780. " lda %2,3b-2b(%0)n"
  781. ".previous"
  782. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  783. : "r"(va), "0"(0));
  784. if (error)
  785. goto give_sigsegv;
  786. *reg_addr = tmp1|tmp2;
  787. break;
  789. case 0x22: /* lds */
  790. __asm__ __volatile__(
  791. "1: ldq_u %1,0(%3)n"
  792. "2: ldq_u %2,3(%3)n"
  793. " extll %1,%3,%1n"
  794. " extlh %2,%3,%2n"
  795. "3:n"
  796. ".section __ex_table,"a"n"
  797. " .gprel32 1bn"
  798. " lda %1,3b-1b(%0)n"
  799. " .gprel32 2bn"
  800. " lda %2,3b-2b(%0)n"
  801. ".previous"
  802. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  803. : "r"(va), "0"(0));
  804. if (error)
  805. goto give_sigsegv;
  806. alpha_write_fp_reg(reg, s_mem_to_reg((int)(tmp1|tmp2)));
  807. return;
  809. case 0x23: /* ldt */
  810. __asm__ __volatile__(
  811. "1: ldq_u %1,0(%3)n"
  812. "2: ldq_u %2,7(%3)n"
  813. " extql %1,%3,%1n"
  814. " extqh %2,%3,%2n"
  815. "3:n"
  816. ".section __ex_table,"a"n"
  817. " .gprel32 1bn"
  818. " lda %1,3b-1b(%0)n"
  819. " .gprel32 2bn"
  820. " lda %2,3b-2b(%0)n"
  821. ".previous"
  822. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  823. : "r"(va), "0"(0));
  824. if (error)
  825. goto give_sigsegv;
  826. alpha_write_fp_reg(reg, tmp1|tmp2);
  827. return;
  829. case 0x28: /* ldl */
  830. __asm__ __volatile__(
  831. "1: ldq_u %1,0(%3)n"
  832. "2: ldq_u %2,3(%3)n"
  833. " extll %1,%3,%1n"
  834. " extlh %2,%3,%2n"
  835. "3:n"
  836. ".section __ex_table,"a"n"
  837. " .gprel32 1bn"
  838. " lda %1,3b-1b(%0)n"
  839. " .gprel32 2bn"
  840. " lda %2,3b-2b(%0)n"
  841. ".previous"
  842. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  843. : "r"(va), "0"(0));
  844. if (error)
  845. goto give_sigsegv;
  846. *reg_addr = (int)(tmp1|tmp2);
  847. break;
  849. case 0x29: /* ldq */
  850. __asm__ __volatile__(
  851. "1: ldq_u %1,0(%3)n"
  852. "2: ldq_u %2,7(%3)n"
  853. " extql %1,%3,%1n"
  854. " extqh %2,%3,%2n"
  855. "3:n"
  856. ".section __ex_table,"a"n"
  857. " .gprel32 1bn"
  858. " lda %1,3b-1b(%0)n"
  859. " .gprel32 2bn"
  860. " lda %2,3b-2b(%0)n"
  861. ".previous"
  862. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2)
  863. : "r"(va), "0"(0));
  864. if (error)
  865. goto give_sigsegv;
  866. *reg_addr = tmp1|tmp2;
  867. break;
  869. /* Note that the store sequences do not indicate that they change
  870.    memory because it _should_ be affecting nothing in this context.
  871.    (Otherwise we have other, much larger, problems.)  */
  872. case 0x0d: /* stw */
  873. __asm__ __volatile__(
  874. "1: ldq_u %2,1(%5)n"
  875. "2: ldq_u %1,0(%5)n"
  876. " inswh %6,%5,%4n"
  877. " inswl %6,%5,%3n"
  878. " mskwh %2,%5,%2n"
  879. " mskwl %1,%5,%1n"
  880. " or %2,%4,%2n"
  881. " or %1,%3,%1n"
  882. "3: stq_u %2,1(%5)n"
  883. "4: stq_u %1,0(%5)n"
  884. "5:n"
  885. ".section __ex_table,"a"n"
  886. " .gprel32 1bn"
  887. " lda %2,5b-1b(%0)n"
  888. " .gprel32 2bn"
  889. " lda %1,5b-2b(%0)n"
  890. " .gprel32 3bn"
  891. " lda $31,5b-3b(%0)n"
  892. " .gprel32 4bn"
  893. " lda $31,5b-4b(%0)n"
  894. ".previous"
  895. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  896.   "=&r"(tmp3), "=&r"(tmp4)
  897. : "r"(va), "r"(*reg_addr), "0"(0));
  898. if (error)
  899. goto give_sigsegv;
  900. return;
  902. case 0x26: /* sts */
  903. fake_reg = s_reg_to_mem(alpha_read_fp_reg(reg));
  904. /* FALLTHRU */
  906. case 0x2c: /* stl */
  907. __asm__ __volatile__(
  908. "1: ldq_u %2,3(%5)n"
  909. "2: ldq_u %1,0(%5)n"
  910. " inslh %6,%5,%4n"
  911. " insll %6,%5,%3n"
  912. " msklh %2,%5,%2n"
  913. " mskll %1,%5,%1n"
  914. " or %2,%4,%2n"
  915. " or %1,%3,%1n"
  916. "3: stq_u %2,3(%5)n"
  917. "4: stq_u %1,0(%5)n"
  918. "5:n"
  919. ".section __ex_table,"a"n"
  920. " .gprel32 1bn"
  921. " lda %2,5b-1b(%0)n"
  922. " .gprel32 2bn"
  923. " lda %1,5b-2b(%0)n"
  924. " .gprel32 3bn"
  925. " lda $31,5b-3b(%0)n"
  926. " .gprel32 4bn"
  927. " lda $31,5b-4b(%0)n"
  928. ".previous"
  929. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  930.   "=&r"(tmp3), "=&r"(tmp4)
  931. : "r"(va), "r"(*reg_addr), "0"(0));
  932. if (error)
  933. goto give_sigsegv;
  934. return;
  936. case 0x27: /* stt */
  937. fake_reg = alpha_read_fp_reg(reg);
  938. /* FALLTHRU */
  940. case 0x2d: /* stq */
  941. __asm__ __volatile__(
  942. "1: ldq_u %2,7(%5)n"
  943. "2: ldq_u %1,0(%5)n"
  944. " insqh %6,%5,%4n"
  945. " insql %6,%5,%3n"
  946. " mskqh %2,%5,%2n"
  947. " mskql %1,%5,%1n"
  948. " or %2,%4,%2n"
  949. " or %1,%3,%1n"
  950. "3: stq_u %2,7(%5)n"
  951. "4: stq_u %1,0(%5)n"
  952. "5:n"
  953. ".section __ex_table,"a"nt"
  954. " .gprel32 1bn"
  955. " lda %2,5b-1b(%0)n"
  956. " .gprel32 2bn"
  957. " lda %1,5b-2b(%0)n"
  958. " .gprel32 3bn"
  959. " lda $31,5b-3b(%0)n"
  960. " .gprel32 4bn"
  961. " lda $31,5b-4b(%0)n"
  962. ".previous"
  963. : "=r"(error), "=&r"(tmp1), "=&r"(tmp2),
  964.   "=&r"(tmp3), "=&r"(tmp4)
  965. : "r"(va), "r"(*reg_addr), "0"(0));
  966. if (error)
  967. goto give_sigsegv;
  968. return;
  970. default:
  971. /* What instruction were you trying to use, exactly?  */
  972. goto give_sigbus;
  973. }
  975. /* Only integer loads should get here; everyone else returns early. */
  976. if (reg == 30)
  977. wrusp(fake_reg);
  978. return;
  980. give_sigsegv:
  981. regs->pc -= 4;  /* make pc point to faulting insn */
  982. send_sig(SIGSEGV, current, 1);
  983. return;
  985. give_sigbus:
  986. regs->pc -= 4;
  987. send_sig(SIGBUS, current, 1);
  988. return;
  989. }
  991. /*
  992.  * Unimplemented system calls.
  993.  */
  994. asmlinkage long
  995. alpha_ni_syscall(unsigned long a0, unsigned long a1, unsigned long a2,
  996.  unsigned long a3, unsigned long a4, unsigned long a5,
  997.  struct pt_regs regs)
  998. {
  999. /* We only get here for OSF system calls, minus #112;
  1000.    the rest go to sys_ni_syscall.  */
  1001. #if 0
  1002. printk("<sc %ld(%lx,%lx,%lx)>", regs.r0, a0, a1, a2);
  1003. #endif
  1004. return -ENOSYS;
  1005. }
  1007. void
  1008. trap_init(void)
  1009. {
  1010. /* Tell PAL-code what global pointer we want in the kernel.  */
  1011. register unsigned long gptr __asm__("$29");
  1012. wrkgp(gptr);
  1014. wrent(entArith, 1);
  1015. wrent(entMM, 2);
  1016. wrent(entIF, 3);
  1017. wrent(entUna, 4);
  1018. wrent(entSys, 5);
  1019. wrent(entDbg, 6);
  1021. /* Hack for Multia (UDB) and JENSEN: some of their SRMs have
  1022.  * a bug in the handling of the opDEC fault.  Fix it up if so.
  1023.  */
  1024. if (implver() == IMPLVER_EV4) {
  1025. opDEC_check();
  1026. }
  1027. }