# 2.11BSD#431 - /usr/src/sys/pdp/net_SKcall.s

##### Functions

    Sretu             X
    _SKcall           X

       1: /*
       2:  * Copyright (c) 1988 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  *
       6:  *	@(#)net_SKcall.s	1.1 (2.10BSD Berkeley) 4/3/88
       7:  */
       8:
       9: #include "DEFS.h"
      10: #include "../machine/mch_iopage.h"
      11: /*
      12:  * Inter-address-space procedure call subroutines.
      13:  *	SKcall -- supervisor to kernel
      14:  */
      15:
      16: /*
      17:  * SKcall(func, nbytes, a1, ..., aN)
      18:  *
      19:  * C-call from supervisor to kernel.
      20:  * Calls func(a1, ..., aN) in kernel mode.
      21:  */
      22: ENTRY(SKcall)
      23:         mov     r5,-(sp)
      24:         mov     PS,-(sp)        / Save current PS
      25:         mov     010(sp),r0      / r0: # bytes of arguments to copy
      26:
      27:         /*
      28: 	 * Allocate enough space on the kernel stack to hold
      29: 	 * the call frame.  We must allocate space to hold all the
      30: 	 * arguments, plus:
      31: 	 *	a PS, PC pair to take us to the function being called
      32: 	 *	    in kernel space.
      33: 	 *	a return address (Kretu)
      34: 	 *	a null R5 entry as a marker
      35: 	 *	a PS, PC pair to take us back to supervisor mode.
      36: 	 *
      37: 	 * We assume that if the kernel stack pointer is pointing to
      38: 	 * an address before the start of seg6, the kernel stack has
      39: 	 * been remapped and we must use mtpd instructions instead
      40: 	 * of simple mov's.
      41: 	 *
      42: 	 *			WARNING:
      43: 	 *			=======
      44: 	 *
      45: 	 * The reason we use mtpd is to guarantee that we write into
      46: 	 * the kernel stack.  However, when the kernel stack is remapped
      47: 	 * to point outside of seg 6, there may not be enough room for
      48: 	 * storing the arguments in the new stack.  There is currently no
      49: 	 * check made here to prevent overflowing this remapped stack.
      50: 	 */
      51:
      52:         mov     $040340,PS      / Current SUPV, prev KERN, spl7 (paranoia)
      53:         mfpd    sp              / Kernel stack pointer
      54:         mov     (sp),r1         / Pointer to base of new call frame
      55:         sub     r0,(sp)
      56:         sub     $12.,(sp)       / New SP.
      57:         mtpd    sp              / Set up alternate stack ptr
      58:
      59:         cmp     r1,$_u          / Is kernel SP pointing in seg6?
      60:         bhi     skmov           / Yes: OK to use normal mov instructions
      61:         jmp     skmtpd          / No: must use mtpd instead
      62:
      63: skmov:
      64:         mov     (sp),PS         / Restore original PS
      65:         mov     (sp)+,-(r1)     / Transfer saved PS to alternate stack
      66:         mov     $ret,-(r1)      / Will return to ret below
      67:         mov     r5,-(r1)        / Old frame ptr
      68:         mov     r1,r5           / New frame ptr for other mode
      69:
      70:         /*
      71: 	 * Copy arguments.
      72: 	 * Note that the stack offsets here are the same as they
      73: 	 * were right after we saved the PS.
      74: 	 */
      75:
      76:         mov     r2,-(sp)        / Save
      77:         mov     r0,r2           / r2: number of bytes of arguments to copy
      78:         beq     2f              / None to copy? if so, skip loop
      79:         asr     r2              / r2: number of words of arguments to copy
      80:         add     sp,r0
      81:         add     $10.,r0         / r0: ptr to argN+1
      82: 1:
      83:         mov     -(r0),-(r1)
      84:         sob     r2,1b
      85: 2:
      86:         mov     (sp)+,r2        / Restore
      87:
      88:         /*
      89: 	 * Build the rest of the kernel stack frame.
      90: 	 * This consists of a normal return address (Kretu) to which
      91: 	 * the kernel function will return, and a <PS, PC> pair used
      92: 	 * by Kretu to get back here to supervisor mode.
      93: 	 */
      94:
      95:         mov     $Kretu,-(r1)    / Address of RTT-er in kernel mode
      96:         mov     $30000,-(r1)    / New PS mode: (current KERN, prev USER)
      97:         bisb    PS,(r1)         / New PS priority
      98:         mov     04(sp),-(r1)    / Stack address of function to be called
      99:
     100: skcall:
     101:         /*
     102: 	 * At this point, the stacks look like the following:
     103: 	 *
     104: 	 *	SUPERVISOR		KERNEL
     105: 	 *	----------		------
     106: 	 *SSP->	<R5>			<KERN func address>	<-KSP
     107: 	 *	<caller's rtnaddr>	<KERN PS>
     108: 	 *	<KERN func address>	<Kretu>
     109: 	 *	<# bytes of args>	<arg0>
     110: 	 *	<arg0>			 ...
     111: 	 *	 ...			<argN>
     112: 	 *	<argN>			 <0>
     113: 	 *				<ret in SUPV space>
     114: 	 *				<PS for SUPV mode>
     115: 	 *
     116: 	 * "<KERN func address>" is the address in kernel address
     117: 	 * space of the function being called.
     118: 	 */
     119:
     120:         iot
     121:
     122:         /*
     123: 	 * Return to caller of SKcall.
     124: 	 * We arrive here with the PS being the same as it was on
     125: 	 * calling SKcall, via a "rtt" from Kretu in kernel mode.
     126: 	 */
     127: ret:
     128:         mov     (sp)+,r5
     129:         rts     pc
     130:
     131:         /*
     132: 	 * The kernel stack has been repointed.
     133: 	 * Use mtpd to set up the kernel stack for the call.
     134: 	 *
     135: 	 * We expect that r1 contains the address in kernel space
     136: 	 * of the base of the call frame we are about to build.
     137: 	 * The word on the top of the stack is the original PS.
     138: 	 */
     139:
     140: skmtpd:
     141:         mov     (sp),PS         / Restore original PS (mainly for priority)
     142:         bic     $30000,PS       / Previous mode is kernel
     143:         mtpd    -(r1)           / Transfer saved PS to alternate stack
     144:         mov     $ret,-(sp)      / Will return to ret below
     145:         mtpd    -(r1)
     146:         mov     r5,-(sp)        / Old frame ptr
     147:         mtpd    -(r1)
     148:         mov     r1,r5           / New frame ptr for other mode
     149:
     150:         /*
     151: 	 * Copy arguments.
     152: 	 * Note that the stack offsets here are the same as they
     153: 	 * were right after we saved the PS.
     154: 	 */
     155:
     156:         mov     r2,-(sp)        / Save
     157:         mov     r0,r2           / r2: number of bytes of arguments to copy
     158:         beq     2f              / None to copy? if so, skip loop
     159:         asr     r2              / r2: number of words of arguments to copy
     160:         add     sp,r0
     161:         add     $10.,r0         / r0: ptr to argN+1
     162: 1:
     163:         mov     -(r0),-(sp)
     164:         mtpd    -(r1)
     165:         sob     r2,1b
     166: 2:
     167:         mov     (sp)+,r2        / Restore
     168:
     169:         /*
     170: 	 * Build the rest of the kernel stack frame.
     171: 	 * This consists of a normal return address (Kretu) to which
     172: 	 * the kernel function will return, and a <PS, PC> pair used
     173: 	 * by Kretu to get back here to supervisor mode.
     174: 	 */
     175:
     176:         mov     $Kretu,-(sp)    / Address of RTT-er in kernel mode
     177:         mtpd    -(r1)
     178:         mov     $010000,-(sp)   / New PS mode: (current KERN, prev SUPV)
     179:         bisb    PS,(sp)         / New PS priority
     180:         mtpd    -(r1)
     181:         mov     04(sp),-(sp)    / Stack address of function to be called
     182:         mtpd    -(r1)
     183:         jmp     skcall          / Back to complete the call
     184:
     185:
     186: /*
     187:  * Sretu is the exit point in supervisor code that cleans up
     188:  * the supervisor stack for return to kernel mode from a
     189:  * kernel-to-net procedure call.
     190:  *
     191:  * We can't use rtt here, so instead we use the a "iot"
     192:  * in just the same way as we would use to "call" something
     193:  * in the kernel.
     194:  */
     195: ASENTRY(Sretu)
     196:         mov     r5,sp           / Base of frame area
     197:         tst     (sp)+           / Throw away old frame pointer
     198:         /*
     199: 	 * At this point, the stacks look like the following:
     200: 	 *
     201: 	 *	KERNEL			SUPERVISOR
     202: 	 *	------			----------
     203: 	 *				<_Sretu>
     204: 	 *				<arg0>
     205: 	 *KSP->	<ret in KERN space>	 ...
     206: 	 *	<R5>			<argN>
     207: 	 *	<caller's rtnaddr>	 <0>
     208: 	 *	<SUPV func address>	<old stack top>	<-SSP
     209: 	 *	<# bytes of args>
     210: 	 *	<arg0>
     211: 	 *	 ...
     212: 	 *	<argN>
     213: 	 */
     214:         iot

#### Defined functions

Sretu defined in line 195; used 1 times

- in /usr/src/sys/pdp/mch_KScall.s line 96

_SKcall defined in line 22; used 28 times

- in /usr/src/sys/pdp/net_mac.h line 15, 24-39(4), 56-68(4), 80-88(3), 182-199(5), 205, 211-219(3)
- in /usr/src/sys/pdpif/if_qe.c line 254
- in /usr/src/sys/pdpif/if_qt.c line 211
- in /usr/src/sys/sys/sys_net.c line 509
- in /usr/src/sys/sys/uipc_usrreq.c line 514, 539, 566, 652

ret defined in line 127; used 2 times

- in line 66, 144

skcall defined in line 100; used 1 times

- in line 183

skmov defined in line 63; used 1 times

- in line 60

skmtpd defined in line 140; used 1 times

- in line 61

Last modified: 1988-05-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 614 |