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

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

嵌入式Linux

开发平台：

Unix_Linux

entry.S：源码内容
  1. /*------------------------------------------------------------------------------
  2.  * Native PARISC/Linux Project (http://www.puffingroup.com/parisc)
  3.  *
  4.  * kernel entry points (interruptions, system call wrappers)
  5.  *  Copyright (C) 1999,2000 Philipp Rumpf 
  6.  *  Copyright (C) 1999 SuSE GmbH Nuernberg 
  7.  *  Copyright (C) 2000 Hewlett-Packard (John Marvin)
  8.  *  Copyright (C) 1999 Hewlett-Packard (Frank Rowand)
  9.  *
  10.  *    This program is free software; you can redistribute it and/or modify
  11.  *    it under the terms of the GNU General Public License as published by
  12.  *    the Free Software Foundation; either version 2, or (at your option)
  13.  *    any later version.
  14.  *
  15.  *    This program is distributed in the hope that it will be useful,
  16.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *    GNU General Public License for more details.
  19.  *
  20.  *    You should have received a copy of the GNU General Public License
  21.  *    along with this program; if not, write to the Free Software
  22.  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  25. #include <linux/config.h>
  26. #include <asm/offset.h>
  28. /* the following is the setup i think we should follow:
  29.  * whenever the CPU is interruptible, the following has to be true:
  30.  *  CR30 is the kernel sp or 0 if we currently use the kernel stack
  31.  *  CR31 is the kernel gp */ 
  33. /* we have the following possibilities to act on an interruption:
  34.  *  - handle in assembly and use shadowed registers only
  35.  *  - save registers to kernel stack and handle in assembly or C */
  37. .text
  39. #ifdef __LP64__
  40. .level 2.0w
  41. #endif
  43. #define __ASSEMBLY__
  44. #include <asm/assembly.h> /* for LDREG/STREG defines */
  45. #include <asm/pgtable.h>
  46. #include <asm/psw.h>
  47. #include <asm/signal.h>
  49. #ifdef __LP64__
  50. #define FRAME_SIZE 64
  51. #else
  52. #define FRAME_SIZE 64
  53. #endif
  55. /* Switch to virtual mapping, trashing only %r1 */
  56. .macro virt_map rfi_type
  57. mtsm %r0
  58. tovirt %r29
  59. tovirt %r30
  60. mfsp %sr7, %r1
  61. mtsp %r1, %sr3
  62. mtsp %r0, %sr4
  63. mtsp %r0, %sr5
  64. mtsp %r0, %sr6
  65. mtsp %r0, %sr7
  66. ldil L%KERNEL_PSW, %r1
  67. ldo R%KERNEL_PSW(%r1), %r1
  68. LDIL_FIXUP(%r1)
  69. mtctl %r1, %cr22
  70. mtctl %r0, %cr17
  71. mtctl %r0, %cr17
  72. ldil L%.+28, %r1
  73. ldo R%.+24(%r1), %r1
  74. LDIL_FIXUP(%r1)
  75. mtctl %r1, %cr18
  76. ldo 4(%r1), %r1
  77. mtctl %r1, %cr18
  78. rfi_type
  79. nop
  80. .endm
  82. .macro get_stack
  83. mfctl %cr30, %r1 
  84. comib,=,n 0, %r1, 0f   /* forward so predicted not taken */
  86. /* we save the registers in the task struct */
  87. ldo TASK_REGS(%r1), %r29
  88. tophys %r29
  89. STREG %r30, PT_GR30(%r29)
  90. STREG %r1,  PT_CR30(%r29)
  91. ldo TASK_SZ_ALGN(%r1), %r30
  92. b 1f     /* unconditional so predicted taken */
  93. mtctl %r0,%cr30
  94. 0:
  95. /* we put a struct pt_regs on the stack and save the registers there */
  96. copy %r30,%r29
  97. ldo PT_SZ_ALGN(%r30),%r30
  98. tophys %r29
  99. STREG %r30,PT_GR30(%r29)
  100. STREG %r0,PT_CR30(%r29)
  101. 1:
  102. .endm
  104. .macro rest_stack regs
  105. LDREG PT_CR30(regs), %r1
  106. comib,=,n 0, %r1, 2f/* forward so predicted not taken */
  108. /* we restore the registers out of the task struct */
  109. mtctl %r1, %cr30
  110. LDREG PT_GR1(regs), %r1
  111. LDREG PT_GR30(regs),%r30
  112. b 3f
  113. LDREG PT_GR29(regs),%r29
  114. 2:
  115. /* we take a struct pt_regs off the stack */
  116. LDREG PT_GR1(regs),  %r1
  117. LDREG PT_GR29(regs), %r29
  118. ldo -PT_SZ_ALGN(%r30), %r30
  119. 3:
  120. .endm
  122. #ifdef OLD
  123. /* fixme interruption handler */
  124. .macro def code
  125. /* WARNING!!! THIS IS DEBUG CODE ONLY!!! */
  126. b unimplemented_64bitirq
  127. ldi code, %r1
  128. .align 32
  129. .endm
  131. /* Use def to enable break - KWDB wants em
  132.  * (calls traps.c:handle_interruption) */
  133. .macro pass_break code
  135. #else
  136. /* default interruption handler
  137.  * (calls traps.c:handle_interruption) */
  138. .macro def code
  139. #endif
  140. mtctl %r29, %cr31
  141. mtctl %r1,  %cr28
  142. ldi code, %r1
  143. b intr_save
  144. mtctl   %r1, %cr29
  145. .align 32
  146. .endm
  148. /* Interrupt interruption handler
  149.  * (calls irq.c:do_irq_mask) */
  150. .macro extint code
  151. mtctl %r29, %cr31
  152. mtctl %r1,  %cr28
  153. mfctl %cr23, %r1
  154. mtctl %r1, %cr23
  155. b intr_extint
  156. mtctl %r1, %cr29
  157. .align 32
  158. .endm
  160. .import os_hpmc, code
  162. /* HPMC handler */
  163. .macro hpmc code
  164. nop /* must be a NOP, will be patched later */
  165. ldil L%PA(os_hpmc), %r3
  166. ldo R%PA(os_hpmc)(%r3), %r3
  167. bv,n 0(%r3)
  168. nop
  169. .word 0 /* checksum (will be patched) */
  170. .word PA(os_hpmc) /* address of handler */
  171. .word 0 /* length of handler */
  172. .endm
  174. /*
  175.  * Performance Note: Instructions will be moved up into
  176.  * this part of the code later on, once we are sure
  177.  * that the tlb miss handlers are close to final form.
  178.  */
  180. /* Register definitions for tlb miss handler macros */
  182. va  = r8 /* virtual address for which the trap occured */
  183. spc = r24 /* space for which the trap occured */
  185. #ifndef __LP64__
  187. /*
  188.  * itlb miss interruption handler (parisc 1.1 - 32 bit)
  189.  */
  191. .macro itlb_11 code
  193. mfctl %pcsq, spc
  194. b itlb_miss_11
  195. mfctl %pcoq, va
  197. .align 32
  198. .endm
  199. #endif
  201. /*
  202.  * itlb miss interruption handler (parisc 2.0)
  203.  */
  205. .macro itlb_20 code
  207. mfctl %pcsq, spc
  208. #ifdef __LP64__
  209. b       itlb_miss_20w
  210. #else
  211. b itlb_miss_20
  212. #endif
  213. mfctl %pcoq, va
  215. .align 32
  216. .endm
  218. #ifndef __LP64__
  219. /*
  220.  * naitlb miss interruption handler (parisc 1.1 - 32 bit)
  221.  *
  222.  * Note: naitlb misses will be treated
  223.  * as an ordinary itlb miss for now.
  224.  * However, note that naitlb misses
  225.  * have the faulting address in the
  226.  * IOR/ISR.
  227.  */
  229. .macro naitlb_11 code
  231. mfctl %isr,spc
  232. b itlb_miss_11
  233. mfctl  %ior,va
  234. /* FIXME: If user causes a naitlb miss, the priv level may not be in
  235.  * lower bits of va, where the itlb miss handler is expecting them
  236.  */
  238. .align 32
  239. .endm
  240. #endif
  242. /*
  243.  * naitlb miss interruption handler (parisc 2.0)
  244.  *
  245.  * Note: naitlb misses will be treated
  246.  * as an ordinary itlb miss for now.
  247.  * However, note that naitlb misses
  248.  * have the faulting address in the
  249.  * IOR/ISR.
  250.  */
  252. .macro naitlb_20 code
  254. mfctl %isr,spc
  255. #ifdef __LP64__
  256. b       itlb_miss_20w
  257. #else
  258. b itlb_miss_20
  259. #endif
  260. mfctl  %ior,va
  261. /* FIXME: If user causes a naitlb miss, the priv level may not be in
  262.  * lower bits of va, where the itlb miss handler is expecting them
  263.  */
  265. .align 32
  266. .endm
  268. #ifndef __LP64__
  269. /*
  270.  * dtlb miss interruption handler (parisc 1.1 - 32 bit)
  271.  */
  273. .macro dtlb_11 code
  275. mfctl %isr, spc
  276. b dtlb_miss_11
  277. mfctl %ior, va
  279. .align 32
  280. .endm
  281. #endif
  283. /*
  284.  * dtlb miss interruption handler (parisc 2.0)
  285.  */
  287. .macro dtlb_20 code
  289. mfctl %isr, spc
  290. #ifdef __LP64__
  291. b       dtlb_miss_20w
  292. #else
  293. b dtlb_miss_20
  294. #endif
  295. mfctl %ior, va
  297. .align 32
  298. .endm
  300. #ifndef __LP64__
  301. /* nadtlb miss interruption handler (parisc 1.1 - 32 bit)
  302.  *
  303.  * Note: nadtlb misses will be treated
  304.  * as an ordinary dtlb miss for now.
  305.  *
  306.  */
  308. .macro nadtlb_11 code
  310. mfctl %isr,spc
  311. b dtlb_miss_11
  312. mfctl %ior,va
  314. .align 32
  315. .endm
  316. #endif
  318. /* nadtlb miss interruption handler (parisc 2.0)
  319.  *
  320.  * Note: nadtlb misses will be treated
  321.  * as an ordinary dtlb miss for now.
  322.  *
  323.  */
  325. .macro nadtlb_20 code
  327. mfctl %isr,spc
  328. #ifdef __LP64__
  329. b       dtlb_miss_20w
  330. #else
  331. b dtlb_miss_20
  332. #endif
  333. mfctl %ior,va
  335. .align 32
  336. .endm
  338. #ifndef __LP64__
  339. /*
  340.  * dirty bit trap interruption handler (parisc 1.1 - 32 bit)
  341.  */
  343. .macro dbit_11 code
  345. mfctl %isr,spc
  346. b dbit_trap_11
  347. mfctl %ior,va
  349. .align 32
  350. .endm
  351. #endif
  353. /*
  354.  * dirty bit trap interruption handler (parisc 2.0)
  355.  */
  357. .macro dbit_20 code
  359. mfctl %isr,spc
  360. #ifdef __LP64__
  361. b       dbit_trap_20w
  362. #else
  363. b dbit_trap_20
  364. #endif
  365. mfctl %ior,va
  367. .align 32
  368. .endm
  370. /*
  371.  * Align fault_vector_20 on 4K boundary so that both
  372.  * fault_vector_11 and fault_vector_20 are on the
  373.  * same page. This is only necessary as long as we
  374.  * write protect the kernel text, which we may stop
  375.  * doing once we use large parge translations to cover
  376.  * the static part of the kernel address space.
  377.  */
  380. .export fault_vector_20
  382. .align 4096
  384. fault_vector_20:
  385. /* First vector is invalid (0) */
  386. .ascii "cows can fly"
  387. .byte 0
  388. .align 32
  390. hpmc  1
  391. def  2
  392. def  3
  393. extint  4
  394. def  5
  395. itlb_20  6
  396. def  7
  397. def  8
  398. def              9
  399. def 10
  400. def 11
  401. def 12
  402. def 13
  403. def 14
  404. dtlb_20 15
  405. naitlb_20 16
  406. nadtlb_20 17
  407. def 18
  408. def 19
  409. dbit_20 20
  410. def 21
  411. def 22
  412. def 23
  413. def 24
  414. def 25
  415. def 26
  416. def 27
  417. def 28
  418. def 29
  419. def 30
  420. def 31
  422. #ifndef __LP64__
  424. .export fault_vector_11
  426. .align 2048
  428. fault_vector_11:
  429. /* First vector is invalid (0) */
  430. .ascii "cows can fly"
  431. .byte 0
  432. .align 32
  434. hpmc  1
  435. def  2
  436. def  3
  437. extint  4
  438. def  5
  439. itlb_11  6
  440. def  7
  441. def  8
  442. def              9
  443. def 10
  444. def 11
  445. def 12
  446. def 13
  447. def 14
  448. dtlb_11 15
  449. naitlb_11 16
  450. nadtlb_11 17
  451. def 18
  452. def 19
  453. dbit_11 20
  454. def 21
  455. def 22
  456. def 23
  457. def 24
  458. def 25
  459. def 26
  460. def 27
  461. def 28
  462. def 29
  463. def 30
  464. def 31
  466. #endif
  468. .import handle_interruption,code
  469. .import handle_real_interruption,code
  470. .import do_irq_mask,code
  471. .import parisc_stopkernel,code
  472. .import cpu_irq_region,data
  474. /*
  475.  * r26 = function to be called
  476.  * r25 = argument to pass in
  477.  * r24 = flags for do_fork()
  478.  *
  479.  * Kernel threads don't ever return, so they don't need
  480.  * a true register context. We just save away the arguments
  481.  * for copy_thread/ret_ to properly set up the child.
  482.  */
  484. #define CLONE_VM 0x100 /* Must agree with <linux/sched.h> */
  486. .export __kernel_thread, code
  487. .import do_fork
  488. __kernel_thread:
  489. STREG %r2, -RP_OFFSET(%r30)
  491. copy %r30, %r1
  492. ldo PT_SZ_ALGN(%r30),%r30
  493. #ifdef __LP64__
  494. /* Yo, function pointers in wide mode are little structs... -PB */
  495. /* XXX FIXME do we need to honor the fptr's %dp value too? */
  496. ldd 16(%r26), %r26
  497. #endif
  498. STREG %r26, PT_GR26(%r1)  /* Store function & argument for child */
  499. STREG %r25, PT_GR25(%r1)
  500. ldo CLONE_VM(%r0), %r26   /* Force CLONE_VM since only init_mm */
  501. or %r26, %r24, %r26      /* will have kernel mappings.  */
  502. copy %r0, %r25
  503. bl do_fork, %r2
  504. copy %r1, %r24
  506. /* Parent Returns here */
  508. ldo -PT_SZ_ALGN(%r30), %r30
  509. LDREG -RP_OFFSET(%r30), %r2
  510. bv %r0(%r2)
  511. nop
  513. /*
  514.  * Child Returns here
  515.  *
  516.  * copy_thread moved args from temp save area set up above
  517.  * into task save area.
  518.  */
  520. .export ret_from_kernel_thread
  521. ret_from_kernel_thread:
  523. LDREG TASK_PT_GR26-TASK_SZ_ALGN(%r30), %r1
  524. LDREG TASK_PT_GR25-TASK_SZ_ALGN(%r30), %r26
  525. ble 0(%sr7, %r1)
  526. copy %r31, %r2
  528. b sys_exit
  529. ldi 0, %r26
  531. .import sys_execve, code
  532. .export __execve, code
  533. __execve:
  534. copy %r2, %r15
  535. copy %r23, %r17
  536. copy %r30, %r16
  537. ldo PT_SZ_ALGN(%r30), %r30
  538. STREG %r26, PT_GR26(%r16)
  539. STREG %r25, PT_GR25(%r16)
  540. STREG %r24, PT_GR24(%r16)
  541. bl sys_execve, %r2
  542. copy %r16, %r26
  544. comib,<>,n 0,%r28,__execve_failed
  546. b intr_return
  547. STREG %r17, PT_CR30(%r16)
  549. __execve_failed:
  550. /* yes, this will trap and die. */
  551. copy %r15, %r2
  552. bv %r0(%r2)
  553. nop
  555. .align 4
  557. /*
  558.  * struct task_struct *_switch_to(struct task_struct *prev,
  559.  * struct task_struct *next)
  560.  *
  561.  * switch kernel stacks and return prev */
  562. .export _switch_to, code
  563. _switch_to:
  564. STREG  %r2, -RP_OFFSET(%r30)
  566. callee_save
  568. ldil L%_switch_to_ret, %r2
  569. ldo R%_switch_to_ret(%r2), %r2
  570. LDIL_FIXUP(%r2)
  572. STREG %r2, TASK_PT_KPC(%r26)
  573. LDREG TASK_PT_KPC(%r25), %r2
  575. STREG %r30, TASK_PT_KSP(%r26)
  576. LDREG TASK_PT_KSP(%r25), %r30
  578. bv %r0(%r2)
  579. nop
  581. _switch_to_ret:
  582. mtctl %r0, %cr0 /* Needed for single stepping */
  583. callee_rest
  585. LDREG -RP_OFFSET(%r30), %r2
  586. bv %r0(%r2)
  587. copy %r26, %r28
  589. /*
  590.  * Common rfi return path for interruptions, kernel execve, and some
  591.  * syscalls.  The sys_rt_sigreturn syscall will return via this path
  592.  * if the signal was received when the process was running; if the
  593.  * process was blocked on a syscall then the normal syscall_exit
  594.  * path is used.  All syscalls for traced proceses exit via
  595.  * intr_restore.
  596.  * Note that the following code uses a "relied upon translation". See
  597.  * the parisc ACD for details. The ssm is necessary due to a PCXT bug.
  598.  */
  600. .align 4096
  602. .export syscall_exit_rfi
  603. syscall_exit_rfi:
  604. copy    %r30,%r16
  605. /* FIXME! depi below has hardcoded dependency on kernel stack size */
  606. depi    0,31,14,%r16 /* get task pointer */
  607. ldo TASK_REGS(%r16),%r16
  608. /* Force iaoq to userspace, as the user has had access to our current
  609.  * context via sigcontext.
  610.  * XXX do we need any other protection here?
  611.  */
  612. LDREG PT_IAOQ0(%r16),%r19
  613. depi 3,31,2,%r19
  614. STREG %r19,PT_IAOQ0(%r16)
  615. LDREG PT_IAOQ1(%r16),%r19
  616. depi 3,31,2,%r19
  617. STREG %r19,PT_IAOQ1(%r16)
  619. intr_return:
  621. /* Check for software interrupts */
  623. .import irq_stat,data
  625. ldil    L%irq_stat,%r19
  626. ldo     R%irq_stat(%r19),%r19
  627. LDIL_FIXUP(%r19)
  629. #ifdef CONFIG_SMP
  630. copy    %r30,%r1
  631. /* FIXME! depi below has hardcoded dependency on kernel stack size */
  632. depi    0,31,14,%r1 /* get task pointer */
  633. ldw     TASK_PROCESSOR(%r1),%r20 /* get cpu # - int */
  634. #if (IRQSTAT_SZ == 32)
  635. dep     %r20,26,27,%r20 /* shift left 5 bits */
  636. #else
  637. #error IRQSTAT_SZ changed, fix dep
  638. #endif /* IRQSTAT_SZ */
  639. add     %r19,%r20,%r19
  640. #endif /* CONFIG_SMP */
  642. ldw     IRQSTAT_SI_ACTIVE(%r19),%r20 /* hardirq.h: unsigned int */
  643. ldw     IRQSTAT_SI_MASK(%r19),%r19 /* hardirq.h: unsigned int */
  644. and     %r19,%r20,%r20
  645. comib,<>,n 0,%r20,intr_do_softirq /* forward */
  647. intr_check_resched:
  649. /* check for reschedule */
  650. copy    %r30,%r1
  651. /* FIXME! depi below has hardcoded dependency on kernel stack size */
  652. depi    0,31,14,%r1 /* get task pointer */
  653. LDREG     TASK_NEED_RESCHED(%r1),%r19 /* sched.h: long need_resched */
  654. comib,<>,n 0,%r19,intr_do_resched /* forward */
  656. intr_check_sig:
  657. /* As above */
  658. copy    %r30,%r1
  659. depi    0,31,14,%r1 /* get task pointer */
  660. ldw TASK_SIGPENDING(%r1),%r19 /* sched.h: int sigpending */
  661. comib,<>,n 0,%r19,intr_do_signal /* forward */
  663. intr_restore:
  664. copy      %r16, %r29
  665. ldo PT_FR31(%r29), %r29
  666. rest_fp %r29
  667. copy     %r16, %r29
  668. rest_general  %r29
  669. ssm 0,%r0
  670. nop
  671. nop
  672. nop
  673. nop
  674. nop
  675. nop
  676. nop
  677. tophys %r29
  678. mtsm %r0
  679. rest_specials %r29
  680. rest_stack %r29
  681. rfi
  682. nop
  683. nop
  684. nop
  685. nop
  686. nop
  687. nop
  688. nop
  689. nop
  691. .import do_softirq,code
  692. intr_do_softirq:
  693. bl      do_softirq,%r2
  694. nop
  695. b       intr_check_resched
  696. nop
  698. .import schedule,code
  699. intr_do_resched:
  700. /* Only do reschedule if we are returning to user space */
  701. LDREG     PT_SR7(%r16), %r20
  702. comib,= 0,%r20,intr_restore /* backward */
  703. nop
  705. bl      schedule,%r2
  706. ssm     PSW_SM_I, %r0
  708. /* It's OK to leave I bit on */
  709. b       intr_return /* start over if we got a resched */
  710. nop
  712. .import do_signal,code
  713. intr_do_signal:
  714. /* Only do signals if we are returning to user space */
  715. LDREG   PT_SR7(%r16), %r20
  716. comib,= 0,%r20,intr_restore /* backward */
  717. nop
  719. copy %r0, %r24 /* unsigned long in_syscall */
  720. copy %r16, %r25 /* struct pt_regs *regs */
  721. ssm     PSW_SM_I, %r0
  722. bl do_signal,%r2
  723. copy %r0, %r26 /* sigset_t *oldset = NULL */
  725. b intr_restore
  726. nop
  728. /* CR28 - saved GR1
  729.  * CR29 - argument for do_irq_mask */
  731. /* External interrupts */
  732. intr_extint:
  733. get_stack
  734. save_specials %r29
  735. virt_map rfi
  736. save_general %r29
  738. ldo PT_FR0(%r29), %r24
  739. save_fp %r24
  741. loadgp
  743. copy %r29, %r24 /* arg2 is pt_regs */
  744. copy %r29, %r16 /* save pt_regs */
  745. #ifdef CONFIG_KWDB
  746. copy %r29, %r3 /* KWDB - update frame pointer (gr3) */
  747. #endif
  749. /* sorry to put this cruft in the interrupt path */
  750. ldil L%cpu_irq_region, %r25
  751. ldo R%cpu_irq_region(%r25), %r25
  752. bl do_irq_mask,%r2
  753. #ifdef __LP64__
  754. LDIL_FIXUP(%r25)
  755. #else
  756. nop
  757. #endif
  759. b intr_return
  760. nop
  762. /* Generic interruptions (illegal insn, unaligned, page fault, etc) */
  764. .export         intr_save, code /* for os_hpmc */
  766. intr_save:
  767. get_stack
  768. save_specials %r29
  770. mfctl %cr20, %r1
  771. STREG %r1, PT_ISR(%r29)
  772. mfctl %cr21, %r1
  773. STREG %r1, PT_IOR(%r29)
  775. virt_map rfi
  776. save_general %r29
  778. ldo PT_FR0(%r29), %r25
  779. save_fp %r25
  781. loadgp
  783. copy %r29, %r25 /* arg1 is pt_regs */
  784. #ifdef CONFIG_KWDB
  785. copy %r29, %r3 /* KWDB - update frame pointer (gr3) */
  786. #endif
  788. bl handle_interruption,%r2
  789. copy %r29, %r16 /* save pt_regs */
  791. b intr_return
  792. nop
  794. /*
  795.  * Note for all tlb miss handlers:
  796.  *
  797.  * cr24 contains a pointer to the kernel address space
  798.  * page directory.
  799.  *
  800.  * cr25 contains a pointer to the current user address
  801.  * space page directory.
  802.  *
  803.  * sr3 will contain the space id of the user address space
  804.  * of the current running thread while that thread is
  805.  * running in the kernel.
  806.  */
  808. /*
  809.  * register number allocations.  Note that these are all
  810.  * in the shadowed registers
  811.  */
  813. t0 = r1 /* temporary register 0 */
  814. va = r8 /* virtual address for which the trap occured */
  815. t1 = r9 /* temporary register 1 */
  816. pte  = r16 /* pte/phys page # */
  817. prot = r17 /* prot bits */
  818. spc  = r24 /* space for which the trap occured */
  819. ptp = r25 /* page directory/page table pointer */
  821. #ifdef __LP64__
  823. dtlb_miss_20w:
  825. extrd,u         spc,31,7,t1     /* adjust va */
  826. depd            t1,31,7,va      /* adjust va */
  827. depdi           0,31,7,spc      /* adjust space */
  828. mfctl           %cr25,ptp /* Assume user space miss */
  829. or,*<>          %r0,spc,%r0     /* If it is user space, nullify */
  830. mfctl           %cr24,ptp /* Load kernel pgd instead */
  831. extrd,u         va,33,9,t1      /* Get pgd index */
  833. mfsp            %sr7,t0 /* Get current space */
  834. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  835. comb,<>,n       t0,spc,dtlb_fault /* forward */
  837. /* First level page table lookup */
  839. ldd,s           t1(ptp),ptp
  840. extrd,u         va,42,9,t0     /* get second-level index */
  841. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dtlb_fault
  842. depdi           0,63,12,ptp     /* clear prot bits */
  844. /* Second level page table lookup */
  846. ldd,s           t0(ptp),ptp
  847. extrd,u         va,51,9,t0     /* get third-level index */
  848. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dtlb_fault
  849. depdi           0,63,12,ptp     /* clear prot bits */
  851. /* Third level page table lookup */
  853. shladd           t0,3,ptp,ptp
  854. ldi _PAGE_ACCESSED,t1
  855. ldd              0(ptp),pte
  856. bb,>=,n          pte,_PAGE_PRESENT_BIT,dtlb_fault
  858. /* Check whether the "accessed" bit was set, otherwise do so */
  860. or t1,pte,t0 /* t0 has R bit set */
  861. and,*<>         t1,pte,%r0      /* test and nullify if already set */
  862. std             t0,0(ptp)       /* write back pte */
  864. copy            spc,prot /* init prot with faulting space */
  866. depd pte,8,7,prot
  867. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  868. depdi 1,12,1,prot
  869. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  870. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  871. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  872. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  874. /* Get rid of prot bits and convert to page addr for idtlbt */
  876. depdi 0,63,12,pte
  877. extrd,u         pte,56,32,pte
  878. idtlbt %r16,%r17
  880. rfir
  881. nop
  882. #else
  884. dtlb_miss_11:
  885. mfctl           %cr25,ptp /* Assume user space miss */
  886. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  887. mfctl           %cr24,ptp /* Load kernel pgd instead */
  888. extru va,9,10,t1 /* Get pgd index */
  890. mfsp            %sr7,t0 /* Get current space */
  891. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  892. comb,<>,n       t0,spc,dtlb_fault /* forward */
  894. /* First level page table lookup */
  896. ldwx,s t1(ptp),ptp
  897. extru va,19,10,t0 /* get second-level index */
  898. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dtlb_fault
  899. depi 0,31,12,ptp /* clear prot bits */
  901. /* Second level page table lookup */
  903. sh2addl   t0,ptp,ptp
  904. ldi _PAGE_ACCESSED,t1
  905. ldw  0(ptp),pte
  906. bb,>=,n   pte,_PAGE_PRESENT_BIT,dtlb_fault
  908. /* Check whether the "accessed" bit was set, otherwise do so */
  910. or t1,pte,t0 /* t0 has R bit set */
  911. and,<> t1,pte,%r0 /* test and nullify if already set */
  912. stw t0,0(ptp) /* write back pte */
  914. copy            spc,prot /* init prot with faulting space */
  915. dep pte,8,7,prot
  917. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  918. depi 1,12,1,prot
  919. extru,=         pte,_PAGE_USER_BIT,1,r0
  920. depi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  921. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  922. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  924. /* Get rid of prot bits and convert to page addr for idtlba */
  926. depi 0,31,12,pte
  927. extru pte,24,25,pte
  929. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  930. mtsp spc,%sr1
  932. idtlba pte,(%sr1,va)
  933. idtlbp prot,(%sr1,va)
  935. mtsp t0, %sr1 /* Restore sr1 */
  937. rfir
  938. nop
  940. dtlb_miss_20:
  941. .level 2.0
  943. mfctl           %cr25,ptp /* Assume user space miss */
  944. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  945. mfctl           %cr24,ptp /* Load kernel pgd instead */
  946. extru va,9,10,t1 /* Get pgd index */
  948. mfsp            %sr7,t0 /* Get current space */
  949. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  950. comb,<>,n       t0,spc,dtlb_fault /* forward */
  952. /* First level page table lookup */
  954. ldwx,s t1(ptp),ptp
  955. extru va,19,10,t0 /* get second-level index */
  956. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dtlb_fault
  957. depi 0,31,12,ptp /* clear prot bits */
  959. /* Second level page table lookup */
  961. sh2addl   t0,ptp,ptp
  962. ldi _PAGE_ACCESSED,t1
  963. ldw  0(ptp),pte
  964. bb,>=,n   pte,_PAGE_PRESENT_BIT,dtlb_fault
  966. /* Check whether the "accessed" bit was set, otherwise do so */
  968. or t1,pte,t0 /* t0 has R bit set */
  969. and,<> t1,pte,%r0 /* test and nullify if already set */
  970. stw t0,0(ptp) /* write back pte */
  972. copy            spc,prot /* init prot with faulting space */
  974. depd pte,8,7,prot
  975. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  976. depdi 1,12,1,prot
  977. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  978. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  979. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  980. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  982. /* Get rid of prot bits and convert to page addr for idtlbt */
  984. depdi 0,63,12,pte
  985. extrd,u pte,56,25,pte
  986. idtlbt %r16,%r17
  988. .level 1.1
  990. rfir
  991. nop
  992. #endif
  994. #ifdef __LP64__
  995. itlb_miss_20w:
  997. /*
  998.  * I miss is a little different, since we allow users to fault
  999.  * on the gateway page which is in the kernel address space.
  1000.  */
  1002. extrd,u         spc,31,7,t1     /* adjust va */
  1003. depd            t1,31,7,va      /* adjust va */
  1004. depdi           0,31,7,spc      /* adjust space */
  1005. cmpib,*=        0,spc,itlb_miss_kernel_20w
  1006. extrd,u         va,33,9,t1      /* Get pgd index */
  1008. mfctl           %cr25,ptp /* load user pgd */
  1010. mfsp            %sr7,t0 /* Get current space */
  1011. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  1012. cmpb,*<>,n      t0,spc,itlb_fault /* forward */
  1014. /* First level page table lookup */
  1016. itlb_miss_common_20w:
  1017. ldd,s           t1(ptp),ptp
  1018. extrd,u         va,42,9,t0     /* get second-level index */
  1019. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1020. depdi           0,63,12,ptp     /* clear prot bits */
  1022. /* Second level page table lookup */
  1024. ldd,s           t0(ptp),ptp
  1025. extrd,u         va,51,9,t0     /* get third-level index */
  1026. bb,>=,n         ptp,_PAGE_PRESENT_BIT,itlb_fault
  1027. depdi           0,63,12,ptp     /* clear prot bits */
  1029. /* Third level page table lookup */
  1031. shladd           t0,3,ptp,ptp
  1032. ldi _PAGE_ACCESSED,t1
  1033. ldd              0(ptp),pte
  1034. bb,>=,n          pte,_PAGE_PRESENT_BIT,itlb_fault
  1036. /* Check whether the "accessed" bit was set, otherwise do so */
  1038. or t1,pte,t0 /* t0 has R bit set */
  1039. and,*<>         t1,pte,%r0      /* test and nullify if already set */
  1040. std             t0,0(ptp)       /* write back pte */
  1042. copy            spc,prot        /* init prot with faulting space */
  1044. depd pte,8,7,prot
  1045. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  1046. depdi 1,12,1,prot
  1047. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1048. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1049. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1050. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1052. /* Get rid of prot bits and convert to page addr for iitlbt */
  1054. depdi 0,63,12,pte
  1055. extrd,u         pte,56,32,pte
  1056. iitlbt          %r16,%r17
  1058. rfir
  1059. nop
  1061. itlb_miss_kernel_20w:
  1062. b               itlb_miss_common_20w
  1063. mfctl           %cr24,ptp /* Load kernel pgd */
  1064. #else
  1066. itlb_miss_11:
  1068. /*
  1069.  * I miss is a little different, since we allow users to fault
  1070.  * on the gateway page which is in the kernel address space.
  1071.  */
  1073. comib,=         0,spc,itlb_miss_kernel_11
  1074. extru va,9,10,t1 /* Get pgd index */
  1076. mfctl           %cr25,ptp /* load user pgd */
  1078. mfsp            %sr7,t0 /* Get current space */
  1079. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1080. comb,<>,n       t0,spc,itlb_fault /* forward */
  1082. /* First level page table lookup */
  1084. itlb_miss_common_11:
  1085. ldwx,s t1(ptp),ptp
  1086. extru va,19,10,t0 /* get second-level index */
  1087. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1088. depi 0,31,12,ptp /* clear prot bits */
  1090. /* Second level page table lookup */
  1092. sh2addl   t0,ptp,ptp
  1093. ldi _PAGE_ACCESSED,t1
  1094. ldw  0(ptp),pte
  1095. bb,>=,n   pte,_PAGE_PRESENT_BIT,itlb_fault
  1097. /* Check whether the "accessed" bit was set, otherwise do so */
  1099. or t1,pte,t0 /* t0 has R bit set */
  1100. and,<> t1,pte,%r0 /* test and nullify if already set */
  1101. stw t0,0(ptp) /* write back pte */
  1103. copy            spc,prot        /* init prot with faulting space */
  1104. dep pte,8,7,prot
  1106. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1107. depi 1,12,1,prot
  1108. extru,=         pte,_PAGE_USER_BIT,1,r0
  1109. depi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1110. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1111. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1113. /* Get rid of prot bits and convert to page addr for iitlba */
  1115. depi 0,31,12,pte
  1116. extru pte,24,25,pte
  1118. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1119. mtsp spc,%sr1
  1121. iitlba pte,(%sr1,va)
  1122. iitlbp prot,(%sr1,va)
  1124. mtsp t0, %sr1 /* Restore sr1 */
  1126. rfir
  1127. nop
  1129. itlb_miss_kernel_11:
  1130. b               itlb_miss_common_11
  1131. mfctl           %cr24,ptp /* Load kernel pgd */
  1133. itlb_miss_20:
  1135. /*
  1136.  * I miss is a little different, since we allow users to fault
  1137.  * on the gateway page which is in the kernel address space.
  1138.  */
  1140. comib,=         0,spc,itlb_miss_kernel_20
  1141. extru va,9,10,t1 /* Get pgd index */
  1143. mfctl           %cr25,ptp /* load user pgd */
  1145. mfsp            %sr7,t0 /* Get current space */
  1146. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1147. comb,<>,n       t0,spc,itlb_fault /* forward */
  1149. /* First level page table lookup */
  1151. itlb_miss_common_20:
  1152. ldwx,s t1(ptp),ptp
  1153. extru va,19,10,t0 /* get second-level index */
  1154. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1155. depi 0,31,12,ptp /* clear prot bits */
  1157. /* Second level page table lookup */
  1159. sh2addl   t0,ptp,ptp
  1160. ldi _PAGE_ACCESSED,t1
  1161. ldw  0(ptp),pte
  1162. bb,>=,n   pte,_PAGE_PRESENT_BIT,itlb_fault
  1164. /* Check whether the "accessed" bit was set, otherwise do so */
  1166. or t1,pte,t0 /* t0 has R bit set */
  1167. and,<> t1,pte,%r0 /* test and nullify if already set */
  1168. stw t0,0(ptp) /* write back pte */
  1170. copy            spc,prot        /* init prot with faulting space */
  1172. .level 2.0
  1174. depd pte,8,7,prot
  1175. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  1176. depdi 1,12,1,prot
  1177. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1178. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1179. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1180. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1182. /* Get rid of prot bits and convert to page addr for iitlbt */
  1184. depdi 0,63,12,pte
  1185. extrd,u pte,56,25,pte
  1186. iitlbt          %r16,%r17
  1187. .level 1.1
  1189. rfir
  1190. nop
  1193. itlb_miss_kernel_20:
  1194. b               itlb_miss_common_20
  1195. mfctl           %cr24,ptp /* Load kernel pgd */
  1196. #endif
  1198. #ifdef __LP64__
  1200. dbit_trap_20w:
  1202. extrd,u         spc,31,7,t1     /* adjust va */
  1203. depd            t1,31,7,va      /* adjust va */
  1204. depdi           0,1,2,va        /* adjust va */
  1205. depdi           0,31,7,spc      /* adjust space */
  1206. mfctl           %cr25,ptp /* Assume user space miss */
  1207. or,*<>          %r0,spc,%r0     /* If it is user space, nullify */
  1208. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1209. extrd,u         va,33,9,t1      /* Get pgd index */
  1211. mfsp            %sr7,t0 /* Get current space */
  1212. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  1213. comb,<>,n       t0,spc,dbit_fault /* forward */
  1215. /* First level page table lookup */
  1217. ldd,s           t1(ptp),ptp
  1218. extrd,u         va,42,9,t0     /* get second-level index */
  1219. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dbit_fault
  1220. depdi           0,63,12,ptp     /* clear prot bits */
  1222. /* Second level page table lookup */
  1224. ldd,s           t0(ptp),ptp
  1225. extrd,u         va,51,9,t0     /* get third-level index */
  1226. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dbit_fault
  1227. depdi           0,63,12,ptp     /* clear prot bits */
  1229. /* Third level page table lookup */
  1231. shladd           t0,3,ptp,ptp
  1232. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1233. ldd              0(ptp),pte
  1234. bb,>=,n          pte,_PAGE_PRESENT_BIT,dbit_fault
  1236. /* Set Accessed and Dirty bits in the pte */
  1238. or t1,pte,pte
  1239. std             pte,0(ptp)      /* write back pte */
  1241. copy            spc,prot /* init prot with faulting space */
  1243. depd pte,8,7,prot
  1244. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  1245. depdi 1,12,1,prot
  1246. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1247. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1248. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1249. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1251. /* Get rid of prot bits and convert to page addr for idtlbt */
  1253. depdi 0,63,12,pte
  1254. extrd,u         pte,56,32,pte
  1255. idtlbt %r16,%r17
  1257. rfir
  1258. nop
  1259. #else
  1261. dbit_trap_11:
  1262. mfctl           %cr25,ptp /* Assume user space trap */
  1263. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1264. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1265. extru va,9,10,t1 /* Get pgd index */
  1267. mfsp            %sr7,t0 /* Get current space */
  1268. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1269. comb,<>,n       t0,spc,dbit_fault /* forward */
  1271. /* First level page table lookup */
  1273. ldwx,s t1(ptp),ptp
  1274. extru va,19,10,t0 /* get second-level index */
  1275. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dbit_fault
  1276. depi 0,31,12,ptp /* clear prot bits */
  1278. /* Second level page table lookup */
  1280. sh2addl   t0,ptp,ptp
  1281. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1282. ldw  0(ptp),pte
  1283. bb,>=,n   pte,_PAGE_PRESENT_BIT,dbit_fault
  1285. /* Set Accessed and Dirty bits in the pte */
  1287. or t1,pte,pte
  1288. stw pte,0(ptp) /* write back pte */
  1290. copy            spc,prot        /* init prot with faulting space */
  1291. dep pte,8,7,prot
  1293. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1294. depi 1,12,1,prot
  1295. extru,=         pte,_PAGE_USER_BIT,1,r0
  1296. depi 7,11,3,prot /* Set for user space (1 rsvd for read) */
  1297. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1298. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1300. /* Get rid of prot bits and convert to page addr for idtlba */
  1302. depi 0,31,12,pte
  1303. extru pte,24,25,pte
  1305. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1306. mtsp spc,%sr1
  1308. idtlba pte,(%sr1,va)
  1309. idtlbp prot,(%sr1,va)
  1311. mtsp t0, %sr1     /* Restore sr1 */
  1313. rfir
  1314. nop
  1316. dbit_trap_20:
  1317. mfctl           %cr25,ptp /* Assume user space trap */
  1318. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1319. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1320. extru va,9,10,t1 /* Get pgd index */
  1322. mfsp            %sr7,t0 /* Get current space */
  1323. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1324. comb,<>,n       t0,spc,dbit_fault /* forward */
  1326. /* First level page table lookup */
  1328. ldwx,s t1(ptp),ptp
  1329. extru va,19,10,t0 /* get second-level index */
  1330. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dbit_fault
  1331. depi 0,31,12,ptp /* clear prot bits */
  1333. /* Second level page table lookup */
  1335. sh2addl   t0,ptp,ptp
  1336. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1337. ldw  0(ptp),pte
  1338. bb,>=,n   pte,_PAGE_PRESENT_BIT,dbit_fault
  1340. /* Set Accessed and Dirty bits in the pte */
  1342. or t1,pte,pte
  1343. stw pte,0(ptp) /* write back pte */
  1345. copy            spc,prot        /* init prot with faulting space */
  1347. .level 2.0
  1349. depd pte,8,7,prot
  1350. extrd,u,*= pte,_PAGE_NO_CACHE_BIT+32,1,r0
  1351. depdi 1,12,1,prot
  1352. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1353. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1354. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1355. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1357. /* Get rid of prot bits and convert to page addr for idtlbt */
  1359. depdi 0,63,12,pte
  1360. extrd,u pte,56,25,pte
  1361. idtlbt %r16,%r17
  1363. .level 1.1
  1365. rfir
  1366. nop
  1367. #endif
  1369. .import handle_interruption,code
  1371. kernel_bad_space:
  1372. b tlb_fault
  1373. ldi 31,%r1 /* Use an unused code */
  1375. dbit_fault:
  1376. b tlb_fault
  1377. ldi 20,%r1
  1379. itlb_fault:
  1380. b tlb_fault
  1381. ldi 6,%r1
  1383. dtlb_fault:
  1384. ldi 15,%r1
  1386. /* Fall Through */
  1388. tlb_fault:
  1389. mtctl %r1,%cr29
  1390. mtctl %r29,%cr31
  1392. get_stack
  1393. save_specials %r29 /* Note this saves a trashed r1 */
  1395. SAVE_CR (%cr20, PT_ISR(%r29))
  1396. SAVE_CR (%cr21, PT_IOR(%r29))
  1398. virt_map rfir
  1400. STREG %r1,PT_GR1(%r29) /* save good value after rfir */
  1402. save_general %r29
  1404. ldo PT_FR0(%r29), %r25
  1405. save_fp %r25
  1407. loadgp
  1409. copy %r29, %r25
  1411. bl handle_interruption, %r2
  1412. copy %r29, %r16
  1414. b intr_return
  1415. nop
  1417. /* Register saving semantics for system calls:
  1419.    %r1    clobbered by system call macro in userspace
  1420.    %r2    saved in PT_REGS by gateway page
  1421.    %r3  - %r18    preserved by C code (saved by signal code)
  1422.    %r19 - %r20    saved in PT_REGS by gateway page
  1423.    %r21 - %r22    non-standard syscall args
  1424.    stored in kernel stack by gateway page
  1425.    %r23 - %r26    arg3-arg0, saved in PT_REGS by gateway page
  1426.    %r27 - %r30    saved in PT_REGS by gateway page
  1427.    %r31    syscall return pointer
  1428.  */
  1430. /* Floating point registers (FIXME: what do we do with these?)
  1432.    %fr0  - %fr3    status/exception, not preserved
  1433.    %fr4  - %fr7    arguments
  1434.    %fr8  - %fr11   not preserved by C code
  1435.    %fr12 - %fr21   preserved by C code
  1436.    %fr22 - %fr31   not preserved by C code
  1437.  */
  1439. .macro reg_save regs
  1440. STREG %r3, PT_GR3(regs)
  1441. STREG %r4, PT_GR4(regs)
  1442. STREG %r5, PT_GR5(regs)
  1443. STREG %r6, PT_GR6(regs)
  1444. STREG %r7, PT_GR7(regs)
  1445. STREG %r8, PT_GR8(regs)
  1446. STREG %r9, PT_GR9(regs)
  1447. STREG   %r10,PT_GR10(regs)
  1448. STREG   %r11,PT_GR11(regs)
  1449. STREG   %r12,PT_GR12(regs)
  1450. STREG   %r13,PT_GR13(regs)
  1451. STREG   %r14,PT_GR14(regs)
  1452. STREG   %r15,PT_GR15(regs)
  1453. STREG   %r16,PT_GR16(regs)
  1454. STREG   %r17,PT_GR17(regs)
  1455. STREG   %r18,PT_GR18(regs)
  1456. .endm
  1458. .macro reg_restore regs
  1459. LDREG PT_GR3(regs), %r3
  1460. LDREG PT_GR4(regs), %r4
  1461. LDREG PT_GR5(regs), %r5
  1462. LDREG PT_GR6(regs), %r6
  1463. LDREG PT_GR7(regs), %r7
  1464. LDREG PT_GR8(regs), %r8
  1465. LDREG PT_GR9(regs), %r9
  1466. LDREG   PT_GR10(regs),%r10
  1467. LDREG   PT_GR11(regs),%r11
  1468. LDREG   PT_GR12(regs),%r12
  1469. LDREG   PT_GR13(regs),%r13
  1470. LDREG   PT_GR14(regs),%r14
  1471. LDREG   PT_GR15(regs),%r15
  1472. LDREG   PT_GR16(regs),%r16
  1473. LDREG   PT_GR17(regs),%r17
  1474. LDREG   PT_GR18(regs),%r18
  1475. .endm
  1477. .export sys_fork_wrapper
  1478. sys_fork_wrapper:
  1479. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  1480. reg_save %r1
  1482. STREG %r2,-RP_OFFSET(%r30)
  1483. ldo FRAME_SIZE(%r30),%r30
  1485. /* These are call-clobbered registers and therefore
  1486.    also syscall-clobbered (we hope). */
  1487. STREG %r2,PT_GR19(%r1) /* save for child */
  1488. STREG %r30,PT_GR20(%r1)
  1489. ldil L%child_return, %r3
  1490. ldo R%child_return(%r3), %r3
  1491. LDIL_FIXUP(%r3)
  1492. STREG %r3,PT_GR21(%r1) /* save for child */
  1494. LDREG PT_GR30(%r1),%r25
  1495. copy %r1,%r24
  1496. bl sys_clone,%r2
  1497. ldi SIGCHLD,%r26
  1499. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  1500. wrapper_exit:
  1501. ldo -FRAME_SIZE(%r30),%r30 /* get the stackframe */
  1502. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1    /* get pt regs */
  1504. reg_restore %r1
  1506. bv %r0(%r2)
  1507. nop
  1509. /* Set the return value for the child */
  1510. child_return:
  1511. LDREG TASK_PT_GR19-TASK_SZ_ALGN-128(%r30),%r2
  1512. b wrapper_exit
  1513. copy %r0,%r28
  1516. .export sys_clone_wrapper
  1517. sys_clone_wrapper:
  1518. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  1519. reg_save %r1
  1521. STREG %r2,-RP_OFFSET(%r30)
  1522. ldo FRAME_SIZE(%r30),%r30
  1524. STREG %r30,PT_GR20(%r1)
  1525. ldil L%child_return,%r3
  1526. ldo R%child_return(%r3),%r3
  1527. LDIL_FIXUP(%r3)
  1529. bl sys_clone,%r2
  1530. STREG %r3,PT_GR21(%r1) /* save for child */
  1532. b wrapper_exit
  1533. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  1536. .export sys_vfork_wrapper
  1537. sys_vfork_wrapper:
  1538. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  1539. reg_save %r1
  1541. STREG %r2,-RP_OFFSET(%r30)
  1542. ldo FRAME_SIZE(%r30),%r30
  1544. STREG %r30,PT_GR20(%r1)
  1545. ldil L%child_return,%r3
  1546. ldo R%child_return(%r3),%r3
  1547. LDIL_FIXUP(%r3)
  1548. STREG %r3,PT_GR21(%r1) /* save for child */
  1550. bl sys_vfork,%r2
  1551. copy %r1,%r26
  1553. b wrapper_exit
  1554. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  1557. .macro  execve_wrapper execve
  1558. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1     /* get pt regs */
  1560. /*
  1561.  * Do we need to save/restore r3-r18 here?
  1562.  * I don't think so. why would new thread need old
  1563.  * threads registers?
  1564.  */
  1566. /* %arg0 - %arg3 are already saved for us. */
  1568. STREG %r2,-RP_OFFSET(%r30)
  1569. ldo FRAME_SIZE(%r30),%r30
  1570. bl execve,%r2
  1571. copy %r1,%arg0
  1573. ldo -FRAME_SIZE(%r30),%r30
  1574. LDREG -RP_OFFSET(%r30),%r2
  1576. /* If exec succeeded we need to load the args */
  1578. ldo -1024(%r0),%r1
  1579. comb,>>= %r28,%r1,error_execve
  1580. copy %r2,%r19
  1582. error_execve:
  1583. bv %r0(%r19)
  1584. nop
  1585. .endm
  1587. .export sys_execve_wrapper
  1588. .import sys_execve
  1590. sys_execve_wrapper:
  1591. execve_wrapper sys_execve
  1593. #ifdef __LP64__
  1594. .export sys32_execve_wrapper
  1595. .import sys32_execve
  1597. sys32_execve_wrapper:
  1598. execve_wrapper sys32_execve
  1599. #endif
  1601. .export sys_rt_sigreturn_wrapper
  1602. sys_rt_sigreturn_wrapper:
  1603. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30), %r26
  1604. /* Don't save regs, we are going to restore them from sigcontext. */
  1605. STREG %r2, -RP_OFFSET(%r30)
  1606. bl sys_rt_sigreturn,%r2
  1607. ldo FRAME_SIZE(%r30), %r30
  1609. ldo -FRAME_SIZE(%r30), %r30
  1610. LDREG -RP_OFFSET(%r30), %r2
  1612. /* FIXME: I think we need to restore a few more things here. */
  1613. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1     /* get pt regs */
  1614. reg_restore %r1
  1616. /* If the signal was received while the process was blocked on a
  1617.  * syscall, then r2 will take us to syscall_exit; otherwise r2 will
  1618.  * take us to syscall_exit_rfi and on to intr_return.
  1619.  */
  1620. bv %r0(%r2)
  1621. LDREG PT_GR28(%r1),%r28  /* reload original r28 for syscall_exit */
  1623. .export sys_sigaltstack_wrapper
  1624. sys_sigaltstack_wrapper:
  1625. /* Get the user stack pointer */
  1626. LDREG -TASK_SZ_ALGN-FRAME_SIZE+TASK_PT_GR30(%r30), %r24
  1627. STREG %r2, -RP_OFFSET(%r30)
  1628. bl do_sigaltstack,%r2
  1629. ldo FRAME_SIZE(%r30), %r30
  1631. ldo -FRAME_SIZE(%r30), %r30
  1632. LDREG -RP_OFFSET(%r30), %r2
  1633. bv %r0(%r2)
  1634. nop
  1636. .export sys_rt_sigsuspend_wrapper
  1637. sys_rt_sigsuspend_wrapper:
  1638. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30), %r24
  1639. reg_save %r24
  1641. STREG %r2, -RP_OFFSET(%r30)
  1642. bl sys_rt_sigsuspend,%r2
  1643. ldo FRAME_SIZE(%r30), %r30
  1645. ldo -FRAME_SIZE(%r30), %r30
  1646. LDREG -RP_OFFSET(%r30), %r2
  1648. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1
  1649. reg_restore %r1
  1651. bv %r0(%r2)
  1652. nop
  1654. .export syscall_exit
  1655. syscall_exit:
  1656. /* NOTE: HP-UX syscalls also come through here
  1657.    after hpux_syscall_exit fixes up return
  1658.    values. */
  1659. /* NOTE: Not all syscalls exit this way.  rt_sigreturn will exit
  1660.  * via syscall_exit_rfi if the signal was received while the process
  1661.  * was running.  All traced processes will probably exit via
  1662.  * syscall_exit_rfi in the future.
  1663.  */
  1665. /* save return value now */
  1667. STREG     %r28,TASK_PT_GR28-TASK_SZ_ALGN-FRAME_SIZE(%r30)
  1669. syscall_check_bh:
  1671. /* #ifdef NOTNOW */
  1672. /* Check for software interrupts */
  1674. .import irq_stat,data
  1676. ldil    L%irq_stat,%r19
  1677. ldo     R%irq_stat(%r19),%r19
  1678. LDIL_FIXUP(%r19)
  1680. #ifdef CONFIG_SMP
  1681. /* sched.h: int processor */
  1682. ldw     TASK_PROCESSOR-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r20 /* get cpu # */
  1683. #if (IRQSTAT_SZ == 32)
  1684. dep     %r20,26,27,%r20 /* shift left 5 bits */
  1685. #else
  1686. #error IRQSTAT_SZ changed, fix dep
  1687. #endif /* IRQSTAT_SZ */
  1688. add     %r19,%r20,%r19
  1689. #endif /* CONFIG_SMP */
  1691. ldw     IRQSTAT_SI_ACTIVE(%r19),%r20 /* hardirq.h: unsigned int */
  1692. ldw     IRQSTAT_SI_MASK(%r19),%r19 /* hardirq.h: unsigned int */
  1693. and     %r19,%r20,%r20
  1694. comib,<>,n 0,%r20,syscall_do_softirq /* forward */
  1695. /* #endif */
  1698. syscall_check_resched:
  1700. /* check for reschedule */
  1702. LDREG  TASK_NEED_RESCHED-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r19 /* long */
  1703. comib,<>,n 0,%r19,syscall_do_resched /* forward */
  1705. syscall_check_sig:
  1706. ldo     -TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1         /* get task ptr */
  1707. /* check for pending signals */
  1708. ldw     TASK_SIGPENDING(%r1),%r19
  1709. comib,<>,n 0,%r19,syscall_do_signal  /* forward */
  1711. syscall_restore:
  1712. /* disable interrupts while dicking with the kernel stack, */
  1713. /* or life can become unpleasant */
  1714. rsm PSW_SM_I, %r20
  1715. LDREG TASK_PTRACE(%r1), %r19 /* Are we being ptraced? */
  1716. bb,<,n %r19,31,syscall_restore_rfi
  1717. LDREG TASK_PT_GR20(%r1),%r19
  1718. mtctl %r19, %cr27
  1720. LDREG TASK_PT_GR2(%r1),%r2    /* restore user rp */
  1721. LDREG TASK_PT_GR21(%r1),%r21
  1722. LDREG TASK_PT_GR22(%r1),%r22
  1723. LDREG TASK_PT_GR23(%r1),%r23
  1724. LDREG TASK_PT_GR24(%r1),%r24
  1725. LDREG TASK_PT_GR25(%r1),%r25
  1726. LDREG TASK_PT_GR26(%r1),%r26
  1727. LDREG TASK_PT_GR27(%r1),%r27    /* restore user dp */
  1728. LDREG TASK_PT_GR28(%r1),%r28    /* syscall return value */
  1729. LDREG TASK_PT_GR29(%r1),%r29
  1730. LDREG TASK_PT_GR30(%r1),%r30    /* restore user sp */
  1731. LDREG TASK_PT_GR31(%r1),%r31    /* restore syscall rp */
  1732. ldo TASK_PT_FR31(%r1),%r19    /* reload fpregs */
  1733. rest_fp %r19
  1734. LDREG TASK_PT_SAR(%r1),%r19    /* restore SAR */
  1735. mtsar %r19
  1736. LDREG TASK_PT_GR19(%r1),%r19
  1738. mtctl %r1,%cr30    /* intrhandler okay. */
  1739. mfsp %sr3,%r1    /* Get users space id */
  1740. mtsp %r1,%sr4    /* Restore sr4 */
  1741. mtsp %r1,%sr5    /* Restore sr5 */
  1742. mtsp %r1,%sr6    /* Restore sr6 */
  1744. depi 3,31,2,%r31    /* ensure return to user mode. */
  1746. mtsm %r20    /* restore irq state  */
  1747. mfctl %cr27,%r20
  1749. /*
  1750.  * Due to a dependency in the tlb miss handlers on sr7, it
  1751.  * is essential that sr7 get set in the delay slot.
  1752.  */
  1754. #ifdef __LP64__
  1756. /* Note the be (and mtsp) is executed in narrow mode. This is OK
  1757.  * for 32 bit processes, but won't work once we support 64 bit
  1758.  * processes.
  1759.  */
  1761. rsm PSW_SM_W, %r0
  1762. be 0(%sr3,%r31)    /* return to user space */
  1763. mtsp %r1,%sr7    /* Restore sr7 */
  1764. #else
  1765. be 0(%sr3,%r31)    /* return to user space */
  1766. mtsp %r1,%sr7    /* Restore sr7 */
  1767. #endif
  1769. /* We have to return via an RFI, so that PSW T and R bits can be set
  1770.  * appropriately.
  1771.  * This sets up pt_regs so we can return via intr_restore, which is not
  1772.  * the most efficient way of doing things, but it works.
  1773.  */
  1774. syscall_restore_rfi:
  1775. ldo -1(%r0),%r2    /* Set recovery cntr to -1 */
  1776. mtctl %r2,%cr0    /*   for immediate trap */
  1777. copy %r0,%r2    /* Create a reasonable PSW */
  1778. /* XXX W bit??? */
  1779. depi -1,13,1,%r2
  1780. depi -1,28,1,%r2
  1781. depi -1,30,1,%r2
  1782. depi -1,31,1,%r2
  1783. bb,<,n %r19,15,set_rbit    /* PT_SINGLESTEP */
  1784. bb,>=,n %r19,14,set_nobit    /* PT_BLOCKSTEP, see ptrace.c */
  1785. set_tbit:
  1786. depi -1,7,1,%r2
  1787. b,n set_nobit
  1788. set_rbit:
  1789. depi -1,27,1,%r2
  1790. set_nobit:
  1791. STREG %r2,TASK_PT_PSW(%r1)
  1792. STREG %r1,TASK_PT_CR30(%r1)
  1793. mfsp %sr0,%r2
  1794. STREG %r2,TASK_PT_SR0(%r1)
  1795. mfsp %sr1,%r2
  1796. STREG %r2,TASK_PT_SR1(%r1)
  1797. mfsp %sr2,%r2
  1798. STREG %r2,TASK_PT_SR2(%r1)
  1799. mfsp %sr3,%r2
  1800. STREG %r2,TASK_PT_SR3(%r1)
  1801. STREG %r2,TASK_PT_SR4(%r1)
  1802. STREG %r2,TASK_PT_SR5(%r1)
  1803. STREG %r2,TASK_PT_SR6(%r1)
  1804. STREG %r2,TASK_PT_SR7(%r1)
  1805. STREG %r2,TASK_PT_IASQ0(%r1)
  1806. STREG %r2,TASK_PT_IASQ1(%r1)
  1807. LDREG TASK_PT_GR31(%r1),%r2
  1808. depi 3,31,2,%r2    /* ensure return to user mode. */
  1809. STREG %r2,TASK_PT_IAOQ0(%r1)
  1810. ldo 4(%r2),%r2
  1811. STREG %r2,TASK_PT_IAOQ1(%r1)
  1812. ldo TASK_REGS(%r1),%r25
  1813. reg_save %r25    /* Save r3 to r18 */
  1814. copy %r25,%r16
  1815. b intr_restore
  1816. nop
  1818. .import do_softirq,code
  1819. syscall_do_softirq:
  1820. bl      do_softirq,%r2
  1821. nop
  1822. b       syscall_check_resched
  1823. ssm     PSW_SM_I, %r0  /* do_softirq returns with I bit off */
  1825. .import schedule,code
  1826. syscall_do_resched:
  1827. bl schedule,%r2
  1828. nop
  1829. b       syscall_check_bh  /* if resched, we start over again */
  1830. nop
  1832. .import do_signal,code
  1833. syscall_do_signal:
  1834. /* Save callee-save registers (for sigcontext).
  1835.    FIXME: After this point the process structure should be
  1836.    consistent with all the relevant state of the process
  1837.    before the syscall.  We need to verify this. */
  1838. ldo TASK_REGS(%r1), %r25 /* struct pt_regs *regs */
  1839. reg_save %r25
  1841. ldi 1, %r24 /* unsigned long in_syscall */
  1843. bl do_signal,%r2
  1844. copy %r0, %r26 /* sigset_t *oldset = NULL */
  1846. ldo     -TASK_SZ_ALGN-FRAME_SIZE(%r30), %r1     /* reload task ptr */
  1847. ldo TASK_REGS(%r1), %r20 /* reload pt_regs */
  1848. reg_restore %r20
  1850. b,n     syscall_restore
  1852. #ifdef __LP64__
  1853. unimplemented_64bitirq:
  1854. ssm PSW_SM_Q+PSW_SM_I, %r0
  1855. /* indicate that we had an interrupt */
  1856. ldi 0x77, %r28
  1857. ldi 0x77, %r29
  1858. /* save interrupt registers in GRs for diagnosis */
  1859. mfctl %cr17, %r17
  1860. mfctl %cr18, %r18
  1861. mfctl %cr19, %r19
  1862. mfctl %cr20, %r20
  1863. mfctl %cr21, %r21
  1864. mfctl %cr22, %r22
  1865. b,n .
  1866. nop
  1867. #endif