wrappers.asm

vc环境下的pgp源码

        mov DWORD PTR [esi], ecx    ; action performed
        ;returning with handle in eax 

        pop ebp
        ret

EndCdecl     IFSMgr_Ring0_OpenCreateFile

; BOOL cdecl IFSMgr_Ring0_CloseFile(HANDLE filehandle, WORD *pError)
StartCdecl  IFSMgr_Ring0_CloseFile

filehandle EQU [ebp+8]
pError EQU [ebp+12]

        push ebp
        mov  ebp, esp

        mov ebx, filehandle         
        mov eax, R0_CLOSEFILE   ; func code
        VxDCall IFSMgr_Ring0_FileIO
        mov ecx, 1      ; assume returning true
        jnc @f
        mov esi, pError
        mov WORD PTR [esi], ax
        xor ecx, ecx    ; returning false
@@:
        mov eax, ecx  ;error code or zero

        pop ebp
        ret

    
EndCdecl     IFSMgr_Ring0_CloseFile

; DWORD cdecl IFSMgr_Ring0_WriteFile(BOOL bInContext, HANDLE filehandle, 
;                           PVOID buf, DWORD count, DWORD filepos, 
;                           WORD  *perr))
StartCdecl  IFSMgr_Ring0_WriteFile

bInContext EQU [ebp+8]
filehandle EQU [ebp+12]
buf EQU [ebp+16]
count EQU [ebp+20]
filepos EQU [ebp+24]
pError EQU [ebp+28]

        push ebp
        mov  ebp, esp

        mov ebx, filehandle          
        mov esi, buf           
        mov ecx, count        
        mov edx, filepos             
        mov eax, R0_WRITEFILE
        cmp WORD PTR bInContext, 0          
        je  @f
        mov eax, R0_WRITEFILE_IN_CONTEXT
@@:
        VxDCall IFSMgr_Ring0_FileIO
        jnc @f
        mov esi, pError              
        mov WORD PTR [esi], ax  ;give caller error code
        xor ecx, ecx            ;set byte count to zero on error
@@: 
        ; ecx contains count
        mov eax, ecx

        pop ebp
        ret 

EndCdecl     IFSMgr_Ring0_WriteFile

;  IRQHANDLE _stdcall VPICD_Virtualize_IRQ (VPICD_IRQ_DESCRIPTOR *pIrqDesc)
;
StartStdCall VPICD_Virtualize_IRQ, 4

	pop	edx			; save ret addr in unused reg
	pop	edi			; pIrqDesc
	VxDcall VPICD_Virtualize_IRQ
	jnc @f
	xor eax, eax	; carry set, error, so zero return code
@@:
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Virtualize_IRQ, 4

;  void _stdcall VPICD_Physically_Mask(IRQHANDLE hndIrq))
;
StartStdCall VPICD_Physically_Mask, 4

	pop	edx			; save ret addr in unused reg
	pop	eax			; hndIrq  
	VxDcall VPICD_Physically_Mask
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Physically_Mask, 4

;  void _stdcall VPICD_Physically_Unmask(IRQHANDLE hndIrq))
; 
StartStdCall VPICD_Physically_Unmask, 4

	pop	edx			; save ret addr in unused reg
	pop	eax			; hndIrq  
	VxDcall VPICD_Physically_Unmask
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Physically_Unmask, 4

;  void _stdcall VPICD_Force_Default_Behavior(IRQHANDLE hndIrq));
; y
StartStdCall VPICD_Force_Default_Behavior, 4

	pop	edx			; save ret addr in unused reg
	pop	eax			; hndIrq  
	VxDcall VPICD_Force_Default_Behavior
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Force_Default_Behavior, 4

;  void _stdcall VPICD_Phys_EOI(IRQHANDLE hndIrq))
;
StartStdCall VPICD_Phys_EOI, 4

	pop	edx			; save ret addr in unused reg
	pop	eax			; hndIrq  
	VxDcall VPICD_Phys_EOI
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Phys_EOI, 4

