Changeset 71592 in vbox

Timestamp:

Mar 31, 2018 7:51:41 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

121581

Message:

DevVGA,VBoxVideo: Code cleanup in progress. bugref:9094

Location:

trunk

Files:

• include/VBox/Graphics/VBoxVideo.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h (modified) (2 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp (modified) (6 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp (modified) (8 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.cpp (modified) (30 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp (modified) (21 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.h (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.cpp (modified) (6 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h (modified) (1 diff)
• src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (modified) (8 diffs)

trunk/include/VBox/Graphics/VBoxVideo.h

@@ -347 +347 @@
 } 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 +378 @@
     {
         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 +974 @@
     } 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()

trunk/src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h

@@ -65 +65 @@
 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 +106 @@
 } HGSMIQUERYCPORTPROCS;
 
-/* Data returned by IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS. */
+/** Data returned by IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS. */
 typedef struct _HGSMIQUERYCALLBACKS
 {

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp

@@ -32 +32 @@
     if(pDev->vhwa.bEnabled)
     {
-        VBOXVHWACMD* pCmd;
-
         uint32_t unsupportedSCaps = VBoxDispVHWAUnsupportedDDSCAPS(lpDDS->ddsCaps.dwCaps);
         if(unsupportedSCaps)
@@ -50 +48 @@
         }
 
-        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 +138 @@
     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 +255 @@
     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 +396 @@
         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 +491 @@
                  || ((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;

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDrawVHWA.cpp

@@ -20 +20 @@
 #include <iprt/asm.h>
 
-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 +35 @@
 }
 
-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 +168 @@
     DD_SURFACE_LOCAL *pSurf = lpSetColorKey->lpDDSurface;
     PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)pSurf->lpGbl->dwReserved1;
-    VBOXVHWACMD* pCmd;
 
     lpSetColorKey->ddRVal = DD_OK;
@@ -170 +173 @@
     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 +224 @@
     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 +302 @@
         }
 
-        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 +455 @@
         }
 
-        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 +501 @@
     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);

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h

@@ -131 +131 @@
 /* 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);

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp

@@ -482 +482 @@
 }
 
-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);

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.cpp

@@ -21 +21 @@
 #include <iprt/asm-amd64-x86.h>
 
-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 +52 @@
 }
 
-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 +66 @@
 }
 
-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 +96 @@
 {
     int rc = VERR_GENERAL_FAILURE;
-    VBOXVHWACMD* pCmd;
 
     if (!pDev->hgsmi.bSupported)
@@ -103 +102 @@
     }
 
-    pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_ENABLE, 0);
+    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_ENABLE, 0);
     if (!pCmd)
     {
@@ -110 +109 @@
     }
 
-    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 +117 @@
 }
 
-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 +129 @@
     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 +142 @@
 }
 
-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 +174 @@
 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 +197 @@
 
 /* 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 +215 @@
 }
 
-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 +222 @@
 }
 
-void VBoxDispVHWACommandSubmitAsynchAndComplete (PVBOXDISPDEV pDev, VBOXVHWACMD* pCmd)
+void VBoxDispVHWACommandSubmitAsynchAndComplete (PVBOXDISPDEV pDev, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
 {
     pCmd->GuestVBVAReserved1 = (uintptr_t)VBoxDispVHWAFreeCmdCompletion;
@@ -236 +232 @@
     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 +243 @@
 }
 
-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 +265 @@
     }
 
-    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 +283 @@
 }
 
-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 +293 @@
     }
 
-    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 +306 @@
 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 +325 @@
     pDev->vhwa.numFourCC = pInfo->u.out.numFourCC;
     pDev->vhwa.bEnabled = (pInfo->u.out.cfgFlags & VBOXVHWA_CFG_ENABLED);
+
     VBoxDispVHWAFreeHostInfo1(pDev, pInfo);
     return VINF_SUCCESS;
@@ -342 +332 @@
 int VBoxDispVHWAInitHostInfo2(PVBOXDISPDEV pDev, DWORD *pFourCC)
 {
-    VBOXVHWACMD_QUERYINFO2* pInfo;
     int rc = VINF_SUCCESS;
 
@@ -348 +337 @@
         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 +358 @@
 {
     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 +369 @@
     }
 
-    if(VBoxDispVHWACommandSubmit (pDev, pCmd))
-    {
+    if (VBoxDispVHWACommandSubmit(pDev, pCmd))
         if(RT_SUCCESS(pCmd->rc))
-        {
             rc = VINF_SUCCESS;
-        }
-    }
 
     VBoxDispVHWACommandRelease(pDev, pCmd);
@@ -652 +633 @@
 }
 
-void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY *pVHWACKey, DDCOLORKEY  *pDdCKey)
+void VBoxDispVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY RT_UNTRUSTED_VOLATILE_HOST *pVHWACKey, DDCOLORKEY  *pDdCKey)
 {
     pVHWACKey->low = pDdCKey->dwColorSpaceLowValue;
@@ -658 +639 @@
 }
 
-void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX *pVHWAOverlay, DDOVERLAYFX *pDdOverlay)
+void VBoxDispVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX RT_UNTRUSTED_VOLATILE_HOST *pVHWAOverlay, DDOVERLAYFX *pDdOverlay)
 {
     /// @todo fxFlags
@@ -665 +646 @@
 }
 
-void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX *pVHWABlt, DDBLTFX *pDdBlt)
+void VBoxDispVHWAFromDDBLTFX(VBOXVHWA_BLTFX RT_UNTRUSTED_VOLATILE_HOST *pVHWABlt, DDBLTFX *pDdBlt)
 {
     pVHWABlt->fillColor = pDdBlt->dwFillColor;
@@ -673 +654 @@
 }
 
-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 +670 @@
 }
 
-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 +738 @@
 }
 
-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;

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVHWA.h

@@ -59 +59 @@
 }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 +112 @@
 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 +129 @@
 uint32_t VBoxDispVHWASupportedDDCEYCAPS(uint32_t caps);
 
-#endif /*VBOXDISPVHWA_H*/
+#endif /* !VBOXDISPVHWA_H */
+

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp

@@ -25 +25 @@
 
 #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 +229 @@
 }
 
-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 +248 @@
     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 +264 @@
 }
 
-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 +271 @@
     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 +345 @@
     vboxVhwaHlpOverlayListInit(pDevExt, srcId);
 
-    VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVhwaQueryHostInfo1(pDevExt, srcId);
+    VBOXVHWACMD_QUERYINFO1 RT_UNTRUSTED_VOLATILE_HOST *pInfo1 = vboxVhwaQueryHostInfo1(pDevExt, srcId);
     if (pInfo1)
     {
@@ -380 +385 @@
                         && (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 +421 @@
 }
 
-int vboxVhwaHlpTranslateFormat(VBOXVHWA_PIXELFORMAT *pFormat, D3DDDIFORMAT enmFormat)
+static int vboxVhwaHlpTranslateFormat(VBOXVHWA_PIXELFORMAT RT_UNTRUSTED_VOLATILE_HOST *pFormat, D3DDDIFORMAT enmFormat)
 {
     pFormat->Reserved = 0;
@@ -490 +496 @@
     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 +513 @@
 }
 
-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 +574 @@
 }
 
-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 +621 @@
     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 +633 @@
             Assert(pCmd->rc == VINF_SUCCESS);
             if(pCmd->rc == VINF_SUCCESS)
-            {
                 rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, fFlags, true);
-            }
             else
                 rc = pCmd->rc;
