; $Id: VBoxSFA.asm 4377 2007-08-27 08:45:40Z vboxsync $ ;; @file ; VBoxSF - OS/2 Shared Folders, all assembly code (16 -> 32 thunking mostly). ; ; ; Copyright (c) 2007 knut st. osmundsen ; ; Permission is hereby granted, free of charge, to any person ; obtaining a copy of this software and associated documentation ; files (the "Software"), to deal in the Software without ; restriction, including without limitation the rights to use, ; copy, modify, merge, publish, distribute, sublicense, and/or sell ; copies of the Software, and to permit persons to whom the ; Software is furnished to do so, subject to the following ; conditions: ; ; The above copyright notice and this permission notice shall be ; included in all copies or substantial portions of the Software. ; ; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES ; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ; OTHER DEALINGS IN THE SOFTWARE. ; ;******************************************************************************* ;* Header Files * ;******************************************************************************* %define RT_INCL_16BIT_SEGMENTS %include "iprt/asmdefs.mac" %include "iprt/err.mac" %include "VBox/VBoxGuest.mac" ;******************************************************************************* ;* Defined Constants And Macros * ;******************************************************************************* %define ERROR_NOT_SUPPORTED 50 %define ERROR_INVALID_PARAMETER 87 %define DevHlp_AttachDD 2ah ;; ; Prints a string to the VBox log port. %macro DEBUG_STR16 1 %ifdef DEBUG segment DATA16 %%my_dbg_str: db %1, 0ah, 0 segment CODE16 push ax mov ax, %%my_dbg_str call NAME(dbgstr16) pop ax %endif %endmacro %macro VBOXSF_EP16_BEGIN 2 global %1 %1: DEBUG_STR16 {'VBoxSF: ', %2} %endmacro %macro VBOXSF_EP16_END 1 global %1_EndProc %1_EndProc: %endmacro ;; ; Used to taking us to 32-bit and reserving a parameter frame. ; ; @param %1 The function name ; @param %2 The number of bytes to reserve ; %macro VBOXSF_TO_32 2 ; prologue push ebp mov ebp, esp ; bp push ds ; bp - 2 push es ; bp - 4 ; Reserve the 32-bit parameter and align the stack on a 16 byte ; boundrary to make GCC really happy. sub sp, %2 and sp, 0fff0h ;jmp far dword NAME(%i %+ _32) wrt FLAT db 066h db 0eah dd NAME(%1 %+ _32) ;wrt FLAT dw TEXT32 wrt FLAT segment TEXT32 GLOBALNAME %1 %+ _32 mov ax, DATA32 wrt FLAT mov ds, ax mov es, ax call KernThunkStackTo32 %endmacro VBOXSF_TO_32 1 ;; ; The counter part to VBOXSF_TO_32 ; ; @param %1 The function name ; %macro VBOXSF_TO_16 1 push eax call KernThunkStackTo16 pop eax ;jmp far dword NAME(%1 %+ _16) wrt CODE16 db 066h db 0eah dw NAME(%1 %+ _16) wrt CODE16 dw CODE16 segment CODE16 GLOBALNAME %1 %+ _16 ; Epilogue lea sp, [bp - 4h] pop es pop ds mov esp, ebp pop ebp %endmacro ;; ; Thunks the given 16:16 pointer to a flat pointer. ; ; @param %1 The negated ebp offset of the input. ; @param %2 The esp offset of the output. ; @users eax, edx, ecx ; %macro VBOXSF_FARPTR_2_FLAT 2 movzx eax, word [ebp - (%1) + 2] push eax call KernSelToFlat movzx edx, word [ebp - (%1)] add eax, edx mov [esp + (%2)], eax %endmacro ;; ; Thunks the given 16:16 struct sffsd pointer to a flat pointer. ; ; @param %1 The negated ebp offset of the input. ; @param %2 The esp offset of the output. ; @users eax, ecx ; %macro VBOXSF_PSFFSD_2_FLAT 2 lds cx, [ebp - (%1)] and ecx, 0ffffh mov eax, dword [ecx] mov cx, DATA32 wrt FLAT mov [esp + (%2)], eax mov ds, cx %endmacro ;; ; Thunks the given 16:16 struct cdfsd pointer to a flat pointer. ; ; @param %1 The negated ebp offset of the input. ; @param %2 The esp offset of the output. ; @users eax, ecx ; %macro VBOXSF_PCDFSD_2_FLAT 2 lds cx, [ebp - (%1)] and ecx, 0ffffh mov eax, dword [ecx] mov cx, DATA32 wrt FLAT mov [esp + (%2)], eax mov ds, cx %endmacro ;; ; Thunks the given 16:16 struct fsfsd pointer to a flat pointer. ; ; @param %1 The negated ebp offset of the input. ; @param %2 The esp offset of the output. ; @users eax, ecx ; %macro VBOXSF_PFSFSD_2_FLAT 2 lds cx, [ebp - (%1)] and ecx, 0ffffh mov eax, dword [ecx] mov cx, DATA32 wrt FLAT mov [esp + (%2)], eax mov ds, cx %endmacro ;******************************************************************************* ;* External Symbols * ;******************************************************************************* segment CODE32 extern KernThunkStackTo32 extern KernThunkStackTo16 extern KernSelToFlat segment CODE16 extern FSH_FORCENOSWAP extern DOS16WRITE segment CODE32 extern NAME(FS32_ALLOCATEPAGESPACE) extern NAME(FS32_ATTACH) extern NAME(FS32_CANCELLOCKREQUEST) extern NAME(FS32_CANCELLOCKREQUESTL) extern NAME(FS32_CHDIR) extern FS32_CHGFILEPTRL extern NAME(FS32_CLOSE) extern NAME(FS32_COMMIT) extern NAME(FS32_COPY) extern NAME(FS32_DELETE) extern NAME(FS32_DOPAGEIO) extern NAME(FS32_EXIT) extern NAME(FS32_FILEATTRIBUTE) extern NAME(FS32_FILEINFO) extern NAME(FS32_FILEIO) extern NAME(FS32_FILELOCKS) extern NAME(FS32_FILELOCKSL) extern NAME(FS32_FINDCLOSE) extern NAME(FS32_FINDFIRST) extern NAME(FS32_FINDFROMNAME) extern NAME(FS32_FINDNEXT) extern NAME(FS32_FINDNOTIFYCLOSE) extern NAME(FS32_FINDNOTIFYFIRST) extern NAME(FS32_FINDNOTIFYNEXT) extern NAME(FS32_FLUSHBUF) extern NAME(FS32_FSCTL) extern NAME(FS32_FSINFO) extern NAME(FS32_IOCTL) extern NAME(FS32_MKDIR) extern NAME(FS32_MOUNT) extern NAME(FS32_MOVE) extern NAME(FS32_NEWSIZEL) extern NAME(FS32_NMPIPE) extern NAME(FS32_OPENCREATE) extern NAME(FS32_OPENPAGEFILE) extern NAME(FS32_PATHINFO) extern NAME(FS32_PROCESSNAME) extern FS32_READ extern NAME(FS32_RMDIR) extern NAME(FS32_SETSWAP) extern NAME(FS32_SHUTDOWN) extern FS32_WRITE extern NAME(VBoxSFR0Init) ;******************************************************************************* ;* Global Variables * ;******************************************************************************* segment DATA16 ;; ; The file system name. global FS_NAME FS_NAME: db 'VBOXSF',0 ;; ; File system attributes ; The 32-bit version is only used to indicate that this is a 32-bit file system. ; %define FSA_REMOTE 0001h ; remote file system. %define FSA_UNC 0002h ; implements UNC. %define FSA_LOCK 0004h ; needs lock notification. %define FSA_LVL7 0008h ; accept level 7 (case perserving path request). %define FSA_PSVR 0010h ; (named) pipe server. %define FSA_LARGEFILE 0020h ; large file support. align 16 global FS_ATTRIBUTE global FS32_ATTRIBUTE FS_ATTRIBUTE: FS32_ATTRIBUTE: dd FSA_REMOTE + FSA_LARGEFILE ;+ FSA_LVL7 + FSA_LOCK ;; 64-bit mask. ; bit 0 - don't get the ring-0 spinlock. ; bit 6 - don't get the subsystem ring-0 spinlock. global FS_MPSAFEFLAGS2 FS_MPSAFEFLAGS2: dd 0 dd 0 ;; ; Set after VBoxSFR0Init16Bit has been called. GLOBALNAME g_fDoneRing0 db 0 align 4 ;; ; The device helper (IPRT expects this name). ; (This is set by FS_INIT.) GLOBALNAME g_fpfnDevHlp dd 0 ;; ; Whether initialization should be verbose or quiet. GLOBALNAME g_fVerbose db 1 ;; DEBUGGING DEBUGGING GLOBALNAME g_u32Info dd 0 ;; Far pointer to DOS16WRITE (corrected set before called). ; Just a 'temporary' hack to work around a wlink/nasm issue. GLOBALNAME g_fpfnDos16Write dw DOS16WRITE dw seg DOS16WRITE ;; ; The attach dd data. GLOBALNAME g_VBoxGuestAttachDD dd 0 dw 0 dd 0 dw 0 ;; ; The AttachDD name of the VBoxGuest.sys driver. GLOBALNAME g_szVBoxGuestName db VBOXGUEST_DEVICE_NAME, 0 ;; ; The VBoxGuest IDC connection data. GLOBALNAME g_VBoxGuestIDC times VBGOS2IDC_size db 0 ;; ; This must be present, we've got fixups against it. segment DATA32 g_pfnDos16Write: dd DOS16WRITE ; flat ; ; ; 16-bit entry point thunking. ; 16-bit entry point thunking. ; 16-bit entry point thunking. ; ; segment CODE16 ;; ; @cproto int FS_ALLOCATEPAGESPACE(PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG cb, USHORT cbWantContig) VBOXSF_EP16_BEGIN FS_ALLOCATEPAGESPACE, 'FS_ALLOCATEPAGESPACE' VBOXSF_TO_32 FS_ALLOCATEPAGESPACE, 4*4 movzx ecx, word [ebp + 08h] ; cbWantContig mov [esp + 3*4], ecx mov edx, [ebp + 0ah] ; cb mov [esp + 2*4], edx VBOXSF_PSFFSD_2_FLAT 0eh, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 12h, 0*4 ; psffsi call NAME(FS32_ALLOCATEPAGESPACE) VBOXSF_TO_16 FS_ALLOCATEPAGESPACE retf 0eh VBOXSF_EP16_END FS_ALLOCATEPAGESPACE ;; ; @cproto int FS_ATTACH(USHORT flag, PCSZ pszDev, PVPFSD pvpfsd, PCDFSD pcdfsd, PBYTE pszParm, PUSHORT pcbParm) ; VBOXSF_EP16_BEGIN FS_ATTACH, 'FS_ATTACH' ; ; Initialized ring-0 yet? (this is a likely first entry point) ; push ds mov ax, DATA16 mov ds, ax test byte [NAME(g_fDoneRing0)], 1 jnz .DoneRing0 call NAME(VBoxSFR0Init16Bit) .DoneRing0: pop ds VBOXSF_TO_32 FS_ATTACH, 6*4 VBOXSF_FARPTR_2_FLAT 08h, 5*4 ; pcbParm VBOXSF_FARPTR_2_FLAT 0ch, 4*4 ; pszParm VBOXSF_FARPTR_2_FLAT 10h, 3*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 14h, 2*4 ; pvpfsd VBOXSF_FARPTR_2_FLAT 18h, 1*4 ; pszDev movzx ecx, word [ebp + 1ch] ; fFlag mov [esp], ecx call NAME(FS32_ATTACH) VBOXSF_TO_16 FS_ATTACH retf 16h VBOXSF_EP16_END FS_ATTACH ;; ; @cproto int FS_CANCELLOCKREQUEST(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelock far *pLockRange) VBOXSF_EP16_BEGIN FS_CANCELLOCKREQUEST, 'FS_CANCELLOCKREQUEST' VBOXSF_TO_32 FS_CANCELLOCKREQUEST, 3*4 VBOXSF_FARPTR_2_FLAT 08h, 2*4 ; pLockRange VBOXSF_PSFFSD_2_FLAT 0ch, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 10h, 0*4 ; psffsi call NAME(FS32_CANCELLOCKREQUEST) VBOXSF_TO_16 FS_CANCELLOCKREQUEST retf 0ch VBOXSF_EP16_END FS_CANCELLOCKREQUEST ;; ; @cproto int FS_CANCELLOCKREQUESTL(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelockl far *pLockRange) VBOXSF_EP16_BEGIN FS_CANCELLOCKREQUESTL, 'FS_CANCELLOCKREQUESTL' VBOXSF_TO_32 FS_CANCELLOCKREQUESTL, 3*4 VBOXSF_FARPTR_2_FLAT 08h, 2*4 ; pLockRange VBOXSF_PSFFSD_2_FLAT 0ch, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 10h, 0*4 ; psffsi call NAME(FS32_CANCELLOCKREQUESTL) VBOXSF_TO_16 FS_CANCELLOCKREQUESTL retf 0ch VBOXSF_EP16_END FS_CANCELLOCKREQUESTL ;; ; @cproto int FS_CHDIR(USHORT flag, PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszDir, USHORT iCurDirEnd) VBOXSF_EP16_BEGIN FS_CHDIR, 'FS_CHDIR' VBOXSF_TO_32 FS_CHDIR, 5*4 movzx ecx, word [ebp + 08h] ; iCurDirEnd mov [esp + 4*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 3*4 ; pszDir VBOXSF_FARPTR_2_FLAT 0eh, 2*4 ; pcdfsd (use slow thunk here, see flag) VBOXSF_FARPTR_2_FLAT 12h, 1*4 ; pcdfsi movzx eax, word [ebp + 16h] ; flag mov [esp], eax call NAME(FS32_CHDIR) VBOXSF_TO_16 FS_CHDIR retf 10h VBOXSF_EP16_END FS_CHDIR ; @cproto int FS_CHGFILEPTR(PSFFSI psffsi, PVBOXSFFSD psffsd, LONG off, USHORT usMethod, USHORT IOflag) VBOXSF_EP16_BEGIN FS_CHGFILEPTR, 'FS_CHGFILEPTR' VBOXSF_TO_32 FS_CHGFILEPTR, 6*4 movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 5*4], ecx movzx edx, word [ebp + 0ah] ; usMethod mov [esp + 4*4], edx mov eax, [ebp + 0ch] ; off mov [esp + 2*4], eax rol eax, 1 ; high dword - is there a better way than this? and eax, 1 mov edx, 0ffffffffh mul edx mov [esp + 3*4], eax VBOXSF_PSFFSD_2_FLAT 10h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 14h, 0*4 ; psffsi call FS32_CHGFILEPTRL VBOXSF_TO_16 FS_CHGFILEPTR retf 10h VBOXSF_EP16_END FS_CHGFILEPTR ;; ; @cproto int FS_CLOSE(USHORT type, USHORT IOflag, PSFFSI psffsi, PVBOXSFFSD psffsd) ; VBOXSF_EP16_BEGIN FS_CLOSE, 'FS_CLOSE' VBOXSF_TO_32 FS_CLOSE, 4*4 VBOXSF_PSFFSD_2_FLAT 08h, 3*4 ; psffsd VBOXSF_FARPTR_2_FLAT 0ch, 2*4 ; psffsi movzx ecx, word [ebp + 10h] ; IOflag mov [esp + 1*4], ecx movzx edx, word [ebp + 12h] ; type mov [esp], edx call NAME(FS32_CLOSE) VBOXSF_TO_16 FS_CLOSE retf 0ch VBOXSF_EP16_END FS_CLOSE ;; ; @cproto int FS_COMMIT(USHORT type, USHORT IOflag, PSFFSI psffsi, PVBOXSFFSD psffsd) ; VBOXSF_EP16_BEGIN FS_COMMIT, 'FS_COMMIT' VBOXSF_TO_32 FS_COMMIT, 4*4 VBOXSF_PSFFSD_2_FLAT 08h, 3*4 ; psffsd VBOXSF_FARPTR_2_FLAT 0ch, 2*4 ; psffsi movzx ecx, word [ebp + 10h] ; IOflag mov [esp + 1*4], ecx movzx edx, word [ebp + 12h] ; type mov [esp], edx call NAME(FS32_COMMIT) VBOXSF_TO_16 FS_COMMIT retf 0ch VBOXSF_EP16_END FS_COMMIT ;; ; @cproto int FS_COPY(USHORT flag, PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszSrc, USHORT iSrcCurDirEnd ; PCSZ pszDst, USHORT iDstCurDirEnd, USHORT nameType); VBOXSF_EP16_BEGIN FS_COPY, 'FS_COPY' VBOXSF_TO_32 FS_COPY, 8*4 movzx ecx, word [ebp + 08h] ; flag mov [esp + 7*4], ecx movzx edx, word [ebp + 0ah] ; iDstCurDirEnd mov [esp + 6*4], edx VBOXSF_FARPTR_2_FLAT 0ch, 5*4 ; pszDst movzx eax, word [ebp + 10h] ; iSrcCurDirEnd mov [esp + 4*4], eax VBOXSF_FARPTR_2_FLAT 12h, 3*4 ; pszSrc VBOXSF_PCDFSD_2_FLAT 16h, 2*4 ; psffsd VBOXSF_FARPTR_2_FLAT 1ah, 1*4 ; psffsi movzx ecx, word [ebp + 1eh] ; flag mov [esp], ecx call NAME(FS32_COPY) VBOXSF_TO_16 FS_COPY retf 18h VBOXSF_EP16_END FS_COPY ;; ; @cproto int FS_DELETE(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszFile, USHORT iCurDirEnd); VBOXSF_EP16_BEGIN FS_DELETE, 'FS_DELETE' VBOXSF_TO_32 FS_DELETE, 4*4 movzx ecx, word [ebp + 08h] ; iCurDirEnd mov [esp + 3*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 2*4 ; pszFile VBOXSF_PCDFSD_2_FLAT 0eh, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 12h, 0*4 ; pcdfsi call NAME(FS32_DELETE) VBOXSF_TO_16 FS_DELETE retf 0eh VBOXSF_EP16_END FS_DELETE ;; ; @cproto int FS_DOPAGEIO(PSFFSI psffsi, PVBOXSFFSD psffsd, struct PageCmdHeader far *pList) VBOXSF_EP16_BEGIN FS_DOPAGEIO, 'FS_DOPAGEIO' VBOXSF_TO_32 FS_DOPAGEIO, 3*4 VBOXSF_FARPTR_2_FLAT 08h, 2*4 ; pList VBOXSF_PSFFSD_2_FLAT 0ch, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 10h, 0*4 ; psffsi call NAME(FS32_DOPAGEIO) VBOXSF_TO_16 FS_DOPAGEIO retf 0ch VBOXSF_EP16_END FS_DOPAGEIO ;; ; @cproto void FS_EXIT(USHORT uid, USHORT pid, USHORT pdb) VBOXSF_EP16_BEGIN FS_EXIT, 'FS_EXIT' ; ; Initialized ring-0 yet? (this is a likely first entry point) ; push ds mov ax, DATA16 mov ds, ax test byte [NAME(g_fDoneRing0)], 1 jnz .DoneRing0 call NAME(VBoxSFR0Init16Bit) .DoneRing0: pop ds VBOXSF_TO_32 FS_EXIT, 3*4 movzx ecx, word [ebp + 08h] ; pdb mov [esp + 2*4], ecx movzx edx, word [ebp + 0ah] ; pib mov [esp + 1*4], edx movzx eax, word [ebp + 0ch] ; uid mov [esp], eax call NAME(FS32_EXIT) VBOXSF_TO_16 FS_EXIT retf 6h VBOXSF_EP16_END FS_EXIT ;; ; @cproto int FS_FILEATTRIBUTE(USHORT flag, PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd, PUSHORT pAttr); ; VBOXSF_EP16_BEGIN FS_FILEATTRIBUTE, 'FS_FILEATTRIBUTE' VBOXSF_TO_32 FS_FILEATTRIBUTE, 6*4 VBOXSF_FARPTR_2_FLAT 08h, 5*4 ; pAttr movzx ecx, word [ebp + 0ch] ; iCurDirEnd mov [esp + 4*4], ecx VBOXSF_FARPTR_2_FLAT 0eh, 3*4 ; pszName VBOXSF_PCDFSD_2_FLAT 12h, 2*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 16h, 1*4 ; pcdfsi movzx edx, word [ebp + 1ah] ; flag mov [esp], edx call NAME(FS32_FILEATTRIBUTE) VBOXSF_TO_16 FS_FILEATTRIBUTE retf 14h VBOXSF_EP16_END FS_FILEATTRIBUTE ;; ; @cproto int FS_FILEINFO(USHORT flag, PSFFSI psffsi, PVBOXSFFSD psffsd, USHORT level, ; PBYTE pData, USHORT cbData, USHORT IOflag); VBOXSF_EP16_BEGIN FS_FILEINFO, 'FS_FILEINFO' VBOXSF_TO_32 FS_FILEINFO, 7*4 movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 6*4], ecx movzx edx, word [ebp + 0ah] ; cbData mov [esp + 5*4], edx VBOXSF_FARPTR_2_FLAT 0ch, 4*4 ; pData movzx eax, word [ebp + 10h] ; level mov [esp + 3*4], eax VBOXSF_PSFFSD_2_FLAT 12h, 2*4 ; psffsd VBOXSF_FARPTR_2_FLAT 16h, 1*4 ; psffsi movzx ecx, word [ebp + 1ah] ; flag mov [esp], ecx call NAME(FS32_FILEINFO) VBOXSF_TO_16 FS_FILEINFO retf 14h VBOXSF_EP16_END FS_FILEINFO ;; ; @cproto int FS_FILEIO(PSFFSI psffsi, PVBOXSFFSD psffsd, PBYTE pCmdList, USHORT cbCmdList, ; PUSHORT poError, USHORT IOflag); VBOXSF_EP16_BEGIN FS_FILEIO, 'FS_FILEIO' VBOXSF_TO_32 FS_FILEIO, 6*4 movzx ecx, word [ebp + 08h] ; IOFlag mov [esp + 5*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 4*4 ; poError movzx edx, word [ebp + 0eh] ; cbCmdList mov [esp + 3*4], edx VBOXSF_FARPTR_2_FLAT 10h, 2*4 ; pCmdList VBOXSF_PSFFSD_2_FLAT 14h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 18h, 0*4 ; psffsi call NAME(FS32_FILEIO) VBOXSF_TO_16 FS_FILEIO retf 14h VBOXSF_EP16_END FS_FILEIO ;; ; @cproto int FS_FILELOCKS(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelock far *pUnLockRange ; struct filelock far *pLockRange, ULONG timeout, ULONG flags) VBOXSF_EP16_BEGIN FS_FILELOCKS, 'FS_FILELOCKS' VBOXSF_TO_32 FS_FILELOCKS, 6*4 mov ecx, [ebp + 08h] ; flags mov [esp + 5*4], ecx mov edx, [ebp + 0ch] ; timeout mov [esp + 4*4], edx VBOXSF_FARPTR_2_FLAT 10h, 3*4 ; pLockRange VBOXSF_FARPTR_2_FLAT 14h, 2*4 ; pUnLockRange VBOXSF_PSFFSD_2_FLAT 18h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 1ch, 0*4 ; psffsi call NAME(FS32_FILELOCKS) VBOXSF_TO_16 FS_FILELOCKS retf 18h VBOXSF_EP16_END FS_FILELOCKS ;; ; @cproto int FS_FILELOCKSL(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelockl far *pUnLockRange ; struct filelockl far *pLockRange, ULONG timeout, ULONG flags) VBOXSF_EP16_BEGIN FS_FILELOCKSL, 'FS_FILELOCKSL' VBOXSF_TO_32 FS_FILELOCKSL, 6*4 mov ecx, [ebp + 08h] ; flags mov [esp + 5*4], ecx mov edx, [ebp + 0ch] ; timeout mov [esp + 4*4], edx VBOXSF_FARPTR_2_FLAT 10h, 3*4 ; pLockRange VBOXSF_FARPTR_2_FLAT 14h, 2*4 ; pUnLockRange VBOXSF_PSFFSD_2_FLAT 18h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 1ch, 0*4 ; psffsi call NAME(FS32_FILELOCKS) VBOXSF_TO_16 FS_FILELOCKSL retf 18h VBOXSF_EP16_END FS_FILELOCKSL ;; ; @cproto int FS_FINDCLOSE(PFSFSI pfsfsi, PVBOXSFFS pfsfsd); ; VBOXSF_EP16_BEGIN FS_FINDCLOSE, 'FS_FINDCLOSE' VBOXSF_TO_32 FS_FINDCLOSE, 2*4 VBOXSF_PFSFSD_2_FLAT 08h, 1*4 ; pfsfsd VBOXSF_FARPTR_2_FLAT 0ch, 0*4 ; pfsfsi call NAME(FS32_FINDCLOSE) VBOXSF_TO_16 FS_FINDCLOSE retf 8h VBOXSF_EP16_END FS_FINDCLOSE ;; ; @cproto int FS_FINDFIRST(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd, USHORT attr, ; PFSFSI pfsfsi, PVBOXSFFS pfsfsd, PBYTE pbData, USHORT cbData, PUSHORT pcMatch, ; USHORT level, USHORT flags); ; VBOXSF_EP16_BEGIN FS_FINDFIRST, 'FS_FINDFIRST' VBOXSF_TO_32 FS_FINDFIRST, 12*4 movzx ecx, word [ebp + 08h] ; flags mov [esp + 11*4], ecx movzx edx, word [ebp + 0ah] ; level mov [esp + 10*4], edx VBOXSF_FARPTR_2_FLAT 0ch, 9*4 ; pcMatch movzx eax, word [ebp + 10h] ; cbData mov [esp + 8*4], eax VBOXSF_FARPTR_2_FLAT 12h, 7*4 ; pbData VBOXSF_FARPTR_2_FLAT 16h, 6*4 ; pfsfsd VBOXSF_FARPTR_2_FLAT 1ah, 5*4 ; pfsfsi movzx ecx, word [ebp + 1eh] ; attr mov [esp + 4*4], ecx movzx edx, word [ebp + 20h] ; iCurDirEnd mov [esp + 3*4], edx VBOXSF_FARPTR_2_FLAT 22h, 2*4 ; pszName VBOXSF_PCDFSD_2_FLAT 26h, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 2ah, 0*4 ; pcdfsi call NAME(FS32_FINDFIRST) VBOXSF_TO_16 FS_FINDFIRST retf 26h VBOXSF_EP16_END FS_FINDFIRST ;; ; @cproto int FS_FINDFROMNAME(PFSFSI pfsfsi, PVBOXSFFS pfsfsd, PBYTE pbData, USHORT cbData, PUSHORT pcMatch, ; USHORT level, ULONG position, PCSZ pszName, USHORT flag) ; VBOXSF_EP16_BEGIN FS_FINDFROMNAME, 'FS_FINDFROMNAME' VBOXSF_TO_32 FS_FINDFROMNAME, 9*4 movzx ecx, word [ebp + 08h] ; flags mov [esp + 8*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 7*4 ; pszName mov edx, [ebp + 0eh] ; position mov [esp + 6*4], edx movzx eax, word [ebp + 12h] ; level mov [esp + 5*4], eax VBOXSF_FARPTR_2_FLAT 14h, 4*4 ; pcMatch movzx eax, word [ebp + 18h] ; cbData mov [esp + 3*4], eax VBOXSF_FARPTR_2_FLAT 1ah, 2*4 ; pbData VBOXSF_PFSFSD_2_FLAT 1eh, 1*4 ; pfsfsd VBOXSF_FARPTR_2_FLAT 22h, 0*4 ; pfsfsi call NAME(FS32_FINDFROMNAME) VBOXSF_TO_16 FS_FINDFROMNAME retf 1eh VBOXSF_EP16_END FS_FINDFROMNAME ;; ; @cproto int FS_FINDNEXT(PFSFSI pfsfsi, PVBOXSFFS pfsfsd, PBYTE pbData, USHORT cbData, PUSHORT pcMatch, ; USHORT level, USHORT flag) ; VBOXSF_EP16_BEGIN FS_FINDNEXT, 'FS_FINDNEXT' VBOXSF_TO_32 FS_FINDNEXT, 7*4 movzx ecx, word [ebp + 08h] ; flags mov [esp + 6*4], ecx movzx eax, word [ebp + 0ah] ; level mov [esp + 5*4], eax VBOXSF_FARPTR_2_FLAT 0ch, 4*4 ; pcMatch movzx eax, word [ebp + 10h] ; cbData mov [esp + 3*4], eax VBOXSF_FARPTR_2_FLAT 12h, 2*4 ; pbData VBOXSF_PFSFSD_2_FLAT 16h, 1*4 ; pfsfsd VBOXSF_FARPTR_2_FLAT 1ah, 0*4 ; pfsfsi call NAME(FS32_FINDNEXT) VBOXSF_TO_16 FS_FINDNEXT retf 16h VBOXSF_EP16_END FS_FINDNEXT ;; ; @cproto int FS_FINDNOTIFYCLOSE(USHORT handle); ; VBOXSF_EP16_BEGIN FS_FINDNOTIFYCLOSE, 'FS_FINDNOTIFYCLOSE' VBOXSF_TO_32 FS_FINDNOTIFYCLOSE, 1*4 movzx ecx, word [ebp + 08h] ; handle mov [esp], ecx call NAME(FS32_FINDNOTIFYCLOSE) VBOXSF_TO_16 FS_FINDNOTIFYCLOSE retf 2h VBOXSF_EP16_END FS_FINDNOTIFYCLOSE ;; ; @cproto int FS_FINDNOTIFYFIRST(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd, USHORT attr, ; PUSHORT pHandle, PBYTE pbData, USHORT cbData, PUSHORT pcMatch, ; USHORT level, USHORT flags); ; VBOXSF_EP16_BEGIN FS_FINDNOTIFYFIRST, 'FS_FINDNOTIFYFIRST' VBOXSF_TO_32 FS_FINDNOTIFYFIRST, 11*4 movzx ecx, word [ebp + 08h] ; flags mov [esp + 10*4], ecx movzx edx, word [ebp + 0ah] ; level mov [esp + 9*4], edx VBOXSF_FARPTR_2_FLAT 0ch, 8*4 ; pcMatch movzx eax, word [ebp + 10h] ; cbData mov [esp + 7*4], eax VBOXSF_FARPTR_2_FLAT 12h, 6*4 ; pbData VBOXSF_FARPTR_2_FLAT 16h, 5*4 ; pHandle movzx ecx, word [ebp + 1ah] ; attr mov [esp + 4*4], ecx movzx edx, word [ebp + 1ch] ; iCurDirEnd mov [esp + 3*4], edx VBOXSF_FARPTR_2_FLAT 1eh, 2*4 ; pszName VBOXSF_PCDFSD_2_FLAT 22h, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 26h, 0*4 ; pcdfsi call NAME(FS32_FINDNOTIFYFIRST) VBOXSF_TO_16 FS_FINDNOTIFYFIRST retf 22h VBOXSF_EP16_END FS_FINDNOTIFYFIRST ;; ; @cproto int FS_FINDNOTIFYNEXT(USHORT handle, PBYTE pbData, USHORT cbData, PUSHORT pcMatch, ; USHORT level, ULONG timeout) ; VBOXSF_EP16_BEGIN FS_FINDNOTIFYNEXT, 'FS_FINDNOTIFYNEXT' VBOXSF_TO_32 FS_FINDNOTIFYNEXT, 6*4 mov ecx, [ebp + 08h] ; timeout mov [esp + 5*4], ecx movzx edx, word [ebp + 0ch] ; level mov [esp + 4*4], edx VBOXSF_FARPTR_2_FLAT 0eh, 3*4 ; pcMatch movzx eax, word [ebp + 12h] ; cbData mov [esp + 2*4], eax VBOXSF_FARPTR_2_FLAT 14h, 1*4 ; pbData movzx ecx, word [ebp + 18h] ; handle mov [esp], ecx call NAME(FS32_FINDNOTIFYNEXT) VBOXSF_TO_16 FS_FINDNOTIFYNEXT retf 12h VBOXSF_EP16_END FS_FINDNOTIFYNEXT ;; @cproto int FS_FLUSHBUF(USHORT hVPB, USHORT flag); VBOXSF_EP16_BEGIN FS_FLUSHBUF, 'FS_FLUSHBUF' VBOXSF_TO_32 FS_FLUSHBUF, 2*4 movzx edx, word [ebp + 08h] ; flag mov [esp + 1*4], edx movzx eax, word [ebp + 0ch] ; hVPB mov [esp + 0*4], eax call NAME(FS32_FLUSHBUF) VBOXSF_TO_16 FS_FLUSHBUF retf 4h VBOXSF_EP16_END FS_FLUSHBUF ;; @cproto int FS_FSCTL(union argdat far *pArgdat, USHORT iArgType, USHORT func, ; PVOID pParm, USHORT lenParm, PUSHORT plenParmIO, ; PVOID pData, USHORT lenData, PUSHORT plenDataIO); VBOXSF_EP16_BEGIN FS_FSCTL, 'FS_FSCTL' ; ; Initialized ring-0 yet? (this is a likely first entry point) ; push ds mov ax, DATA16 mov ds, ax test byte [NAME(g_fDoneRing0)], 1 jnz .DoneRing0 call NAME(VBoxSFR0Init16Bit) .DoneRing0: pop ds VBOXSF_TO_32 FS_FSCTL, 9*4 VBOXSF_FARPTR_2_FLAT 08h, 8*4 ; plenDataIO movzx ecx, word [ebp + 0ch] ; lenData mov [esp + 7*4], ecx VBOXSF_FARPTR_2_FLAT 0eh, 6*4 ; pData VBOXSF_FARPTR_2_FLAT 12h, 5*4 ; plenDataIO movzx ecx, word [ebp + 16h] ; lenData mov [esp + 4*4], ecx VBOXSF_FARPTR_2_FLAT 18h, 3*4 ; pData movzx edx, word [ebp + 1ch] ; func mov [esp + 2*4], edx movzx eax, word [ebp + 1eh] ; iArgType mov [esp + 1*4], eax VBOXSF_FARPTR_2_FLAT 20h, 0*4 ; pArgdat call NAME(FS32_FSCTL) VBOXSF_TO_16 FS_FSCTL retf 1ch VBOXSF_EP16_END FS_FSCTL ;; @cproto int FS_FSINFO(USHORT flag, USHORT hVPB, PBYTE pbData, USHORT cbData, USHORT level) VBOXSF_EP16_BEGIN FS_FSINFO, 'FS_FSINFO' VBOXSF_TO_32 FS_FSINFO, 5*4 movzx ecx, word [ebp + 08h] ; level mov [esp + 10h], ecx movzx edx, word [ebp + 0ah] ; cbData mov [esp + 0ch], edx VBOXSF_FARPTR_2_FLAT 0ch, 2*4 ; pbData movzx edx, word [ebp + 10h] ; hVPB mov [esp], edx movzx eax, word [ebp + 12h] ; flag mov [esp], eax call NAME(FS32_FSINFO) VBOXSF_TO_16 FS_FSINFO retf 14h VBOXSF_EP16_END FS_FSINFO ;; ; @cproto int FS_IOCTL(PSFFSI psffsi, PVBOXSFFSD psffsd, USHORT cat, USHORT func, ; PVOID pParm, USHORT lenParm, PUSHORT plenParmIO, ; PVOID pData, USHORT lenData, PUSHORT plenDataIO); VBOXSF_EP16_BEGIN FS_IOCTL, 'FS_IOCTL' VBOXSF_TO_32 FS_IOCTL, 10*4 VBOXSF_FARPTR_2_FLAT 08h, 9*4 ; plenDataIO movzx ecx, word [ebp + 0ch] ; lenData mov [esp + 8*4], ecx VBOXSF_FARPTR_2_FLAT 0eh, 7*4 ; pData VBOXSF_FARPTR_2_FLAT 12h, 6*4 ; plenDataIO movzx ecx, word [ebp + 16h] ; lenData mov [esp + 5*4], ecx VBOXSF_FARPTR_2_FLAT 18h, 4*4 ; pData movzx edx, word [ebp + 1ch] ; cat mov [esp + 3*4], edx movzx eax, word [ebp + 1eh] ; func mov [esp + 2*4], eax VBOXSF_PSFFSD_2_FLAT 20h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 24h, 0*4 ; pData call NAME(FS32_IOCTL) VBOXSF_TO_16 FS_IOCTL retf 20h VBOXSF_EP16_END FS_IOCTL ;; ; @cproto int FS_MKDIR(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd, ; PBYTE pEABuf, USHORT flag); VBOXSF_EP16_BEGIN FS_MKDIR, 'FS_MKDIR' VBOXSF_TO_32 FS_MKDIR, 6*4 movzx ecx, word [ebp + 08h] ; flag mov [esp + 5*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 4*4 ; pEABuf movzx edx, word [ebp + 0eh] ; iCurDirEnd mov [esp + 3*4], edx VBOXSF_FARPTR_2_FLAT 10h, 2*4 ; pszName VBOXSF_PCDFSD_2_FLAT 14h, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 18h, 0*4 ; pcdfsi call NAME(FS32_MKDIR) VBOXSF_TO_16 FS_MKDIR retf 14h VBOXSF_EP16_END FS_MKDIR ;; ; @cproto int FS_MOUNT(USHORT flag, PVPFSI pvpfsi, PVBOXSFVP pvpfsd, USHORT hVPB, PCSZ pszBoot) VBOXSF_EP16_BEGIN FS_MOUNT, 'FS_MOUNT' ; ; Initialized ring-0 yet? (this is a likely first entry point) ; push ds mov ax, DATA16 mov ds, ax test byte [NAME(g_fDoneRing0)], 1 jnz .DoneRing0 call NAME(VBoxSFR0Init16Bit) .DoneRing0: pop ds VBOXSF_TO_32 FS_MOUNT, 5*4 VBOXSF_FARPTR_2_FLAT 08h, 4*4 ; pszBoot movzx ecx, word [ebp + 0ch] ; hVPB mov [esp + 3*4], ecx VBOXSF_FARPTR_2_FLAT 0eh, 2*4 ; pvpfsd VBOXSF_FARPTR_2_FLAT 12h, 1*4 ; pvpfsi movzx ecx, word [ebp + 16h] ; flag mov [esp], ecx call NAME(FS32_MOUNT) VBOXSF_TO_16 FS_MOUNT retf 10h VBOXSF_EP16_END FS_MOUNT ;; ; @cproto int FS_MOVE(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszSrc, USHORT iSrcCurDirEnd ; PCSZ pszDst, USHORT iDstCurDirEnd, USHORT type) VBOXSF_EP16_BEGIN FS_MOVE, 'FS_MOVE' VBOXSF_TO_32 FS_MOVE, 7*4 movzx ecx, word [ebp + 08h] ; type mov [esp + 6*4], ecx movzx edx, word [ebp + 0ah] ; iDstCurDirEnd mov [esp + 5*4], edx VBOXSF_FARPTR_2_FLAT 0ch, 4*4 ; pszDst movzx eax, word [ebp + 10h] ; iSrcCurDirEnd mov [esp + 3*4], eax VBOXSF_FARPTR_2_FLAT 12h, 2*4 ; pszSrc VBOXSF_PCDFSD_2_FLAT 16h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 1ah, 0*4 ; psffsi call NAME(FS32_MOVE) VBOXSF_TO_16 FS_MOVE retf 16h VBOXSF_EP16_END FS_MOVE ;; ; @cproto int FS_NEWSIZE(PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG cbFile, USHORT IOflag); VBOXSF_EP16_BEGIN FS_NEWSIZE, 'FS_NEWSIZE' VBOXSF_TO_32 FS_NEWSIZE, 5*4 ; thunking to longlong edition. movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 4*4], ecx mov eax, [ebp + 0ah] ; cbFile (ULONG -> LONGLONG) mov dword [esp + 3*4], 0 mov [esp + 2*4], eax VBOXSF_PSFFSD_2_FLAT 0eh, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 12h, 0*4 ; psffsi call NAME(FS32_NEWSIZEL) VBOXSF_TO_16 FS_NEWSIZE retf 0eh VBOXSF_EP16_END FS_NEWSIZE ;; ; @cproto int FS_NEWSIZEL(PSFFSI psffsi, PVBOXSFFSD psffsd, LONGLONG cbFile, USHORT IOflag); VBOXSF_EP16_BEGIN FS_NEWSIZEL, 'FS_NEWSIZEL' VBOXSF_TO_32 FS_NEWSIZEL, 5*4 movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 4*4], ecx mov eax, [ebp + 0ah] ; cbFile mov edx, [ebp + 0eh] mov [esp + 3*4], edx mov [esp + 2*4], eax VBOXSF_PSFFSD_2_FLAT 12h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 16h, 0*4 ; psffsi call NAME(FS32_NEWSIZEL) VBOXSF_TO_16 FS_NEWSIZEL retf 12h VBOXSF_EP16_END FS_NEWSIZEL ;; ; @cproto int FS_NMPIPE(PSFFSI psffsi, PVBOXSFFSD psffsd, USHORT OpType, union npoper far *pOpRec, ; PBYTE pData, PCSZ pszName); VBOXSF_EP16_BEGIN FS_NMPIPE, 'FS_NMPIPE' VBOXSF_TO_32 FS_NMPIPE, 6*4 VBOXSF_FARPTR_2_FLAT 08h, 5*4 ; pszName VBOXSF_FARPTR_2_FLAT 0ch, 4*4 ; pData VBOXSF_FARPTR_2_FLAT 10h, 3*4 ; pOpRec movzx ecx, word [ebp + 14h] ; OpType mov [esp + 2*4], ecx VBOXSF_FARPTR_2_FLAT 16h, 1*4 ; psffsd (take care...) VBOXSF_FARPTR_2_FLAT 1ah, 0*4 ; psffsi call NAME(FS32_NMPIPE) VBOXSF_TO_16 FS_NMPIPE retf 16h VBOXSF_EP16_END FS_NMPIPE ;; ; @cproto int FS_OPENCREATE(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd, ; PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG ulOpenMode, USHORT usOpenFlag, ; PUSHORT pusAction, USHORT usAttr, PBYTE pcEABuf, PUSHORT pfgenflag); VBOXSF_EP16_BEGIN FS_OPENCREATE, 'FS_OPENCREATE' VBOXSF_TO_32 FS_OPENCREATE, 12*4 VBOXSF_FARPTR_2_FLAT 08h, 11*4 ; pfgenflag VBOXSF_FARPTR_2_FLAT 0ch, 10*4 ; pcEABuf movzx ecx, word [ebp + 10h] ; usAttr mov [esp + 9*4], ecx VBOXSF_FARPTR_2_FLAT 12h, 8*4 ; pusAction movzx edx, word [ebp + 16h] ; usOpenFlag mov [esp + 7*4], edx mov eax, [ebp + 18h] ; ulOpenMode mov [esp + 6*4], eax VBOXSF_FARPTR_2_FLAT 1ch, 5*4 ; psffsd (new, no short cuts) VBOXSF_FARPTR_2_FLAT 20h, 4*4 ; psffsi movzx ecx, word [ebp + 24h] ; iCurDirEnd mov [esp + 3*4], ecx VBOXSF_FARPTR_2_FLAT 26h, 2*4 ; pszName VBOXSF_PCDFSD_2_FLAT 2ah, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 2eh, 0*4 ; pcdfsi call NAME(FS32_OPENCREATE) VBOXSF_TO_16 FS_OPENCREATE retf 42 VBOXSF_EP16_END FS_OPENCREATE ;; ; @cproto int FS_OPENPAGEFILE(PULONG pFlag, PULONG pcMaxReq, PCSZ pszName, PSFFSI psffsi, PVBOXSFFSD psffsd, ; USHORT ulOpenMode, USHORT usOpenFlag, USHORT usAttr, ULONG Reserved) VBOXSF_EP16_BEGIN FS_OPENPAGEFILE, 'FS_OPENPAGEFILE' VBOXSF_TO_32 FS_OPENPAGEFILE, 9*4 mov ecx, [ebp + 08h] ; Reserved mov [esp + 8*4], ecx movzx edx, word [ebp + 0ch] ; usAttr mov [esp + 7*4], edx movzx eax, word [ebp + 0eh] ; usOpenFlag mov [esp + 6*4], eax movzx ecx, word [ebp + 10h] ; usOpenMode mov [esp + 5*4], ecx VBOXSF_FARPTR_2_FLAT 12h, 4*4 ; psffsd (new, no short cuts) VBOXSF_FARPTR_2_FLAT 16h, 3*4 ; psffsi VBOXSF_FARPTR_2_FLAT 1ah, 2*4 ; pszName VBOXSF_FARPTR_2_FLAT 1eh, 1*4 ; pcMaxReq VBOXSF_FARPTR_2_FLAT 22h, 0*4 ; pFlag call NAME(FS32_OPENPAGEFILE) VBOXSF_TO_16 FS_OPENPAGEFILE retf 1eh VBOXSF_EP16_END FS_OPENPAGEFILE ;; ; @cproto int FS_PATHINFO(USHORT flag, PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnt, ; USHORT level, PBYTE pData, USHORT cbData); VBOXSF_EP16_BEGIN FS_PATHINFO, 'FS_PATHINFO' VBOXSF_TO_32 FS_PATHINFO, 8*4 movzx ecx, word [ebp + 08h] ; cbData mov [esp + 7*4], ecx VBOXSF_FARPTR_2_FLAT 0ah, 6*4 ; pData movzx edx, word [ebp + 0eh] ; level mov [esp + 5*4], edx movzx eax, word [ebp + 10h] ; iCurDirEnd mov [esp + 4*4], eax VBOXSF_FARPTR_2_FLAT 12h, 3*4 ; pszName VBOXSF_PCDFSD_2_FLAT 16h, 2*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 1ah, 1*4 ; pcdfsi movzx edx, word [ebp + 1eh] ; flag mov [esp], edx call NAME(FS32_PATHINFO) VBOXSF_TO_16 FS_PATHINFO retf 18h VBOXSF_EP16_END FS_PATHINFO ;; @cproto int FS_PROCESSNAME(PSZ pszName); VBOXSF_EP16_BEGIN FS_PROCESSNAME, 'FS_PROCESSNAME' VBOXSF_TO_32 FS_PROCESSNAME, 1*4 VBOXSF_FARPTR_2_FLAT 08h, 0*4 ; pszName call NAME(FS32_PROCESSNAME) VBOXSF_TO_16 FS_PROCESSNAME retf 4h VBOXSF_EP16_END FS_PROCESSNAME ;; ; @cproto int FS_READ(PSFFSI psffsi, PVBOXSFFSD psffsd, PBYTE pbData, PUSHORT pcbData, USHORT IOflag) VBOXSF_EP16_BEGIN FS_READ, 'FS_READ' VBOXSF_TO_32 FS_READ, 6*4 ; extra local for ULONG cbDataTmp. movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 4*4], ecx les dx, [ebp + 0ah] ; cbDataTmp = *pcbData; movzx edx, dx lea ecx, [esp + 5*4] ; pcbData = &cbDataTmp movzx eax, word [es:edx] mov [ecx], eax mov [esp + 3*4], ecx mov edx, DATA32 mov es, edx VBOXSF_FARPTR_2_FLAT 0eh, 2*4 ; pbData VBOXSF_PSFFSD_2_FLAT 12h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 16h, 0*4 ; psffsi call FS32_READ les dx, [ebp + 0ah] ; *pcbData = cbDataTmp; movzx edx, dx mov cx, [esp + 5*4] mov [es:edx], cx mov edx, DATA32 mov es, edx VBOXSF_TO_16 FS_READ pop es retf 12h VBOXSF_EP16_END FS_READ ;; ; @cproto int FS_RMDIR(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd); ; VBOXSF_EP16_BEGIN FS_RMDIR, 'FS_RMDIR' VBOXSF_TO_32 FS_RMDIR, 4*4 movzx edx, word [ebp + 08h] ; iCurDirEnd mov [esp + 3*4], edx VBOXSF_FARPTR_2_FLAT 0ah, 2*4 ; pszName VBOXSF_PCDFSD_2_FLAT 0eh, 1*4 ; pcdfsd VBOXSF_FARPTR_2_FLAT 12h, 0*4 ; pcdfsi call NAME(FS32_RMDIR) VBOXSF_TO_16 FS_RMDIR retf 14h VBOXSF_EP16_END FS_RMDIR ;; ; @cproto int FS_SETSWAP(PSFFSI psffsi, PVBOXSFFSD psffsd); ; VBOXSF_EP16_BEGIN FS_SETSWAP, 'FS_SETSWAP' VBOXSF_TO_32 FS_SETSWAP, 2*4 VBOXSF_PSFFSD_2_FLAT 08h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 0ch, 0*4 ; psffsi call NAME(FS32_SETSWAP) VBOXSF_TO_16 FS_SETSWAP retf 8h VBOXSF_EP16_END FS_SETSWAP ;; ; @cproto int FS_SHUTDOWN(USHORT type, ULONG reserved); ; VBOXSF_EP16_BEGIN FS_SHUTDOWN, 'FS_SHUTDOWN' VBOXSF_TO_32 FS_SHUTDOWN, 3*4 mov ecx, [ebp + 08h] ; type mov [esp + 1*4], edx movzx edx, word [ebp + 0ah] ; reserved mov [esp], eax call NAME(FS32_SHUTDOWN) VBOXSF_TO_16 FS_SHUTDOWN retf 6h VBOXSF_EP16_END FS_SHUTDOWN ;; ; @cproto int FS_WRITE(PSFFSI psffsi, PVBOXSFFSD psffsd, PBYTE pbData, PUSHORT pcbData, USHORT IOflag) VBOXSF_EP16_BEGIN FS_WRITE, 'FS_WRITE' VBOXSF_TO_32 FS_WRITE, 6*4 ; extra local for ULONG cbDataTmp. movzx ecx, word [ebp + 08h] ; IOflag mov [esp + 4*4], ecx les dx, [ebp + 0ah] ; cbDataTmp = *pcbData; movzx edx, dx lea ecx, [esp + 5*4] ; pcbData = &cbDataTmp movzx eax, word [es:edx] mov [ecx], eax mov [esp + 3*4], ecx mov edx, DATA32 mov es, edx VBOXSF_FARPTR_2_FLAT 0eh, 2*4 ; pbData VBOXSF_PSFFSD_2_FLAT 12h, 1*4 ; psffsd VBOXSF_FARPTR_2_FLAT 16h, 0*4 ; psffsi call FS32_WRITE les dx, [ebp + 0ah] ; *pcbData = cbDataTmp; movzx edx, dx mov cx, [esp + 5*4] mov [es:edx], cx mov edx, DATA32 mov es, edx VBOXSF_TO_16 FS_WRITE pop es retf 12h VBOXSF_EP16_END FS_WRITE ; ; ; Init code starts here ; Init code starts here ; Init code starts here ; ; ;; ; Ring-3 Init (16-bit). ; ; @param pMiniFS [bp + 08h] The mini-FSD. (NULL) ; @param fpfnDevHlp [bp + 0ch] The address of the DevHlp router. ; @param pszCmdLine [bp + 10h] The config.sys command line. ; VBOXSF_EP16_BEGIN FS_INIT, 'FS_INIT' ; DEBUG_STR16 'VBoxSF: FS_INIT - enter' push ebp mov ebp, esp push ds ; bp - 02h push es ; bp - 04h push esi ; bp - 08h push edi ; bp - 0ch mov ax, DATA16 mov ds, ax mov es, ax ; ; Save the device help entry point. ; mov eax, [bp + 0ch] mov [NAME(g_fpfnDevHlp)], eax ; ; Parse the command line. ; Doing this in assembly is kind of ugly... ; cmp word [bp + 10h + 2], 3 jbe near .no_command_line lds si, [bp + 10h] ; ds:si -> command line iterator. .parse_next: ; skip leading blanks. .parse_next_char: mov di, si ; DI = start of argument. lodsb cmp al, ' ' je .parse_next_char cmp al, 9 ; tab je .parse_next_char cmp al, 0 je near .parse_done ; check for '/' or '-' cmp al, '/' je .parse_switch cmp al, '-' je .parse_switch jmp .parse_error ; parse switches. .parse_switch: lodsb cmp al, 0 je .parse_error and al, ~20h ; uppercase cmp al, 'V' ; /V - verbose je .parse_verbose cmp al, 'Q' ; /Q - quiet. je .parse_quiet jmp .parse_error .parse_verbose: mov byte [es:NAME(g_fVerbose)], 1 jmp .parse_next .parse_quiet: mov byte [es:NAME(g_fVerbose)], 0 jmp .parse_next .parse_error: segment DATA16 .szSyntaxError: db 0dh, 0ah, 'VBoxSF.ifs: command line parse error at: ', 0 .szNewLine: db 0dh, 0ah, 0dh, 0ah, 0 segment CODE16 mov bx, .szSyntaxError call NAME(FS_INIT_FPUTS) push es push ds pop es mov bx, di call NAME(FS_INIT_FPUTS) pop es mov bx, .szNewLine call NAME(FS_INIT_FPUTS) mov ax, ERROR_INVALID_PARAMETER jmp .done .parse_done: mov ax, DATA16 mov ds, ax .no_command_line: ; ; Write our greeting to STDOUT. ; APIRET _Pascal DosWrite(HFILE hf, PVOID pvBuf, USHORT cbBuf, PUSHORT pcbBytesWritten); ; cmp byte [NAME(g_fVerbose)], 0 je near .quiet segment DATA16 .szMessage: db 'VirtualBox Guest Additions IFS for OS/2', 0dh, 0ah, 0 segment CODE16 mov bx, .szMessage call NAME(FS_INIT_FPUTS) .quiet: ; return success. xor eax, eax .done: lea sp, [bp - 0ch] pop edi pop esi pop es pop ds mov esp, ebp pop ebp DEBUG_STR16 'VBoxSF: FS_INIT - leave' retf 0ch VBOXSF_EP16_END FS_INIT ;; ; Dos16Write wrapper. ; ; @param es:bx String to print. (zero terminated) ; @uses nothing. GLOBALNAME FS_INIT_FPUTS push bp mov bp, sp push es ; bp - 02h push ds ; bp - 04h push ax ; bp - 06h push bx ; bp - 08h push cx ; bp - 0ah push dx ; bp - 0ch push si ; bp - 0eh push di ; bp - 10h ; cx = strlen(es:bx) xor al, al mov di, bx mov cx, 0ffffh cld repne scasb not cx dec cx ; APIRET _Pascal DosWrite(HFILE hf, PVOID pvBuf, USHORT cbBuf, PUSHORT pcbBytesWritten); push cx mov ax, sp ; cbBytesWritten push 1 ; STDOUT push es ; pvBuf push bx push cx ; cbBuf push ss ; pcbBytesWritten push ax %if 0 ; wlink/nasm generates a non-aliased fixup here which results in 16-bit offset with the flat 32-bit selector. call far DOS16WRITE %else ; convert flat pointer to a far pointer using the tiled algorithm. mov ax, DATA32 wrt FLAT mov ds, ax mov eax, g_pfnDos16Write wrt FLAT movzx eax, word [eax + 2] ; High word of the flat address (in DATA32). shl ax, 3 or ax, 0007h mov dx, DATA16 mov ds, dx mov [NAME(g_fpfnDos16Write) + 2], ax ; Update the selector (in DATA16). ; do the call call far [NAME(g_fpfnDos16Write)] %endif lea sp, [bp - 10h] pop di pop si pop dx pop cx pop bx pop ax pop ds pop es pop bp ret ENDPROC FS_INIT_FPUTS ;; ; 16-bit ring-0 init routine. ; ; Called from various entrypoints likely to be the first to be invoked. ; GLOBALNAME VBoxSFR0Init16Bit DEBUG_STR16 'VBoxSF: VBoxSFR0Init16Bit - enter' push ds push es push fs push gs push esi push edi push ebp mov ebp, esp and sp, 0fffch ; ; Only try once. ; mov ax, DATA16 mov ds, ax mov byte [NAME(g_fDoneRing0)], 1 ; ; Try attach to the VBoxGuest driver. ; mov bx, NAME(g_szVBoxGuestName) mov di, NAME(g_VBoxGuestAttachDD) mov dl, DevHlp_AttachDD call far [NAME(g_fpfnDevHlp)] jc .attach_attempt_done push seg NAME(g_VBoxGuestIDC) push NAME(g_VBoxGuestIDC) call far [NAME(g_VBoxGuestAttachDD) + 6] .attach_attempt_done: %ifndef DONT_LOCK_SEGMENTS ; ; Lock the two 16-bit segments. ; push DATA16 call far FSH_FORCENOSWAP push CODE16 call far FSH_FORCENOSWAP ; Wonder if this'll work if wlink could mark the two segments as ALIASed... ;push DATA32 ;call far FSH_FORCENOSWAP ;push TEXT32 ;call far FSH_FORCENOSWAP %endif ; ; Do 32-bit ring-0 init. ; ;jmp far dword NAME(VBoxSFR0Init16Bit_32) wrt FLAT db 066h db 0eah dd NAME(VBoxSFR0Init16Bit_32) ;wrt FLAT dw TEXT32 wrt FLAT segment TEXT32 GLOBALNAME VBoxSFR0Init16Bit_32 mov ax, DATA32 wrt FLAT mov ds, ax mov es, ax call KernThunkStackTo32 call NAME(VBoxSFR0Init) call KernThunkStackTo16 ;jmp far dword NAME(VBoxSFR0Init16Bit_16) wrt CODE16 db 066h db 0eah dw NAME(VBoxSFR0Init16Bit_16) wrt CODE16 dw CODE16 segment CODE16 GLOBALNAME VBoxSFR0Init16Bit_16 mov esp, ebp pop ebp pop edi pop esi pop gs pop fs pop es pop ds DEBUG_STR16 'VBoxSF: VBoxSFR0Init16Bit - leave' ret ENDPROC VBoxSFR0Init16Bit %ifdef DEBUG ;; ; print the string which offset is in AX (it's in the data segment). ; @uses AX ; GLOBALNAME dbgstr16 push ds push ebx push edx mov bx, ax mov dx, 0504h ; RTLOG_DEBUG_PORT mov ax, DATA16 mov ds, ax .next: mov al, [bx] or al, al jz .done inc bx out dx, al jmp .next .done: pop edx pop ebx pop ds ret ENDPROC dbgstr16 %endif