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