@@ -650 +652 @@
     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 +667 @@
             Assert(pCmd->rc == VINF_SUCCESS);
             if(pCmd->rc == VINF_SUCCESS)
-            {
                 rc = vboxVhwaHlpCheckApplySurfInfo(pSurf, &pBody->SurfInfo, 0, true);
-            }
             else
                 rc = pCmd->rc;
@@ -824 +825 @@
         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 +840 @@
                 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 +897 @@
     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 +987 @@
         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 +1019 @@
                 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 +1031 @@
             {
                 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);
             }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.h

@@ -52 +52 @@
 #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);

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.cpp

@@ -356 +356 @@
 }
 
-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 +363 @@
 }
 
+/** @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 +381 @@
 
     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 +393 @@
                 pCmd = ASMAtomicReadPtrT(&pDispContext->pCmd, VBVAHOSTCMD *);
             } while (!ASMAtomicCmpXchgPtr(&pDispContext->pCmd, NULL, pCmd));
+
             *ppCmd = VBoxVbvaReverseList(pCmd);
 
@@ -396 +399 @@
             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 +511 @@
                             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:
                         {

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h

@@ -31 +31 @@
 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);
 

trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

@@ -1174 +1174 @@
 }
 
-int vbvaVHWAConstruct (PVGASTATE pVGAState)
+int vbvaVHWAConstruct(PVGASTATE pVGAState)
 {
     pVGAState->pendingVhwaCommands.cPending = 0;
@@ -1185 +1185 @@
         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 +1199 @@
 
             rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            ASMCompilerBarrier();
+
             AssertRC(rc);
-            if(RT_SUCCESS(rc))
+            if (RT_SUCCESS(rc))
             {
                 rc = pCmd->rc;
@@ -1230 +1232 @@
 }
 
-int vbvaVHWAReset (PVGASTATE pVGAState)
+int vbvaVHWAReset(PVGASTATE pVGAState)
 {
     vbvaVHWACommandClearAllPending(pVGAState);
@@ -1382 +1384 @@
                     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 +1405 @@
                         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 +1750 @@
             {
                 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 +1988 @@
                     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);