;  void _stdcall VPICD_Set_Int_Request(VMHANDLE hVM,, 
;                                      IRQHANDLE hndIrq
;
StartStdCall VPICD_Set_Int_Request, 8

	pop	edx			; save ret addr in unused reg
	pop   ebx         ; hVM  
	pop	eax			; hndIrq
	VxDcall VPICD_Set_Int_Request
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Set_Int_Request, 8

;  void _stdcall VPICD_Clear_Int_Request(VMHANDLE hVM, 
;                                      IRQHANDLE hIrq
;
StartStdCall VPICD_Clear_Int_Request, 8

	pop	edx			; save ret addr in unused reg
	pop   ebx         ; hVM  
	pop	eax			; hndIrq
	VxDcall VPICD_Clear_Int_Request
	jmp edx			; jump to caller's ret addr

EndStdCall   VPICD_Clear_Int_Request, 8


; DMAHANDLE cdecl VDMAD_Virtualize_Channel(BYTE ch  DMACALLBACK pfCallback )
StartCdecl  VDMAD_Virtualize_Channel

chan EQU [ebp+8]
pfCallback EQU [ebp+12]

        push ebp
        mov  ebp, esp

        movzx eax, BYTE PTR chan
        mov esi, pfCallback
        VxDCall VDMAD_Virtualize_Channel
        jnc @f
		xor eax, eax	; carry set, error so zero return code
@@:
        pop ebp
        ret

EndCdecl VDMAD_Virtualize_Channel

; void _stdcall VDMAD_Set_Region_Info( DMAHANDLE DMAHandle, BYTE BufferId,
;									BOOL LockStatus, 
; 									DWORD Region, DWORD RegionSize, DWORD PhysAddr
;
StartStdCall VDMAD_Set_Region_Info, 24

		pop edi		; save ret addr in unused reg
		pop	eax		; DMAHandle
		pop ebx		; BufferId
		xor bh, bh  ; BL=BufferId
		pop ecx		; LockStatus
		shl ecx, 4  ; CX=LockStatus
		xor cl, cl  ; CH=LockStatus
		or	bx, cx  ; BX=LockStatus|BufferId
		pop esi		; Region
		pop	ecx		; RegionSize
		pop	edx		; PhysAddr
        VxDCall VDMAD_Set_Region_Info
		jmp	edi		; jump to caller's ret addr
        ret

EndStdCall VDMAD_Set_Region_Info, 24

; void _stdcall VDMAD_Set_Phys_State( DMAHANDLE DMAHandle, VMHANDLE hVM,
; 									BYTE Mode, BYTE ExtMode
;
StartStdCall VDMAD_Set_Phys_State, 16 

		pop	esi		; save ret addr in unused reg
		pop	eax		; DMAHandle
		pop	ebx		; hVM
		pop	edx		; Mode
		xor	dh, dh	; DL=Mode
		pop	ecx		; ExtMode
		shl ecx, 4  ; CH=ExtMode
		xor cl, cl	; CH=ExtMode
		or	dx, cx	; DX=ExtMode|Mode
		VxDcall VDMAD_Set_Phys_State
		jmp	esi		; jump to caller's ret addr
		ret

EndStdCall    VDMAD_Set_Phys_State, 16

; void _stdcall VDMAD_Phys_Unmask_Channel( DMAHANDLE DMAHandle, VMHANDLE hVM)
;
StartStdCall  VDMAD_Phys_Unmask_Channel, 8
		
		pop	esi	; save ret addr in unused reg
		pop	edx	; DMAHandle
		pop ebx	; hVM
		VxDcall VDMAD_Phys_Unmask_Channel
		jmp esi	; jump to caller's ret addr
		ret

EndStdCall    VDMAD_Phys_Unmask_Channel, 8

; void _stdcall VDMAD_Phys_Mask_Channel( DMAHANDLE DMAHandle )
;
StartStdCall  VDMAD_Phys_Mask_Channel, 4
		
		pop	esi	; save ret addr in unused reg
		pop	eax	; DMAHandle
		VxDcall VDMAD_Phys_Mask_Channel
		jmp esi	; jump to caller's ret addr
		ret

EndStdCall    VDMAD_Phys_Mask_Channel, 4

; DWORD cdecl VDMAD_Scatter_Lock( VMHANDLE hVM, DWORD Flags,       
;                               PDDW pDDS, PDWORD pPteOffset )
StartCdecl  VDMAD_Scatter_Lock

hVM EQU [ebp+8]
Flags EQU BYTE PTR [ebp+12]
pDDS EQU [ebp+16]
pPteOffset EQU[ebp+20]

RET_NO_LOCKED EQU 0
RET_ALL_LOCKED EQU 1
RET_PART_LOCKED EQU 2
        push ebp
        mov  ebp, esp

        mov al,  BYTE PTR Flags          
        mov ebx, hVM
        mov edi, pDDS
        VxDCall VDMAD_Scatter_Lock
        jc no_lock
        jz all_lock
        mov eax, RET_PART_LOCKED
        jmp flags_checked
no_lock:
        mov eax, RET_NO_LOCKED
        jmp flags_checked
all_lock:
        mov eax, RET_ALL_LOCKED
flags_checked:
        mov ebx, pPteOffset
        mov DWORD PTR [ebx], esi        

        pop ebp
        ret

EndCdecl     VDMAD_Scatter_Lock

; VMHANDLE cdecl SHELL_Resolve_Contention( VMHANDLE hndOwner, 
;                                         VMHANDLE hndContender, 
;                                         char *DeviceName )
;
StartStdCall  SHELL_Resolve_Contention, 12
		
		pop	edx	   ; save ret addr in unused reg
		pop	eax	   ; hndOwner
      pop   ebx      ; hndContender
      pop   esi      ; DeviceName
		VxDcall SHELL_Resolve_Contention
      mov   eax, edi ; move VM handle into return 
      jnc   @f
      xor   eax, eax ; carry set, error, so zero return code
@@:
		jmp   edx	; jump to caller's ret addr
		ret

EndStdCall    SHELL_Resolve_Contention, 12


; BOOL _SHELL_PostMessage( DWORD hWnd, WORD uMsg, 
;                          WORD wParam, DWORD lParam,
;                          CALLBACK pfnCallback, DWORD dwRefData );
;

MakeCDecl   _SHELL_PostMessage

; void VWIN32_QueueUserApc( void * pfnRing3APC, 
;                          DWORD dwParam, 
;                          PTCB hThread);
;

MakeCDecl   _VWIN32_QueueUserApc

;  BOOL VWIN32_SetWin32Event(HANDLE hEvent);
;

MakeCDecl   _VWIN32_SetWin32Event

END