Index: /trunk/include/VBox/Graphics/VBoxVideo.h =================================================================== --- /trunk/include/VBox/Graphics/VBoxVideo.h (revision 71591) +++ /trunk/include/VBox/Graphics/VBoxVideo.h (revision 71592) @@ -347,28 +347,30 @@ } VBOXVHWACMD_TYPE; -/* the command processing was asynch, set by the host to indicate asynch command completion - * must not be cleared once set, the command completion is performed by issuing a host->guest completion command - * while keeping this flag unchanged */ -#define VBOXVHWACMD_FLAG_HG_ASYNCH 0x00010000 -/* asynch completion is performed by issuing the event */ -#define VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT 0x00000001 -/* issue interrupt on asynch completion */ -#define VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ 0x00000002 -/* guest does not do any op on completion of this command, the host may copy the command and indicate that it does not need the command anymore +/** The command processing was asynch, set by the host to indicate asynch + * command completion. Must not be cleared once set, the command completion is + * performed by issuing a host->guest completion command while keeping this + * flag unchanged */ +#define VBOXVHWACMD_FLAG_HG_ASYNCH UINT32_C(0x00010000) +/** asynch completion is performed by issuing the event */ +#define VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT UINT32_C(0x00000001) +/** issue interrupt on asynch completion */ +#define VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ UINT32_C(0x00000002) +/** Guest does not do any op on completion of this command, the host may copy + * the command and indicate that it does not need the command anymore * by setting the VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED flag */ -#define VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION 0x00000004 -/* the host has copied the VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION command and returned it to the guest */ -#define VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED 0x00020000 -/* this is the host->host cmd, i.e. a configuration command posted by the host to the framebuffer */ -#define VBOXVHWACMD_FLAG_HH_CMD 0x10000000 +#define VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION UINT32_C(0x00000004) +/** the host has copied the VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION command and returned it to the guest */ +#define VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED UINT32_C(0x00020000) +/** this is the host->host cmd, i.e. a configuration command posted by the host to the framebuffer */ +#define VBOXVHWACMD_FLAG_HH_CMD UINT32_C(0x10000000) typedef struct VBOXVHWACMD { - VBOXVHWACMD_TYPE enmCmd; /* command type */ - volatile int32_t rc; /* command result */ - int32_t iDisplay; /* display index */ - volatile int32_t Flags; /* ored VBOXVHWACMD_FLAG_xxx values */ - uint64_t GuestVBVAReserved1; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */ - uint64_t GuestVBVAReserved2; /* field internally used by the guest VBVA cmd handling, must NOT be modified by clients */ + VBOXVHWACMD_TYPE enmCmd; /**< command type */ + volatile int32_t rc; /**< command result */ + int32_t iDisplay; /**< display index */ + volatile int32_t Flags; /**< ORed VBOXVHWACMD_FLAG_xxx values */ + uint64_t GuestVBVAReserved1; /**< field internally used by the guest VBVA cmd handling, must NOT be modified by clients */ + uint64_t GuestVBVAReserved2; /**< field internally used by the guest VBVA cmd handling, must NOT be modified by clients */ volatile uint32_t cRefs; int32_t Reserved; @@ -376,18 +378,22 @@ { struct VBOXVHWACMD *pNext; - uint32_t offNext; - uint64_t Data; /* the body is 64-bit aligned */ + uint32_t offNext; + uint64_t Data; /**< the body is 64-bit aligned */ } u; char body[1]; } VBOXVHWACMD; -#define VBOXVHWACMD_HEADSIZE() (RT_OFFSETOF(VBOXVHWACMD, body)) -#define VBOXVHWACMD_SIZE_FROMBODYSIZE(_s) (VBOXVHWACMD_HEADSIZE() + (_s)) -#define VBOXVHWACMD_SIZE(_tCmd) (VBOXVHWACMD_SIZE_FROMBODYSIZE(sizeof(_tCmd))) +#define VBOXVHWACMD_HEADSIZE() (RT_OFFSETOF(VBOXVHWACMD, body)) +#define VBOXVHWACMD_SIZE_FROMBODYSIZE(a_cbBody) (VBOXVHWACMD_HEADSIZE() + (a_cbBody)) +#define VBOXVHWACMD_SIZE(a_tTypeCmd) (VBOXVHWACMD_SIZE_FROMBODYSIZE(sizeof(a_tTypeCmd))) typedef unsigned int VBOXVHWACMD_LENGTH; typedef uint64_t VBOXVHWA_SURFHANDLE; -#define VBOXVHWA_SURFHANDLE_INVALID 0ULL -#define VBOXVHWACMD_BODY(_p, _t) ((_t*)(_p)->body) -#define VBOXVHWACMD_HEAD(_pb) ((VBOXVHWACMD*)((uint8_t *)(_pb) - RT_OFFSETOF(VBOXVHWACMD, body))) +#define VBOXVHWA_SURFHANDLE_INVALID UINT64_C(0) +#define VBOXVHWACMD_BODY(a_pHdr, a_TypeBody) ( (a_TypeBody RT_UNTRUSTED_VOLATILE_HSTGST *)&(a_pHdr)->body[0] ) +#if !defined(IN_GUEST) && defined(IN_RING3) +# define VBOXVHWACMD_BODY_HOST_HEAP(a_pHdr, a_TypeBody) ( (a_TypeBody *)&(a_pHdr)->body[0] ) +#endif +#define VBOXVHWACMD_HEAD(a_pBody)\ + ( (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HSTGST *)((uint8_t *)(a_pBody) - RT_OFFSETOF(VBOXVHWACMD, body))) typedef struct VBOXVHWA_RECTL @@ -968,10 +974,11 @@ } u; char body[1]; -}VBVAHOSTCMD; - -#define VBVAHOSTCMD_SIZE(_size) (sizeof(VBVAHOSTCMD) + (_size)) -#define VBVAHOSTCMD_BODY(_pCmd, _tBody) ((_tBody*)(_pCmd)->body) -#define VBVAHOSTCMD_HDR(_pBody) ((VBVAHOSTCMD*)(((uint8_t*)_pBody) - RT_OFFSETOF(VBVAHOSTCMD, body))) -#define VBVAHOSTCMD_HDRSIZE (RT_OFFSETOF(VBVAHOSTCMD, body)) +} VBVAHOSTCMD; + +#define VBVAHOSTCMD_SIZE(a_cb) (sizeof(VBVAHOSTCMD) + (a_cb)) +#define VBVAHOSTCMD_BODY(a_pCmd, a_TypeBody) ((a_TypeBody RT_UNTRUSTED_VOLATILE_HSTGST *)&(a_pCmd)->body[0]) +#define VBVAHOSTCMD_HDR(a_pBody) \ + ( (VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HSTGST *)( (uint8_t *)(a_pBody) - RT_OFFSETOF(VBVAHOSTCMD, body)) ) +#define VBVAHOSTCMD_HDRSIZE (RT_OFFSETOF(VBVAHOSTCMD, body)) #pragma pack() Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h (revision 71592) @@ -65,13 +65,14 @@ typedef void* HVBOXVIDEOHGSMI; -/* Complete host commands addressed to the display */ -typedef DECLCALLBACK(void) FNVBOXVIDEOHGSMICOMPLETION(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD * pCmd); +/** Complete host commands addressed to the display */ +typedef DECLCALLBACK(void) FNVBOXVIDEOHGSMICOMPLETION(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST * pCmd); typedef FNVBOXVIDEOHGSMICOMPLETION *PFNVBOXVIDEOHGSMICOMPLETION; -/* request the host commands addressed to the display */ -typedef DECLCALLBACK(int) FNVBOXVIDEOHGSMICOMMANDS(HVBOXVIDEOHGSMI hHGSMI, uint8_t u8Channel, uint32_t iDevice, struct VBVAHOSTCMD ** ppCmd); +/** request the host commands addressed to the display */ +typedef DECLCALLBACK(int) FNVBOXVIDEOHGSMICOMMANDS(HVBOXVIDEOHGSMI hHGSMI, uint8_t u8Channel, uint32_t iDevice, + struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST ** ppCmd); typedef FNVBOXVIDEOHGSMICOMMANDS *PFNVBOXVIDEOHGSMICOMMANDS; -/* post guest command (offset) to the host */ +/** post guest command (offset) to the host */ typedef DECLCALLBACK(void) FNVBOXVIDEOHGSMIPOSTCOMMAND(HVBOXVIDEOHGSMI hHGSMI, HGSMIOFFSET offCmd); typedef FNVBOXVIDEOHGSMIPOSTCOMMAND *PFNVBOXVIDEOHGSMIPOSTCOMMAND; @@ -105,5 +106,5 @@ } HGSMIQUERYCPORTPROCS; -/* Data returned by IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS. */ +/** Data returned by IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS. */ typedef struct _HGSMIQUERYCALLBACKS { Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp (revision 71592) @@ -32,6 +32,4 @@ if(pDev->vhwa.bEnabled) { - VBOXVHWACMD* pCmd; - uint32_t unsupportedSCaps = VBoxDispVHWAUnsupportedDDSCAPS(lpDDS->ddsCaps.dwCaps); if(unsupportedSCaps) @@ -50,10 +48,10 @@ } - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CANCREATE, sizeof(VBOXVHWACMD_SURF_CANCREATE)); - if(pCmd) + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CANCREATE, sizeof(VBOXVHWACMD_SURF_CANCREATE)); + if (pCmd) { int rc; - VBOXVHWACMD_SURF_CANCREATE *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CANCREATE)); + VBOXVHWACMD_SURF_CANCREATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE); rc = VBoxDispVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpDDS); @@ -140,14 +138,12 @@ if(pDev->vhwa.bEnabled) { - VBOXVHWACMD* pCmd; - - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE)); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE)); if (pCmd) { - VBOXVHWACMD_SURF_CREATE *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE); + VBOXVHWACMD_SURF_CREATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE); PVBOXVHWASURFDESC pDesc; int rc; - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE)); rc = VBoxDispVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpCreateSurface->lpDDSurfaceDesc); VBOX_WARNRC(rc); @@ -259,15 +255,12 @@ if (pDev->vhwa.bEnabled) { - VBOXVHWACMD* pCmd; - - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY)); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY)); if (pCmd) { - VBOXVHWACMD_SURF_DESTROY *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY); PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpDestroySurface->lpDDSurface->lpGbl->dwReserved1; - if (pDesc) { - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY)); + VBOXVHWACMD_SURF_DESTROY RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY); pBody->u.in.hSurf = pDesc->hHostHandle; @@ -403,11 +396,9 @@ else { - VBOXVHWACMD *pCmd; - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK)); - + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK)); if (pCmd) { - VBOXVHWACMD_SURF_LOCK *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_LOCK)); + VBOXVHWACMD_SURF_LOCK RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK); pBody->u.in.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSurf->lpGbl->fpVidMem); @@ -500,11 +491,9 @@ || ((pSurf->ddsCaps.dwCaps & DDSCAPS_OVERLAY) && pDesc->bVisible)) { - VBOXVHWACMD *pCmd; - pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK)); - - if(pCmd) - { - VBOXVHWACMD_SURF_UNLOCK *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK)); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK)); + if (pCmd) + { + VBOXVHWACMD_SURF_UNLOCK RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK); pBody->u.in.hSurf = pDesc->hHostHandle; Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp (revision 71592) @@ -20,10 +20,12 @@ #include -static DECLCALLBACK(void) VBoxDispVHWASurfBltCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD *pCmd, void *pvContext) +/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */ +static DECLCALLBACK(void) +VBoxDispVHWASurfBltCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, void *pvContext) { RT_NOREF(pvContext); - VBOXVHWACMD_SURF_BLT *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT); - PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)pBody->SrcGuestSurfInfo; - PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)pBody->DstGuestSurfInfo; + VBOXVHWACMD_SURF_BLT RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT); + PVBOXVHWASURFDESC pSrcDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->SrcGuestSurfInfo; + PVBOXVHWASURFDESC pDestDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->DstGuestSurfInfo; ASMAtomicDecU32(&pSrcDesc->cPendingBltsSrc); @@ -33,10 +35,12 @@ } -static DECLCALLBACK(void) VBoxDispVHWASurfFlipCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD *pCmd, void *pvContext) +/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */ +static DECLCALLBACK(void) +VBoxDispVHWASurfFlipCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, void *pvContext) { RT_NOREF(pvContext); - VBOXVHWACMD_SURF_FLIP *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); - PVBOXVHWASURFDESC pCurrDesc = (PVBOXVHWASURFDESC)pBody->CurrGuestSurfInfo; - PVBOXVHWASURFDESC pTargDesc = (PVBOXVHWASURFDESC)pBody->TargGuestSurfInfo; + VBOXVHWACMD_SURF_FLIP RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); + PVBOXVHWASURFDESC pCurrDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->CurrGuestSurfInfo; + PVBOXVHWASURFDESC pTargDesc = (PVBOXVHWASURFDESC)(uintptr_t)pBody->TargGuestSurfInfo; ASMAtomicDecU32(&pCurrDesc->cPendingFlipsCurr); @@ -164,5 +168,4 @@ DD_SURFACE_LOCAL *pSurf = lpSetColorKey->lpDDSurface; PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)pSurf->lpGbl->dwReserved1; - VBOXVHWACMD* pCmd; lpSetColorKey->ddRVal = DD_OK; @@ -170,10 +173,9 @@ if (pDesc) { - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_COLORKEY_SET, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET)); - + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = + VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_COLORKEY_SET, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET)); if (pCmd) { - VBOXVHWACMD_SURF_COLORKEY_SET *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORKEY_SET)); + VBOXVHWACMD_SURF_COLORKEY_SET RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET); pBody->u.in.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSurf->lpGbl->fpVidMem); @@ -222,11 +224,10 @@ if (pSrcDesc && pDstDesc) { - VBOXVHWACMD *pCmd; + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd; pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_BLT, sizeof(VBOXVHWACMD_SURF_BLT)); if (pCmd) { - VBOXVHWACMD_SURF_BLT *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_BLT)); + VBOXVHWACMD_SURF_BLT RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT); pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem); @@ -301,12 +302,9 @@ } - VBOXVHWACMD *pCmd; - - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP)); - + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP)); if (pCmd) { - VBOXVHWACMD_SURF_FLIP *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_FLIP)); + VBOXVHWACMD_SURF_FLIP RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); pBody->u.in.offCurrSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pCurrSurf->lpGbl->fpVidMem); @@ -457,11 +455,9 @@ } - VBOXVHWACMD *pCmd; - - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION)); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION)); if (pCmd) { - VBOXVHWACMD_SURF_OVERLAY_SETPOSITION *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_SETPOSITION)); + VBOXVHWACMD_SURF_OVERLAY_SETPOSITION RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION); pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem); @@ -505,11 +501,9 @@ if (pSrcDesc) { - VBOXVHWACMD* pCmd; - - pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd + = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); if (pCmd) { - VBOXVHWACMD_SURF_OVERLAY_UPDATE *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE); - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); + VBOXVHWACMD_SURF_OVERLAY_UPDATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE); pBody->u.in.offSrcSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSrcSurf->lpGbl->fpVidMem); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h (revision 71592) @@ -131,5 +131,5 @@ /* VBVA related */ int VBoxDispVBVAInit(PVBOXDISPDEV pDev); -void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD *pCmd); +void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd); void vrdpReportDirtyRect(PVBOXDISPDEV pDev, RECTL *prcl); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp (revision 71592) @@ -482,5 +482,5 @@ } -void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD *pCmd) +void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { pDev->hgsmi.mp.pfnCompletionHandler(pDev->hgsmi.mp.hContext, pCmd); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.cpp (revision 71592) @@ -21,15 +21,16 @@ #include -static void VBoxDispVHWACommandFree(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd) +static void VBoxDispVHWACommandFree(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { VBoxHGSMIBufferFree(&pDev->hgsmi.ctx, pCmd); } -static void VBoxDispVHWACommandRetain(VBOXVHWACMD* pCmd) +static void VBoxDispVHWACommandRetain(VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { ASMAtomicIncU32(&pCmd->cRefs); } -static void VBoxDispVHWACommandSubmitAsynchByEvent(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd, VBOXPEVENT pEvent) +static void VBoxDispVHWACommandSubmitAsynchByEvent(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, + VBOXPEVENT pEvent) { pCmd->GuestVBVAReserved1 = (uintptr_t)pEvent; @@ -51,10 +52,12 @@ } -static void VBoxDispVHWAHanldeVHWACmdCompletion(PVBOXDISPDEV pDev, VBVAHOSTCMD * pHostCmd) -{ - VBVAHOSTCMDVHWACMDCOMPLETE * pComplete = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE); - VBOXVHWACMD* pComplCmd = (VBOXVHWACMD*)HGSMIOffsetToPointer(&pDev->hgsmi.ctx.heapCtx.area, pComplete->offCmd); - PFNVBOXVHWACMDCOMPLETION pfnCompletion = (PFNVBOXVHWACMDCOMPLETION)pComplCmd->GuestVBVAReserved1; - void *pContext = (void *)pComplCmd->GuestVBVAReserved2; +static void VBoxDispVHWAHanldeVHWACmdCompletion(PVBOXDISPDEV pDev, VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pHostCmd) +{ + VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_HOST *pComplete = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pComplCmd = + (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *)HGSMIOffsetToPointer(&pDev->hgsmi.ctx.heapCtx.area, pComplete->offCmd); + + PFNVBOXVHWACMDCOMPLETION pfnCompletion = (PFNVBOXVHWACMDCOMPLETION)(uintptr_t)pComplCmd->GuestVBVAReserved1; + void *pContext = (void *)(uintptr_t)pComplCmd->GuestVBVAReserved2; pfnCompletion(pDev, pComplCmd, pContext); @@ -63,17 +66,14 @@ } -static void VBoxVHWAHostCommandHandler(PVBOXDISPDEV pDev, VBVAHOSTCMD * pCmd) -{ - switch(pCmd->customOpCode) +static void VBoxVHWAHostCommandHandler(PVBOXDISPDEV pDev, VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) +{ + switch (pCmd->customOpCode) { case VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE: - { VBoxDispVHWAHanldeVHWACmdCompletion(pDev, pCmd); break; - } + default: - { VBoxDispVBVAHostCommandComplete(pDev, pCmd); - } } } @@ -96,5 +96,4 @@ { int rc = VERR_GENERAL_FAILURE; - VBOXVHWACMD* pCmd; if (!pDev->hgsmi.bSupported) @@ -103,5 +102,5 @@ } - pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_ENABLE, 0); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_ENABLE, 0); if (!pCmd) { @@ -110,11 +109,7 @@ } - if(VBoxDispVHWACommandSubmit(pDev, pCmd)) - { - if(RT_SUCCESS(pCmd->rc)) - { + if (VBoxDispVHWACommandSubmit(pDev, pCmd)) + if (RT_SUCCESS(pCmd->rc)) rc = VINF_SUCCESS; - } - } VBoxDispVHWACommandRelease(pDev, pCmd); @@ -122,10 +117,10 @@ } -VBOXVHWACMD* VBoxDispVHWACommandCreate(PVBOXDISPDEV pDev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd) -{ - VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxHGSMIBufferAlloc(&pDev->hgsmi.ctx, - cbCmd + VBOXVHWACMD_HEADSIZE(), - HGSMI_CH_VBVA, - VBVA_VHWA_CMD); +VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * +VBoxDispVHWACommandCreate(PVBOXDISPDEV pDev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd) +{ + uint32_t cbTotal = cbCmd + VBOXVHWACMD_HEADSIZE(); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pHdr + = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(&pDev->hgsmi.ctx, cbTotal, HGSMI_CH_VBVA, VBVA_VHWA_CMD); if (!pHdr) { @@ -134,5 +129,5 @@ else { - memset(pHdr, 0, sizeof(VBOXVHWACMD)); + memset((void *)pHdr, 0, cbTotal); /* always clear the whole body so caller doesn't need to */ pHdr->iDisplay = pDev->iDevice; pHdr->rc = VERR_GENERAL_FAILURE; @@ -147,15 +142,13 @@ } -void VBoxDispVHWACommandRelease(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd) +void VBoxDispVHWACommandRelease(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs); Assert(cRefs < UINT32_MAX / 2); - if(!cRefs) - { + if (!cRefs) VBoxDispVHWACommandFree(pDev, pCmd); - } -} - -BOOL VBoxDispVHWACommandSubmit(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd) +} + +BOOL VBoxDispVHWACommandSubmit(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { VBOXPEVENT pEvent; @@ -181,13 +174,14 @@ void VBoxDispVHWACommandCheckHostCmds(PVBOXDISPDEV pDev) { - VBVAHOSTCMD *pCmd, *pNextCmd; + VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd; int rc = pDev->hgsmi.mp.pfnRequestCommandsHandler(pDev->hgsmi.mp.hContext, HGSMI_CH_VBVA, pDev->iDevice, &pCmd); /* don't assert here, otherwise NT4 will be unhappy */ - if(RT_SUCCESS(rc)) - { - for(;pCmd; pCmd = pNextCmd) + if (RT_SUCCESS(rc)) + { + while (pCmd) { - pNextCmd = pCmd->u.pNext; + VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pNextCmd = pCmd->u.pNext; VBoxVHWAHostCommandHandler(pDev, pCmd); + pCmd = pNextCmd; } } @@ -203,5 +197,6 @@ /* do not wait for completion */ -void VBoxDispVHWACommandSubmitAsynch (PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext) +void VBoxDispVHWACommandSubmitAsynch(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, + PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext) { pCmd->GuestVBVAReserved1 = (uintptr_t)pfnCompletion; @@ -220,5 +215,6 @@ } -static DECLCALLBACK(void) VBoxDispVHWAFreeCmdCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD *pCmd, void *pvContext) +static DECLCALLBACK(void) VBoxDispVHWAFreeCmdCompletion(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, + void *pvContext) { RT_NOREF(pvContext); @@ -226,5 +222,5 @@ } -void VBoxDispVHWACommandSubmitAsynchAndComplete (PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd) +void VBoxDispVHWACommandSubmitAsynchAndComplete (PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { pCmd->GuestVBVAReserved1 = (uintptr_t)VBoxDispVHWAFreeCmdCompletion; @@ -236,6 +232,7 @@ VBoxHGSMIBufferSubmit(&pDev->hgsmi.ctx, pCmd); - if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH) - || pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED) + uint32_t const fCmdFlags = pCmd->Flags; + if ( !(fCmdFlags & VBOXVHWACMD_FLAG_HG_ASYNCH) + || (fCmdFlags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)) { /* the command is completed */ @@ -246,20 +243,20 @@ } -void VBoxDispVHWAFreeHostInfo1(PVBOXDISPDEV pDev, VBOXVHWACMD_QUERYINFO1* pInfo) -{ - VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo); - VBoxDispVHWACommandRelease(pDev, pCmd); -} - -void VBoxDispVHWAFreeHostInfo2(PVBOXDISPDEV pDev, VBOXVHWACMD_QUERYINFO2* pInfo) -{ - VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo); - VBoxDispVHWACommandRelease(pDev, pCmd); -} - -VBOXVHWACMD_QUERYINFO1* VBoxDispVHWAQueryHostInfo1(PVBOXDISPDEV pDev) -{ - VBOXVHWACMD* pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1)); - VBOXVHWACMD_QUERYINFO1 *pInfo1; +void VBoxDispVHWAFreeHostInfo1(PVBOXDISPDEV pDev, VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBOXVHWACMD_HEAD(pInfo); + VBoxDispVHWACommandRelease(pDev, pCmd); +} + +void VBoxDispVHWAFreeHostInfo2(PVBOXDISPDEV pDev, VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBOXVHWACMD_HEAD(pInfo); + VBoxDispVHWACommandRelease(pDev, pCmd); +} + +static VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *VBoxDispVHWAQueryHostInfo1(PVBOXDISPDEV pDev) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_QUERY_INFO1, + sizeof(VBOXVHWACMD_QUERYINFO1)); if (!pCmd) { @@ -268,5 +265,5 @@ } - pInfo1 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1); + VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo1= VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1); pInfo1->u.in.guestVersion.maj = VBOXVHWA_VERSION_MAJ; pInfo1->u.in.guestVersion.min = VBOXVHWA_VERSION_MIN; @@ -286,8 +283,8 @@ } -VBOXVHWACMD_QUERYINFO2* VBoxDispVHWAQueryHostInfo2(PVBOXDISPDEV pDev, uint32_t numFourCC) -{ - VBOXVHWACMD* pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC)); - VBOXVHWACMD_QUERYINFO2 *pInfo2; +static VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *VBoxDispVHWAQueryHostInfo2(PVBOXDISPDEV pDev, uint32_t numFourCC) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_QUERY_INFO2, + VBOXVHWAINFO2_SIZE(numFourCC)); if (!pCmd) { @@ -296,17 +293,10 @@ } - pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2); + VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2); pInfo2->numFourCC = numFourCC; - - if(VBoxDispVHWACommandSubmit (pDev, pCmd)) - { - if(RT_SUCCESS(pCmd->rc)) - { - if(pInfo2->numFourCC == numFourCC) - { + if (VBoxDispVHWACommandSubmit(pDev, pCmd)) + if (RT_SUCCESS(pCmd->rc)) + if (pInfo2->numFourCC == numFourCC) return pInfo2; - } - } - } VBoxDispVHWACommandRelease(pDev, pCmd); @@ -316,10 +306,9 @@ int VBoxDispVHWAInitHostInfo1(PVBOXDISPDEV pDev) { - VBOXVHWACMD_QUERYINFO1* pInfo; if (!pDev->hgsmi.bSupported) return VERR_NOT_SUPPORTED; - pInfo = VBoxDispVHWAQueryHostInfo1(pDev); + VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo = VBoxDispVHWAQueryHostInfo1(pDev); if(!pInfo) { @@ -336,4 +325,5 @@ pDev->vhwa.numFourCC = pInfo->u.out.numFourCC; pDev->vhwa.bEnabled = (pInfo->u.out.cfgFlags & VBOXVHWA_CFG_ENABLED); + VBoxDispVHWAFreeHostInfo1(pDev, pInfo); return VINF_SUCCESS; @@ -342,5 +332,4 @@ int VBoxDispVHWAInitHostInfo2(PVBOXDISPDEV pDev, DWORD *pFourCC) { - VBOXVHWACMD_QUERYINFO2* pInfo; int rc = VINF_SUCCESS; @@ -348,14 +337,11 @@ return VERR_NOT_SUPPORTED; - pInfo = VBoxDispVHWAQueryHostInfo2(pDev, pDev->vhwa.numFourCC); - + VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo = VBoxDispVHWAQueryHostInfo2(pDev, pDev->vhwa.numFourCC); Assert(pInfo); if(!pInfo) return VERR_OUT_OF_RESOURCES; - if(pDev->vhwa.numFourCC) - { - memcpy(pFourCC, pInfo->FourCC, pDev->vhwa.numFourCC * sizeof(pFourCC[0])); - } + if (pDev->vhwa.numFourCC) + memcpy(pFourCC, (void const *)pInfo->FourCC, pDev->vhwa.numFourCC * sizeof(pFourCC[0])); else { @@ -372,10 +358,9 @@ { int rc = VERR_GENERAL_FAILURE; - VBOXVHWACMD* pCmd; if (!pDev->hgsmi.bSupported) return VERR_NOT_SUPPORTED; - pCmd = VBoxDispVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_DISABLE, 0); + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_DISABLE, 0); if (!pCmd) { @@ -384,11 +369,7 @@ } - if(VBoxDispVHWACommandSubmit (pDev, pCmd)) - { + if (VBoxDispVHWACommandSubmit(pDev, pCmd)) if(RT_SUCCESS(pCmd->rc)) - { rc = VINF_SUCCESS; - } - } VBoxDispVHWACommandRelease(pDev, pCmd); @@ -652,5 +633,5 @@ } -void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY *pVHWACKey, DDCOLORKEY *pDdCKey) +void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY RT_UNTRUSTED_VOLATILE_HOST *pVHWACKey, DDCOLORKEY *pDdCKey) { pVHWACKey->low = pDdCKey->dwColorSpaceLowValue; @@ -658,5 +639,5 @@ } -void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX *pVHWAOverlay, DDOVERLAYFX *pDdOverlay) +void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX RT_UNTRUSTED_VOLATILE_HOST *pVHWAOverlay, DDOVERLAYFX *pDdOverlay) { /// @todo fxFlags @@ -665,5 +646,5 @@ } -void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX *pVHWABlt, DDBLTFX *pDdBlt) +void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX RT_UNTRUSTED_VOLATILE_HOST *pVHWABlt, DDBLTFX *pDdBlt) { pVHWABlt->fillColor = pDdBlt->dwFillColor; @@ -673,5 +654,5 @@ } -int VBoxDispVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT *pVHWAFormat, DDPIXELFORMAT *pDdFormat) +int VBoxDispVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT RT_UNTRUSTED_VOLATILE_HOST *pVHWAFormat, DDPIXELFORMAT *pDdFormat) { uint32_t unsup = VBoxDispVHWAUnsupportedDDPFS(pDdFormat->dwFlags); @@ -689,5 +670,5 @@ } -int VBoxDispVHWAFromDDSURFACEDESC(VBOXVHWA_SURFACEDESC *pVHWADesc, DDSURFACEDESC *pDdDesc) +int VBoxDispVHWAFromDDSURFACEDESC(VBOXVHWA_SURFACEDESC RT_UNTRUSTED_VOLATILE_HOST *pVHWADesc, DDSURFACEDESC *pDdDesc) { uint32_t unsupds = VBoxDispVHWAUnsupportedDSS(pDdDesc->dwFlags); @@ -757,5 +738,13 @@ } -void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL *pSrc) +void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL const *pSrc) +{ + pDst->left = pSrc->left; + pDst->top = pSrc->top; + pDst->right = pSrc->right; + pDst->bottom = pSrc->bottom; +} + +void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL RT_UNTRUSTED_VOLATILE_HOST *pDst, RECTL const *pSrc) { pDst->left = pSrc->left; Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.h (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.h (revision 71592) @@ -59,18 +59,19 @@ }VBOXVHWASURFDESC, *PVBOXVHWASURFDESC; -typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PVBOXDISPDEV pDev, VBOXVHWACMD * pCmd, void * pContext); +typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, void *pvContext); typedef FNVBOXVHWACMDCOMPLETION *PFNVBOXVHWACMDCOMPLETION; void VBoxDispVHWAInit(PVBOXDISPDEV pDev); -int VBoxDispVHWAEnable(PVBOXDISPDEV pDev); -int VBoxDispVHWADisable(PVBOXDISPDEV pDev); -int VBoxDispVHWAInitHostInfo1(PVBOXDISPDEV pDev); -int VBoxDispVHWAInitHostInfo2(PVBOXDISPDEV pDev, DWORD *pFourCC); +int VBoxDispVHWAEnable(PVBOXDISPDEV pDev); +int VBoxDispVHWADisable(PVBOXDISPDEV pDev); +int VBoxDispVHWAInitHostInfo1(PVBOXDISPDEV pDev); +int VBoxDispVHWAInitHostInfo2(PVBOXDISPDEV pDev, DWORD *pFourCC); -VBOXVHWACMD* VBoxDispVHWACommandCreate(PVBOXDISPDEV pDev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd); -void VBoxDispVHWACommandRelease(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd); -BOOL VBoxDispVHWACommandSubmit(PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd); -void VBoxDispVHWACommandSubmitAsynch (PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext); -void VBoxDispVHWACommandSubmitAsynchAndComplete (PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd); +VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *VBoxDispVHWACommandCreate(PVBOXDISPDEV pDev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd); +void VBoxDispVHWACommandRelease(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd); +BOOL VBoxDispVHWACommandSubmit(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST*pCmd); +void VBoxDispVHWACommandSubmitAsynch(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, + PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext); +void VBoxDispVHWACommandSubmitAsynchAndComplete(PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd); void VBoxDispVHWACommandCheckHostCmds(PVBOXDISPDEV pDev); @@ -111,10 +112,11 @@ uint32_t VBoxDispVHWAToDDCKEYs(uint32_t caps); -int VBoxDispVHWAFromDDSURFACEDESC(VBOXVHWA_SURFACEDESC *pVHWADesc, DDSURFACEDESC *pDdDesc); -int VBoxDispVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT *pVHWAFormat, DDPIXELFORMAT *pDdFormat); -void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX *pVHWAOverlay, DDOVERLAYFX *pDdOverlay); -void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY *pVHWACKey, DDCOLORKEY *pDdCKey); -void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX *pVHWABlt, DDBLTFX *pDdBlt); -void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL *pSrc); +int VBoxDispVHWAFromDDSURFACEDESC(VBOXVHWA_SURFACEDESC RT_UNTRUSTED_VOLATILE_HOST *pVHWADesc, DDSURFACEDESC *pDdDesc); +int VBoxDispVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT RT_UNTRUSTED_VOLATILE_HOST *pVHWAFormat, DDPIXELFORMAT *pDdFormat); +void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX RT_UNTRUSTED_VOLATILE_HOST *pVHWAOverlay, DDOVERLAYFX *pDdOverlay); +void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY RT_UNTRUSTED_VOLATILE_HOST *pVHWACKey, DDCOLORKEY *pDdCKey); +void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX RT_UNTRUSTED_VOLATILE_HOST *pVHWABlt, DDBLTFX *pDdBlt); +void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL const *pSrc); +void VBoxDispVHWAFromRECTL(VBOXVHWA_RECTL RT_UNTRUSTED_VOLATILE_HOST *pDst, RECTL const *pSrc); uint32_t VBoxDispVHWAUnsupportedDDCAPS(uint32_t caps); @@ -127,3 +129,4 @@ uint32_t VBoxDispVHWASupportedDDCEYCAPS(uint32_t caps); -#endif /*VBOXDISPVHWA_H*/ +#endif /* !VBOXDISPVHWA_H */ + Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp (revision 71592) @@ -25,4 +25,11 @@ #define VBOXVHWA_PRIMARY_ALLOCATION(_pSrc) ((_pSrc)->pPrimaryAllocation) + +#define VBOXVHWA_COPY_RECT(a_pDst, a_pSrc) do { \ + (a_pDst)->left = (a_pSrc)->left; \ + (a_pDst)->top = (a_pSrc)->top; \ + (a_pDst)->right = (a_pSrc)->right; \ + (a_pDst)->bottom = (a_pSrc)->bottom; \ + } while(0) @@ -222,17 +229,18 @@ } -void vboxVhwaFreeHostInfo1(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO1* pInfo) -{ - VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo); +static void vboxVhwaFreeHostInfo1(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBOXVHWACMD_HEAD(pInfo); vboxVhwaCommandFree(pDevExt, pCmd); } -void vboxVhwaFreeHostInfo2(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO2* pInfo) -{ - VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo); +static void vboxVhwaFreeHostInfo2(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo) +{ + VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBOXVHWACMD_HEAD(pInfo); vboxVhwaCommandFree(pDevExt, pCmd); } -VBOXVHWACMD_QUERYINFO1* vboxVhwaQueryHostInfo1(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) +static VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST * +vboxVhwaQueryHostInfo1(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId) { VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, @@ -240,5 +248,5 @@ AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), NULL); - VBOXVHWACMD_QUERYINFO1 *pInfo1 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1); + VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo1 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1); pInfo1->u.in.guestVersion.maj = VBOXVHWA_VERSION_MAJ; pInfo1->u.in.guestVersion.min = VBOXVHWA_VERSION_MIN; @@ -256,5 +264,6 @@ } -VBOXVHWACMD_QUERYINFO2* vboxVhwaQueryHostInfo2(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC) +static VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST * +vboxVhwaQueryHostInfo2(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC) { VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, @@ -262,19 +271,15 @@ AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), NULL); - VBOXVHWACMD_QUERYINFO2 *pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2); + VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2); pInfo2->numFourCC = numFourCC; int rc = vboxVhwaCommandSubmit(pDevExt, pCmd); AssertRC(rc); - if(RT_SUCCESS(rc)) + if (RT_SUCCESS(rc)) { AssertRC(pCmd->rc); if(RT_SUCCESS(pCmd->rc)) - { if(pInfo2->numFourCC == numFourCC) - { return pInfo2; - } - } } @@ -340,5 +345,5 @@ vboxVhwaHlpOverlayListInit(pDevExt, srcId); - VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVhwaQueryHostInfo1(pDevExt, srcId); + VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo1 = vboxVhwaQueryHostInfo1(pDevExt, srcId); if (pInfo1) { @@ -380,5 +385,6 @@ && (pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAYFOURCC)) { - VBOXVHWACMD_QUERYINFO2* pInfo2 = vboxVhwaQueryHostInfo2(pDevExt, srcId, pInfo1->u.out.numFourCC); + VBOXVHWACMD_QUERYINFO2 RT_UNTRUSTED_VOLATILE_HOST *pInfo2 = + vboxVhwaQueryHostInfo2(pDevExt, srcId, pInfo1->u.out.numFourCC); if (pInfo2) { @@ -415,5 +421,5 @@ } -int vboxVhwaHlpTranslateFormat(VBOXVHWA_PIXELFORMAT *pFormat, D3DDDIFORMAT enmFormat) +static int vboxVhwaHlpTranslateFormat(VBOXVHWA_PIXELFORMAT RT_UNTRUSTED_VOLATILE_HOST *pFormat, D3DDDIFORMAT enmFormat) { pFormat->Reserved = 0; @@ -490,7 +496,7 @@ if (pCmd) { - VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY); - - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY)); + VBOXVHWACMD_SURF_DESTROY RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY); + + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_DESTROY)); pBody->u.in.hSurf = pSurf->hHostHandle; @@ -507,10 +513,10 @@ } -int vboxVhwaHlpPopulateSurInfo(VBOXVHWA_SURFACEDESC *pInfo, PVBOXWDDM_ALLOCATION pSurf, +int vboxVhwaHlpPopulateSurInfo(VBOXVHWA_SURFACEDESC RT_UNTRUSTED_VOLATILE_HOST *pInfo, PVBOXWDDM_ALLOCATION pSurf, uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId) { RT_NOREF(VidPnSourceId); - memset(pInfo, 0, sizeof(VBOXVHWA_SURFACEDESC)); + memset((void *)pInfo, 0, sizeof(VBOXVHWA_SURFACEDESC)); #if 0 @@ -568,6 +574,6 @@ } -int vboxVhwaHlpCheckApplySurfInfo(PVBOXWDDM_ALLOCATION pSurf, VBOXVHWA_SURFACEDESC *pInfo, - uint32_t fFlags, bool bApplyHostHandle) +int vboxVhwaHlpCheckApplySurfInfo(PVBOXWDDM_ALLOCATION pSurf, VBOXVHWA_SURFACEDESC RT_UNTRUSTED_VOLATILE_HOST *pInfo, + uint32_t fFlags, bool bApplyHostHandle) { int rc = VINF_SUCCESS; @@ -615,12 +621,10 @@ if (pCmd) { - VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE); + VBOXVHWACMD_SURF_CREATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE); int rc = VINF_SUCCESS; - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE)); - - rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf, - fFlags, cBackBuffers, fSCaps, - VidPnSourceId); + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE)); + + rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf, fFlags, cBackBuffers, fSCaps, VidPnSourceId); AssertRC(rc); if (RT_SUCCESS(rc)) @@ -629,7 +633,5 @@ Assert(pCmd->rc == VINF_SUCCESS); if(pCmd->rc == VINF_SUCCESS) - { rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, fFlags, true); - } else rc = pCmd->rc; @@ -650,12 +652,13 @@ if (pCmd) { - VBOXVHWACMD_SURF_GETINFO * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_GETINFO); + VBOXVHWACMD_SURF_GETINFO RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_GETINFO); int rc = VINF_SUCCESS; - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_GETINFO)); - - rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf, - 0, 0, VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX, - VidPnSourceId); + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_GETINFO)); + + rc = vboxVhwaHlpPopulateSurInfo(&pBody->SurfInfo, pSurf, 0, 0, + VBOXVHWA_SCAPS_OVERLAY | VBOXVHWA_SCAPS_VIDEOMEMORY + | VBOXVHWA_SCAPS_LOCALVIDMEM | VBOXVHWA_SCAPS_COMPLEX, + VidPnSourceId); AssertRC(rc); if (RT_SUCCESS(rc)) @@ -664,7 +667,5 @@ Assert(pCmd->rc == VINF_SUCCESS); if(pCmd->rc == VINF_SUCCESS) - { rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, 0, true); - } else rc = pCmd->rc; @@ -824,7 +825,7 @@ if (pCmd) { - VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); - - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_FLIP)); + VBOXVHWACMD_SURF_FLIP RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP); + + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_FLIP)); // pBody->TargGuestSurfInfo; @@ -839,5 +840,5 @@ pBody->u.in.xUpdatedTargMemValid = 1; if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID) - pBody->u.in.xUpdatedTargMemRect = *(VBOXVHWA_RECTL*)((void*)&pOurInfo->DirtyRegion.Rect); + VBOXVHWA_COPY_RECT(&pBody->u.in.xUpdatedTargMemRect, &pOurInfo->DirtyRegion.Rect); else { @@ -896,12 +897,13 @@ if(pCmd) { - VBOXVHWACMD_SURF_COLORFILL * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORFILL); - - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORFILL)); + VBOXVHWACMD_SURF_COLORFILL RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORFILL); + + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_COLORFILL)); pBody->u.in.hSurf = pAlloc->hHostHandle; pBody->u.in.offSurface = pAlloc->AllocData.Addr.offVram; pBody->u.in.cRects = pCF->ClrFill.Rects.cRects; - memcpy (pBody->u.in.aRects, pCF->ClrFill.Rects.aRects, pCF->ClrFill.Rects.cRects * sizeof (pCF->ClrFill.Rects.aRects[0])); + memcpy((void *)&pBody->u.in.aRects[0], pCF->ClrFill.Rects.aRects, + pCF->ClrFill.Rects.cRects * sizeof (pCF->ClrFill.Rects.aRects[0])); vboxVhwaCommandSubmitAsynchAndComplete(pOverlay->pDevExt, pCmd); @@ -985,15 +987,17 @@ if (pCmd) { - VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE); - - memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); + VBOXVHWACMD_SURF_OVERLAY_UPDATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE); + + memset((void *)pBody, 0, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE)); pBody->u.in.hDstSurf = pFbSurf->hHostHandle; pBody->u.in.offDstSurface = pFbSurf->AllocData.Addr.offVram; - pBody->u.in.dstRect = *(VBOXVHWA_RECTL*)((void*)&pOverlayInfo->DstRect); + VBOXVHWA_COPY_RECT(&pBody->u.in.dstRect, &pOverlayInfo->DstRect); + pBody->u.in.hSrcSurf = pAlloc->hHostHandle; pBody->u.in.offSrcSurface = pOverlayInfo->PhysicalAddress.QuadPart; pAlloc->AllocData.Addr.offVram = pOverlayInfo->PhysicalAddress.QuadPart; - pBody->u.in.srcRect = *(VBOXVHWA_RECTL*)((void*)&pOverlayInfo->SrcRect); + VBOXVHWA_COPY_RECT(&pBody->u.in.srcRect, &pOverlayInfo->SrcRect); + pBody->u.in.flags |= VBOXVHWA_OVER_SHOW; if (pOurInfo->OverlayDesc.fFlags & VBOXWDDM_OVERLAY_F_CKEY_DST) @@ -1015,5 +1019,5 @@ pBody->u.in.xFlags |= VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT; if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID) - pBody->u.in.xUpdatedSrcMemRect = *(VBOXVHWA_RECTL*)((void*)&pOurInfo->DirtyRegion.Rect); + VBOXVHWA_COPY_RECT(&pBody->u.in.xUpdatedSrcMemRect, &pOurInfo->DirtyRegion.Rect); else { @@ -1027,5 +1031,5 @@ { pBody->u.in.xFlags |= VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT; - pBody->u.in.xUpdatedDstMemRect = *(VBOXVHWA_RECTL*)((void*)pDstUpdateRect); + VBOXVHWA_COPY_RECT(&pBody->u.in.xUpdatedDstMemRect, pDstUpdateRect); } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.h (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.h (revision 71592) @@ -52,8 +52,4 @@ #endif -void vboxVhwaFreeHostInfo1(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO1* pInfo); -void vboxVhwaFreeHostInfo2(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD_QUERYINFO2* pInfo); -VBOXVHWACMD_QUERYINFO1* vboxVhwaQueryHostInfo1(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId); -VBOXVHWACMD_QUERYINFO2* vboxVhwaQueryHostInfo2(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC); int vboxVhwaEnable(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId); int vboxVhwaDisable(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId); Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.cpp (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.cpp (revision 71592) @@ -356,5 +356,6 @@ } -DECLCALLBACK(void) VBoxMPHGSMIHostCmdCompleteCB(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD *pCmd) +/** @callback_method_impl{FNVBOXVIDEOHGSMICOMPLETION} */ +DECLCALLBACK(void) VBoxMPHGSMIHostCmdCompleteCB(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd) { PHGSMIHOSTCOMMANDCONTEXT pCtx = &((PVBOXMP_COMMON)hHGSMI)->hostCtx; @@ -362,6 +363,7 @@ } +/** @callback_method_impl{FNVBOXVIDEOHGSMICOMMANDS} */ DECLCALLBACK(int) VBoxMPHGSMIHostCmdRequestCB(HVBOXVIDEOHGSMI hHGSMI, uint8_t u8Channel, - uint32_t iDisplay, struct VBVAHOSTCMD **ppCmd) + uint32_t iDisplay, struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST **ppCmd) { LOGF_ENTER(); @@ -379,10 +381,10 @@ HGSMICHANNEL *pChannel = HGSMIChannelFindById(&pCtx->channels, u8Channel); - if(pChannel) + if (pChannel) { VBVA_CHANNELCONTEXTS * pContexts = (VBVA_CHANNELCONTEXTS *)pChannel->handler.pvHandler; VBVADISP_CHANNELCONTEXT *pDispContext = VBoxVbvaFindHandlerInfo(pContexts, iDisplay); - if(pDispContext) + if (pDispContext) { VBVAHOSTCMD *pCmd; @@ -391,4 +393,5 @@ pCmd = ASMAtomicReadPtrT(&pDispContext->pCmd, VBVAHOSTCMD *); } while (!ASMAtomicCmpXchgPtr(&pDispContext->pCmd, NULL, pCmd)); + *ppCmd = VBoxVbvaReverseList(pCmd); @@ -396,10 +399,8 @@ return VINF_SUCCESS; } - else - { - WARN(("!pDispContext for display %d", iDisplay)); - } - } - + WARN(("!pDispContext for display %d", iDisplay)); + } + + *ppCmd = NULL; LOGF_LEAVE(); return VERR_INVALID_PARAMETER; @@ -510,9 +511,11 @@ break; } + case VBVAHG_EVENT: { - VBVAHOSTCMDEVENT *pEventCmd = VBVAHOSTCMD_BODY(pCur, VBVAHOSTCMDEVENT); + VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_HOST *pEventCmd = VBVAHOSTCMD_BODY(pCur, VBVAHOSTCMDEVENT); VBoxMPSignalEvent(pCallbacks->pCommon, pEventCmd->pEvent); } + default: { Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h (revision 71591) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h (revision 71592) @@ -31,6 +31,7 @@ void VBoxCreateDisplays(PVBOXMP_DEVEXT pExt, PVIDEO_PORT_CONFIG_INFO pConfigInfo); int VBoxVbvaEnable(PVBOXMP_DEVEXT pExt, BOOLEAN bEnable, VBVAENABLERESULT *pResult); -DECLCALLBACK(void) VBoxMPHGSMIHostCmdCompleteCB(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD *pCmd); -DECLCALLBACK(int) VBoxMPHGSMIHostCmdRequestCB(HVBOXVIDEOHGSMI hHGSMI, uint8_t u8Channel, uint32_t iDisplay, struct VBVAHOSTCMD **ppCmd); +DECLCALLBACK(void) VBoxMPHGSMIHostCmdCompleteCB(HVBOXVIDEOHGSMI hHGSMI, struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST *pCmd); +DECLCALLBACK(int) VBoxMPHGSMIHostCmdRequestCB(HVBOXVIDEOHGSMI hHGSMI, uint8_t u8Channel, uint32_t iDisplay, + struct VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_HOST **ppCmd); int VBoxVbvaChannelDisplayEnable(PVBOXMP_COMMON pCommon, int iDisplay, uint8_t u8Channel); Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp =================================================================== --- /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (revision 71591) +++ /trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (revision 71592) @@ -1174,5 +1174,5 @@ } -int vbvaVHWAConstruct (PVGASTATE pVGAState) +int vbvaVHWAConstruct(PVGASTATE pVGAState) { pVGAState->pendingVhwaCommands.cPending = 0; @@ -1185,5 +1185,5 @@ uint32_t iDisplay = 0; int rc = VINF_SUCCESS; - VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT); + VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT); do @@ -1199,6 +1199,8 @@ rc = vbvaVHWAHHCommandPost(pVGAState, pCmd); + ASMCompilerBarrier(); + AssertRC(rc); - if(RT_SUCCESS(rc)) + if (RT_SUCCESS(rc)) { rc = pCmd->rc; @@ -1230,5 +1232,5 @@ } -int vbvaVHWAReset (PVGASTATE pVGAState) +int vbvaVHWAReset(PVGASTATE pVGAState) { vbvaVHWACommandClearAllPending(pVGAState); @@ -1382,5 +1384,5 @@ pHostCmd->iDstID = pCmd->iDisplay; pHostCmd->customOpCode = 0; - VBVAHOSTCMDEVENT *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT); + VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_GUEST *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT); pBody->pEvent = pCmd->GuestVBVAReserved1; } @@ -1403,5 +1405,6 @@ pHostCmd->iDstID = pCmd->iDisplay; pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE; - VBVAHOSTCMDVHWACMDCOMPLETE *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE); + VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_GUEST *pBody + = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE); pBody->offCmd = offCmd; } @@ -1747,5 +1750,5 @@ { vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0); - VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); + VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); pSave->pSSM = pSSM; vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData); @@ -1985,5 +1988,5 @@ VBOXVBVASAVEDSTATECBDATA VhwaData = {0}; VhwaData.pSSM = pSSM; - VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); + VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); pLoad->pSSM = pSSM; vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);