home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / pub / users / Harry / Blitz / OSProject / p6 / Switch.s < prev    next >
Text File  |  2009-06-03  |  7KB  |  225 lines
  1. ! BLITZ OS - Switch.s
  2. !
  3. ! Harry Porter  -  12/07/03
  4. !                  03/24/09
  5. !
  6. ! The following functions are implemented in this file:
  7. !
  8.     .export    Switch
  9.     .export    ThreadStartUp
  10.     .export    GetOldUserPCFromSystemStack
  11.     .export    LoadPageTableRegs
  12.     .export SaveUserRegs
  13.     .export RestoreUserRegs
  14.     .export BecomeUserThread
  15. !
  16. ! The following functions are imported:
  17. !
  18.     .import    _P_Kernel_ThreadStartMain
  19.     .import    _P_Kernel_ThreadFinish
  20. !
  21.     .text
  22.  
  23.  
  24. ! 
  25. ! ===============  ThreadStartUp  ===============
  26. ! 
  27. ! external ThreadStartUp ()
  28. !
  29. ! This routine is where each Thread begins execution.  The Fork function
  30. ! will place the starting address of this routine into the Thread object
  31. ! so that Switch will "return" to this address, thereby making a jump to
  32. ! the first instruction of this routine.  This routine will initialize
  33. ! all registers needed by high-level KPL code (namely r12 & r14) and will
  34. ! then call the KPL function "ThreadStartMain".  ThreadStartMain will invoke
  35. ! the "main" function of the thread. ThreadStartMain  will never return.
  36. ! 
  37. ThreadStartUp:
  38.         mov    r0,r14                ! Clear the FP register
  39.         mov    r0,r12                ! Clear the Catch Stack pointer
  40.         call    _P_Kernel_ThreadStartMain    ! Call ThreadStartMain
  41. ThreadHang:    debug                    ! Should never reach this point
  42.         jmp    ThreadHang            ! .
  43.  
  44.  
  45.  
  46. ! 
  47. ! ===============  Switch  ===============
  48. ! 
  49. ! external Switch (prevThread, nextThread: ptr to Thread)
  50. !
  51. ! This routine is passed ptrs to 2 Thread objects.  Each Thread object
  52. ! contains a place to store the state of the machine.  This includes:
  53. !    r2-r14
  54. !    stackTop (r15)
  55. ! This routine switches the state from one thread to the next and returns.
  56. ! Of course it will be returning to a different invocation, since the thread
  57. ! will have been switched.
  58. !
  59. ! This routine trashes r1.
  60. ! 
  61. Switch:
  62.         load    [r15+4],r1        ! Move the prevThread into r1
  63.         add    r1,16,r1        ! Make r1 point to r1.regs
  64.         store    r2,[r1+0]        ! Save r2..r14 in r1.regs
  65.         store    r3,[r1+4]        ! .
  66.         store    r4,[r1+8]        ! .
  67.         store    r5,[r1+12]        ! .
  68.         store    r6,[r1+16]        ! .
  69.         store    r7,[r1+20]        ! .
  70.         store    r8,[r1+24]        ! .
  71.         store    r9,[r1+28]        ! .
  72.         store    r10,[r1+32]        ! .
  73.         store    r11,[r1+36]        ! .
  74.         store    r12,[r1+40]        ! .
  75.         store    r13,[r1+44]        ! .
  76.         store    r14,[r1+48]        ! .
  77.         store    r15,[r1+52]        ! Save r15 in r1.stackTop
  78.  
  79.         load    [r15+8],r1        ! Move the nextThread into r1
  80.         add    r1,16,r1        ! Make r1 point to r1.regs
  81.         load    [r1+0],r2        ! Restore r2..r14 from r1.regs
  82.         load    [r1+4],r3        ! .
  83.         load    [r1+8],r4        ! .
  84.         load    [r1+12],r5        ! .
  85.         load    [r1+16],r6        ! .
  86.         load    [r1+20],r7        ! .
  87.         load    [r1+24],r8        ! .
  88.         load    [r1+28],r9        ! .
  89.         load    [r1+32],r10        ! .
  90.         load    [r1+36],r11        ! .
  91.         load    [r1+40],r12        ! .
  92.         load    [r1+44],r13        ! .
  93.         load    [r1+48],r14        ! .
  94.         load    [r1+52],r15        ! Restore r15 from r1.stackTop
  95.         ret
  96.  
  97.  
  98.  
  99. ! 
  100. ! ===============  GetOldUserPCFromSystemStack  ===============
  101. ! 
  102. ! external GetOldUserPCFromSystemStack () returns int
  103. !
  104. ! This routine is called by the kernel after a syscall has occurred.  It expects
  105. ! the assembly SyscallTrapHandler to have called the high-level SyscallTrapHandler,
  106. ! which then called Handle_Sys_Fork.  It expects to be called from Handle_Sys_Fork,
  107. ! and will not work properly otherwise.
  108. !
  109. ! This routine looks down into stuff buried in the system stack and finds the
  110. ! exception block that was pushed onto the stack at the time of the syscall.
  111. ! From that, it retrieves the user-mode PC, which points to the instruction
  112. ! the kernel must return to after the syscall.
  113. ! 
  114. GetOldUserPCFromSystemStack:
  115.         load    [r14],r1        ! r1 = ptr to frame of SyscallTrapHandler
  116.         load    [r1+28],r1        ! r1 = pc from interrupt block
  117.         store    r1,[r15+4]
  118.         ret
  119.  
  120.  
  121.  
  122. ! 
  123. ! =====================  LoadPageTableRegs  =====================
  124. ! 
  125. ! external LoadPageTableRegs (ptbr, ptlr: int)
  126. !
  127. ! This routine will load the Page Table Base Register (PTBR) and the
  128. ! Page Table Length Register (PTLR).
  129. ! 
  130. LoadPageTableRegs:
  131.         load    [r15+4],r1    ! Get arg1
  132.         ldptbr    r1        ! Move it to PTBR
  133.         load    [r15+8],r1    ! Get arg2
  134.         ldptlr    r1        ! Move it to PTLR
  135.         ret            ! return
  136.  
  137.  
  138.  
  139. ! 
  140. ! =====================  SaveUserRegs  =====================
  141. ! 
  142. ! external SaveUserRegs (ptr to int)
  143. !
  144. ! This routine is passed a pointer to a block of memory.  It is called
  145. ! while in System Mode.  It copies the user registers to the block of memory.
  146. !
  147. SaveUserRegs:
  148.         load    [r15+4],r1        ! Move ptr to memory into r1
  149.         readu    r1,[r1+0]        ! Copy user registers to memory
  150.         readu    r2,[r1+4]        ! .
  151.         readu    r3,[r1+8]        ! .
  152.         readu    r4,[r1+12]        ! .
  153.         readu    r5,[r1+16]        ! .
  154.         readu    r6,[r1+20]        ! .
  155.         readu    r7,[r1+24]        ! .
  156.         readu    r8,[r1+28]        ! .
  157.         readu    r9,[r1+32]        ! .
  158.         readu    r10,[r1+36]        ! .
  159.         readu    r11,[r1+40]        ! .
  160.         readu    r12,[r1+44]        ! .
  161.         readu    r13,[r1+48]        ! .
  162.         readu    r14,[r1+52]        ! .
  163.         readu    r15,[r1+56]        ! .
  164.         ret                ! Return
  165.  
  166.  
  167.  
  168. ! 
  169. ! =====================  RestoreUserRegs  =====================
  170. ! 
  171. ! external RestoreUserRegs (ptr to int)
  172. !
  173. ! This routine is passed a pointer to a block of memory.  It is called
  174. ! while in System Mode.  It copies data from memory into the user registers.
  175. !
  176. RestoreUserRegs:
  177.         load    [r15+4],r1        ! Move ptr to memory into r1
  178.         writeu    [r1+0],r1        ! Copy data to user registers
  179.         writeu    [r1+4],r2        ! .
  180.         writeu    [r1+8],r3        ! .
  181.         writeu    [r1+12],r4        ! .
  182.         writeu    [r1+16],r5        ! .
  183.         writeu    [r1+20],r6        ! .
  184.         writeu    [r1+24],r7        ! .
  185.         writeu    [r1+28],r8        ! .
  186.         writeu    [r1+32],r9        ! .
  187.         writeu    [r1+36],r10        ! .
  188.         writeu    [r1+40],r11        ! .
  189.         writeu    [r1+44],r12        ! .
  190.         writeu    [r1+48],r13        ! .
  191.         writeu    [r1+52],r14        ! .
  192.         writeu    [r1+56],r15        ! .
  193.         ret                ! Return
  194.  
  195.  
  196.  
  197. ! 
  198. ! =====================  BecomeUserThread  =====================
  199. ! 
  200. ! external BecomeUserThread (initStack, initPC, initSystemStack: int)
  201. !
  202. ! This routine changes the mode from system-mode to user-mode.  It
  203. ! also enables interrupts and paging.  It is passed the initial value
  204. ! for the user stack and the initial address to branch to.  The user
  205. ! thread will never "return" (it must execute something like
  206. ! Syscall_Exit).  However, the user thread will execute syscalls from
  207. ! time to time.  Thus, the system stack as it exists now will be pushed
  208. ! onto when ever this thread does a syscall.
  209. !
  210. ! Note that 0x00000020 is a StatusRegister (interrupts, user mode, paging off).
  211. ! Note that 0x00000028 is a StatusRegister (interrupts, user mode, paging on).
  212. !
  213. BecomeUserThread:
  214.         load    [r15+4],r3        ! r3 := initStack
  215.         writeu    r3,r15            ! Store stack-ptr in user reg r15
  216.         load    [r15+8],r2        ! Move initPC into r2
  217.         load    [r15+12],r15        ! Move initSystemStack into r15
  218.         push    r0            ! Push a fake interrupt block
  219.         mov    0x00000028,r4        ! .  onto the system stack
  220.         push    r4            ! .
  221.         push    r2            ! .
  222.         clr    r1            ! Set user reg r1 to zero
  223.         writeu    r1,r1            ! .
  224.         reti                ! "return" from interrupt
  225.