VirtualBox

Changeset 71590 in vbox for trunk/src/VBox/Additions


Ignore:
Timestamp:
Mar 31, 2018 6:34:28 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
121579
Message:

DevVGA,HGSMI,++: Code cleanup in progress. bugref:9094

Location:
trunk/src/VBox/Additions
Files:
22 edited

Legend:

Unmodified
Added
Removed

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

    r69500 r71590  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
     17
    1718#ifdef VBOX_WITH_CROGL
    1819
    … …  
    3738}
    3839
    39 static void* vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
     40static void RT_UNTRUSTED_VOLATILE_HOST *vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
    4041{
    4142    return VBoxSHGSMIHeapBufferAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, cbData);
    4243}
    4344
    44 static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
    45 {
    46     return (VBOXVIDEOOFFSET)HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area,
    47                                                  (const HGSMIBUFFERHEADER *)pvBuffer);
    48 }
    49 
    50 static void* vboxMpCrShgsmiBufferFromOffset(PVBOXMP_DEVEXT pDevExt, VBOXVIDEOOFFSET offBuffer)
     45static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
     46{
     47    return (VBOXVIDEOOFFSET)HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, pvBuffer);
     48}
     49
     50static void RT_UNTRUSTED_VOLATILE_HOST *vboxMpCrShgsmiBufferFromOffset(PVBOXMP_DEVEXT pDevExt, VBOXVIDEOOFFSET offBuffer)
    5151{
    5252    return HGSMIOffsetToPointer(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (HGSMIOFFSET)offBuffer);
    5353}
    5454
    55 static void vboxMpCrShgsmiBufferFree(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
     55static void vboxMpCrShgsmiBufferFree(PVBOXMP_DEVEXT pDevExt, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    5656{
    5757    VBoxSHGSMIHeapBufferFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pvBuffer);
    5858}
    5959
    60 static VBOXVIDEOOFFSET vboxMpCrShgsmiTransportBufOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer)
     60static VBOXVIDEOOFFSET vboxMpCrShgsmiTransportBufOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    6161{
    6262    return vboxMpCrShgsmiBufferOffset(pCon->pDevExt, pvBuffer);
    6363}
    6464
    65 static void* vboxMpCrShgsmiTransportBufFromOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, VBOXVIDEOOFFSET offBuffer)
     65static void RT_UNTRUSTED_VOLATILE_HOST *vboxMpCrShgsmiTransportBufFromOffset(PVBOXMP_CRSHGSMITRANSPORT pCon, VBOXVIDEOOFFSET offBuffer)
    6666{
    6767    return vboxMpCrShgsmiBufferFromOffset(pCon->pDevExt, offBuffer);
    6868}
    6969
    70 void* VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer)
     70void RT_UNTRUSTED_VOLATILE_HOST *VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer)
    7171{
    7272    return vboxMpCrShgsmiBufferAlloc(pCon->pDevExt, cbBuffer);
    7373}
    7474
    75 void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer)
     75void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    7676{
    7777    vboxMpCrShgsmiBufferFree(pCon->pDevExt, pvBuffer);
    … …  
    297297
    298298typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
    299                                                                                void *pvRx, uint32_t cbRx, void *pvCtx);
     299                                                                               void RT_UNTRUSTED_VOLATILE_HOST *pvRx,
     300                                                                               uint32_t cbRx, void *pvCtx);
    300301typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION;
    301302
    … …  
    321322    VBOXVDMACMD_CHROMIUM_BUFFER *pRxBuf = &pBody->aBuffers[1];
    322323    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = (PVBOXMP_CRSHGSMICON_BUFDR)pRxBuf->u64GuestData;
    323     void *pvRx = NULL;
     324    void RT_UNTRUSTED_VOLATILE_HOST *pvRx = NULL;
    324325    uint32_t cbRx = 0;
    325326
    … …  
    418419} VBOXMP_CRHGSMICON_WRR_COMPLETION_CTX, *PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX;
    419420
     421/** @callback_method_impl{FNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION} */
    420422static DECLCALLBACK(void) vboxMpCrShgsmiTransportSendWriteReadReadRepostCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
    421                                                                                    void *pvRx, uint32_t cbRx, void *pvCtx)
     423                                                                                   void RT_UNTRUSTED_VOLATILE_HOST *pvRx,
     424                                                                                   uint32_t cbRx, void *pvCtx)
    422425{
    423426    PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX pData = (PVBOXMP_CRHGSMICON_WRR_COMPLETION_CTX)pvCtx;
    … …  
    448451    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = (PVBOXMP_CRSHGSMICON_BUFDR)pRxBuf->u64GuestData;
    449452    PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION)pBufCmd->u64GuestData;
    450     void *pvRx = NULL;
     453    void RT_UNTRUSTED_VOLATILE_HOST *pvRx = NULL;
    451454    uint32_t cbRx = 0;
    452455
    … …  
    552555}
    553556
    554 static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
     557/** @callback_method_impl{FNVBOXSHGSMICMDCOMPLETION}   */
     558static DECLCALLBACK(VOID)
     559vboxMpCrShgsmiTransportVbvaSendWriteAsyncCompletion(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, void *pvContext)
    555560{
    556561    RT_NOREF(pHeap);
    … …  
    559564
    560565    PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
    561     VBOXCMDVBVA_CRCMD_CMD *pCmd;
     566    VBOXCMDVBVA_CRCMD_CMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = NULL;
    562567    int rc = VBoxCmdVbvaConCmdCompletionData(pvCmd, &pCmd);
    563568    const UINT cBuffers = 2;
    … …  
    581586    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITEREAD), cbContextData);
    582587    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
    583     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
     588    VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    584589    if (!pDr)
    585590    {
    … …  
    686691    const uint32_t cBuffers = 2;
    687692    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (VBOXMP_CRHGSMICMD_WRITE), cbContextData);
    688     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
     693    VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    689694    if (!pDr)
    690695    {
    … …  
    11031108}
    11041109
    1105 int VBoxMpCrCmdRxReadbackHandler(CRMessageReadback *pRx, uint32_t cbRx)
    1106 {
    1107     if (cbRx < sizeof (*pRx))
     1110int VBoxMpCrCmdRxReadbackHandler(CRMessageReadback RT_UNTRUSTED_VOLATILE_HOST *pRx, uint32_t cbRx)
     1111{
     1112    if (cbRx < sizeof(*pRx))
    11081113    {
    11091114        WARN(("invalid rx size %d", cbRx));
    11101115        return VERR_INVALID_PARAMETER;
    11111116    }
    1112     void* pvData = VBoxMpCrCmdRxReadbackData(pRx);
     1117    void    *pvSrc = VBoxMpCrCmdRxReadbackData(pRx);
    11131118    uint32_t cbData = VBoxMpCrCmdRxReadbackDataSize(pRx, cbRx);
    1114     void *pvDataPtr = *((void**)&pRx->readback_ptr);
    1115     memcpy(pvDataPtr, pvData, cbData);
     1119    void    *pvDst = *((void**)&pRx->readback_ptr);
     1120    memcpy(pvDst, pvSrc, cbData);
    11161121    return VINF_SUCCESS;
    11171122}
    11181123
    1119 int VBoxMpCrCmdRxHandler(CRMessageHeader *pRx, uint32_t cbRx)
    1120 {
    1121     if (cbRx < sizeof (*pRx))
     1124int VBoxMpCrCmdRxHandler(CRMessageHeader RT_UNTRUSTED_VOLATILE_HOST *pRx, uint32_t cbRx)
     1125{
     1126    if (cbRx < sizeof(*pRx))
    11221127    {
    11231128        WARN(("invalid rx size %d", cbRx));
    11241129        return VERR_INVALID_PARAMETER;
    11251130    }
    1126     CRMessageHeader *pHdr = (CRMessageHeader*)pRx;
    1127     switch (pHdr->type)
     1131    CRMessageType enmType = pRx->type;
     1132    switch (enmType)
    11281133    {
    11291134        case CR_MESSAGE_READBACK:
    1130             return VBoxMpCrCmdRxReadbackHandler((CRMessageReadback*)pRx, cbRx);
     1135            return VBoxMpCrCmdRxReadbackHandler((CRMessageReadback RT_UNTRUSTED_VOLATILE_HOST *)pRx, cbRx);
    11311136        default:
    1132             WARN(("unsupported rx message type: %d", pHdr->type));
     1137            WARN(("unsupported rx message type: %d", enmType));
    11331138            return VERR_INVALID_PARAMETER;
    11341139    }

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

    r69500 r71590  
    4545{
    4646    uint32_t cbBuf;
    47     void *pvBuf;
     47    void RT_UNTRUSTED_VOLATILE_HOST *pvBuf;
    4848} VBOXMP_CRSHGSMICON_BUFDR, *PVBOXMP_CRSHGSMICON_BUFDR;
    4949
    … …  
    6262 * the callee must NOT free it or use outside of the callback context.
    6363 * */
    64 typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx);
     64typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
     65                                                                                    void RT_UNTRUSTED_VOLATILE_HOST *pvRx,
     66                                                                                    uint32_t cbRx, void *pvCtx);
    6567typedef FNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION *PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION;
    6668
    … …  
    7981void VBoxMpCrShgsmiTransportCmdTermWriteAsync(PVBOXMP_CRSHGSMITRANSPORT pCon, void *pvContext);
    8082
    81 void* VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer);
    82 void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void* pvBuffer);
     83void RT_UNTRUSTED_VOLATILE_HOST *VBoxMpCrShgsmiTransportBufAlloc(PVBOXMP_CRSHGSMITRANSPORT pCon, uint32_t cbBuffer);
     84void VBoxMpCrShgsmiTransportBufFree(PVBOXMP_CRSHGSMITRANSPORT pCon, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer);
    8385
    8486typedef struct VBOXMP_CRPACKER
    … …  
    98100}
    99101
    100 DECLINLINE(void) VBoxMpCrPackerTxBufferInit(PVBOXMP_CRPACKER pPacker, void *pvBuffer, uint32_t cbBuffer, uint32_t cCommands)
    101 {
    102     crPackInitBuffer(&pPacker->CrBuffer, pvBuffer, cbBuffer, cbBuffer, cCommands);
     102DECLINLINE(void) VBoxMpCrPackerTxBufferInit(PVBOXMP_CRPACKER pPacker, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer,
     103                                            uint32_t cbBuffer, uint32_t cCommands)
     104{
     105    crPackInitBuffer(&pPacker->CrBuffer, (void *)pvBuffer, cbBuffer, cbBuffer, cCommands);
    103106    crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);
    104107}
    … …  
    190193}
    191194
    192 DECLINLINE(void*) VBoxMpCrCmdRxReadbackData(CRMessageReadback *pRx)
    193 {
    194     return pRx + 1;
    195 }
    196 
    197 DECLINLINE(uint32_t) VBoxMpCrCmdRxReadbackDataSize(CRMessageReadback *pRx, uint32_t cbRx)
     195DECLINLINE(void *) VBoxMpCrCmdRxReadbackData(CRMessageReadback RT_UNTRUSTED_VOLATILE_HOST *pRx)
     196{
     197    return (void *)(pRx + 1);
     198}
     199
     200DECLINLINE(uint32_t) VBoxMpCrCmdRxReadbackDataSize(CRMessageReadback RT_UNTRUSTED_VOLATILE_HOST *pRx, uint32_t cbRx)
    198201{
    199202    RT_NOREF(pRx);
    200203    return cbRx - sizeof(*pRx);
    201204}
    202 int VBoxMpCrCmdRxReadbackHandler(CRMessageReadback *pRx, uint32_t cbRx);
    203 int VBoxMpCrCmdRxHandler(CRMessageHeader *pRx, uint32_t cbRx);
     205int VBoxMpCrCmdRxReadbackHandler(CRMessageReadback RT_UNTRUSTED_VOLATILE_HOST *pRx, uint32_t cbRx);
     206int VBoxMpCrCmdRxHandler(CRMessageHeader RT_UNTRUSTED_VOLATILE_HOST *pRx, uint32_t cbRx);
    204207
    205208/* must be called after calling VBoxMpCrCtlConIs3DSupported only */

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

    r71196 r71590  
    13921392    UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[cBuffers]));
    13931393
    1394     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
     1394    VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    13951395    if (pDr)
    13961396    {
    … …  
    14381438        {
    14391439            PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
    1440             vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxVideoAMgrAllocSubmitCompletion, pDr);
     1440            vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxVideoAMgrAllocSubmitCompletion, (void *)pDr);
    14411441            /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
    14421442            vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
    … …  
    18081808{
    18091809    int rc = VINF_SUCCESS;
    1810     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
    1811                                                                sizeof(VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1810    VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd
     1811        = (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
     1812                                                                             sizeof(VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    18121813    if (pCmd)
    18131814    {
    … …  
    18451846        }
    18461847
    1847         VBoxSHGSMICommandFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
     1848        VBoxSHGSMICommandFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
    18481849    }
    18491850    else

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

    r69500 r71590  
    2020
    2121/* SHGSMI */
    22 DECLINLINE(void) vboxSHGSMICommandRetain(PVBOXSHGSMIHEADER pCmd)
     22DECLINLINE(void) vboxSHGSMICommandRetain(VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    2323{
    2424    ASMAtomicIncU32(&pCmd->cRefs);
    2525}
    2626
    27 void vboxSHGSMICommandFree(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
     27void vboxSHGSMICommandFree(PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    2828{
    2929    VBoxSHGSMIHeapFree(pHeap, pCmd);
    3030}
    3131
    32 DECLINLINE(void) vboxSHGSMICommandRelease(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pCmd)
     32DECLINLINE(void) vboxSHGSMICommandRelease(PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    3333{
    3434    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
    3535    Assert(cRefs < UINT32_MAX / 2);
    3636    if(!cRefs)
    37         vboxSHGSMICommandFree (pHeap, pCmd);
    38 }
    39 
    40 static DECLCALLBACK(void) vboxSHGSMICompletionSetEvent(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
     37        vboxSHGSMICommandFree(pHeap, pCmd);
     38}
     39
     40static DECLCALLBACK(void) vboxSHGSMICompletionSetEvent(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, void *pvContext)
    4141{
    4242    RT_NOREF(pHeap, pvCmd);
    … …  
    4444}
    4545
    46 DECLCALLBACK(void) vboxSHGSMICompletionCommandRelease(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext)
     46DECLCALLBACK(void) vboxSHGSMICompletionCommandRelease(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, void *pvContext)
    4747{
    4848    RT_NOREF(pvContext);
    … …  
    5151
    5252/* do not wait for completion */
    53 DECLINLINE(const VBOXSHGSMIHEADER *) vboxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, PVBOXSHGSMIHEADER pHeader)
     53DECLINLINE(const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *)
     54vboxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    5455{
    5556    RT_NOREF(pHeap);
    … …  
    5960}
    6061
    61 DECLINLINE(void) vboxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     62DECLINLINE(void) vboxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    6263{
    6364    if(!(ASMAtomicReadU32((volatile uint32_t *)&pHeader->fFlags) & VBOXSHGSMI_FLAG_HG_ASYNCH))
    … …  
    7172}
    7273
    73 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent(PVBOXSHGSMI pHeap, PVOID pvBuff, RTSEMEVENT hEventSem)
    74 {
    75     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader(pvBuff);
     74const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     75VBoxSHGSMICommandPrepAsynchEvent(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuff, RTSEMEVENT hEventSem)
     76{
     77    VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader = VBoxSHGSMIBufferHeader(pvBuff);
    7678    pHeader->u64Info1 = (uint64_t)vboxSHGSMICompletionSetEvent;
    7779    pHeader->u64Info2 = (uintptr_t)hEventSem;
    … …  
    8183}
    8284
    83 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch(PVBOXSHGSMI pHeap, PVOID pCmd)
     85const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMICommandPrepSynch(PVBOXSHGSMI pHeap,
     86                                                                              void  RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    8487{
    8588    RTSEMEVENT hEventSem;
    … …  
    9396}
    9497
    95 void VBoxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER * pHeader)
     98void VBoxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    9699{
    97100    vboxSHGSMICommandDoneAsynch(pHeap, pHeader);
    98101}
    99102
    100 int VBoxSHGSMICommandDoneSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     103int VBoxSHGSMICommandDoneSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    101104{
    102105    VBoxSHGSMICommandDoneAsynch(pHeap, pHeader);
    … …  
    109112}
    110113
    111 void VBoxSHGSMICommandCancelAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     114void VBoxSHGSMICommandCancelAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    112115{
    113116    vboxSHGSMICommandRelease(pHeap, (PVBOXSHGSMIHEADER)pHeader);
    114117}
    115118
    116 void VBoxSHGSMICommandCancelSynch (PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
    117 {
    118     VBoxSHGSMICommandCancelAsynch (pHeap, pHeader);
     119void VBoxSHGSMICommandCancelSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
     120{
     121    VBoxSHGSMICommandCancelAsynch(pHeap, pHeader);
    119122    RTSEMEVENT hEventSem = (RTSEMEVENT)pHeader->u64Info2;
    120123    RTSemEventDestroy(hEventSem);
    121124}
    122125
    123 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion,
    124                                                     PVOID pvCompletion, uint32_t fFlags)
     126const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     127VBoxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuff,
     128                            PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
    125129{
    126130    fFlags &= ~VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ;
    127     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader (pvBuff);
     131    VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader = VBoxSHGSMIBufferHeader(pvBuff);
    128132    pHeader->u64Info1 = (uintptr_t)pfnCompletion;
    129133    pHeader->u64Info2 = (uintptr_t)pvCompletion;
    130134    pHeader->fFlags = fFlags;
    131135
    132     return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
    133 }
    134 
    135 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq(PVBOXSHGSMI pHeap, PVOID pvBuff,
    136                                                        PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion,
    137                                                        uint32_t fFlags)
     136    return vboxSHGSMICommandPrepAsynch(pHeap, pHeader);
     137}
     138
     139const VBOXSHGSMIHEADER  RT_UNTRUSTED_VOLATILE_HOST *
     140VBoxSHGSMICommandPrepAsynchIrq(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuff,
     141                               PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags)
    138142{
    139143    fFlags |= VBOXSHGSMI_FLAG_GH_ASYNCH_CALLBACK_IRQ | VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ;
    140     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader (pvBuff);
     144    VBOXSHGSMIHEADER  RT_UNTRUSTED_VOLATILE_HOST *pHeader = VBoxSHGSMIBufferHeader(pvBuff);
    141145    pHeader->u64Info1 = (uintptr_t)pfnCompletion;
    142146    pHeader->u64Info2 = (uintptr_t)pvCompletion;
    … …  
    144148    pHeader->fFlags = fFlags;
    145149
    146     return vboxSHGSMICommandPrepAsynch (pHeap, pHeader);
    147 }
    148 
    149 void* VBoxSHGSMIHeapAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo)
    150 {
    151     KIRQL OldIrql;
    152     void* pvData;
     150    return vboxSHGSMICommandPrepAsynch(pHeap, pHeader);
     151}
     152
     153void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMIHeapAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo)
     154{
     155    KIRQL OldIrql;
     156    void RT_UNTRUSTED_VOLATILE_HOST *pvData;
    153157    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    154158    KeAcquireSpinLock(&pHeap->HeapLock, &OldIrql);
    … …  
    160164}
    161165
    162 void VBoxSHGSMIHeapFree(PVBOXSHGSMI pHeap, void *pvBuffer)
     166void VBoxSHGSMIHeapFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    163167{
    164168    KIRQL OldIrql;
    … …  
    169173}
    170174
    171 void* VBoxSHGSMIHeapBufferAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData)
    172 {
    173     KIRQL OldIrql;
    174     void* pvData;
     175void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMIHeapBufferAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData)
     176{
     177    KIRQL OldIrql;
     178    void RT_UNTRUSTED_VOLATILE_HOST * pvData;
    175179    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    176180    KeAcquireSpinLock(&pHeap->HeapLock, &OldIrql);
    … …  
    182186}
    183187
    184 void VBoxSHGSMIHeapBufferFree(PVBOXSHGSMI pHeap, void *pvBuffer)
     188void VBoxSHGSMIHeapBufferFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    185189{
    186190    KIRQL OldIrql;
    … …  
    203207}
    204208
    205 void* VBoxSHGSMICommandAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo)
     209void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMICommandAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel,
     210                                                        uint16_t u16ChannelInfo)
    206211{
    207212    /* Issue the flush command. */
    208     PVBOXSHGSMIHEADER pHeader = (PVBOXSHGSMIHEADER)VBoxSHGSMIHeapAlloc(pHeap, cbData + sizeof (VBOXSHGSMIHEADER), u8Channel,
    209                                                                        u16ChannelInfo);
     213    VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader =
     214        (VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *)VBoxSHGSMIHeapAlloc(pHeap, cbData + sizeof(VBOXSHGSMIHEADER),
     215                                                                           u8Channel, u16ChannelInfo);
    210216    Assert(pHeader);
    211217    if (pHeader)
    … …  
    217223}
    218224
    219 void VBoxSHGSMICommandFree(PVBOXSHGSMI pHeap, void *pvBuffer)
    220 {
    221     PVBOXSHGSMIHEADER pHeader = VBoxSHGSMIBufferHeader(pvBuffer);
    222     vboxSHGSMICommandRelease (pHeap, pHeader);
     225void VBoxSHGSMICommandFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
     226{
     227    VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader = VBoxSHGSMIBufferHeader(pvBuffer);
     228    vboxSHGSMICommandRelease(pHeap, pHeader);
    223229}
    224230
    … …  
    226232#define VBOXSHGSMI_LISTENTRY2CMD(_pEntry) ( (PVBOXSHGSMIHEADER)((uint8_t *)(_pEntry) - RT_OFFSETOF(VBOXSHGSMIHEADER, pvNext)) )
    227233
    228 int VBoxSHGSMICommandProcessCompletion (PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER* pCur, bool bIrq, PVBOXVTLIST pPostProcessList)
     234int VBoxSHGSMICommandProcessCompletion(PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER *pCur, bool bIrq, PVBOXVTLIST pPostProcessList)
    229235{
    230236    int rc = VINF_SUCCESS;

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

    r69500 r71590  
    3030} VBOXSHGSMI, *PVBOXSHGSMI;
    3131
    32 typedef DECLCALLBACK(void) FNVBOXSHGSMICMDCOMPLETION(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext);
     32typedef DECLCALLBACK(void) FNVBOXSHGSMICMDCOMPLETION(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, void *pvContext);
    3333typedef FNVBOXSHGSMICMDCOMPLETION *PFNVBOXSHGSMICMDCOMPLETION;
    3434
    35 typedef DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) FNVBOXSHGSMICMDCOMPLETION_IRQ(PVBOXSHGSMI pHeap, void *pvCmd, void *pvContext, void **ppvCompletion);
     35typedef DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) FNVBOXSHGSMICMDCOMPLETION_IRQ(PVBOXSHGSMI pHeap,
     36                                                                               void RT_UNTRUSTED_VOLATILE_HOST *pvCmd,
     37                                                                               void *pvContext, void **ppvCompletion);
    3638typedef FNVBOXSHGSMICMDCOMPLETION_IRQ *PFNVBOXSHGSMICMDCOMPLETION_IRQ;
    3739
    3840
    39 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchEvent(PVBOXSHGSMI pHeap, PVOID pvBuff, RTSEMEVENT hEventSem);
    40 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepSynch(PVBOXSHGSMI pHeap, PVOID pCmd);
    41 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
    42 const VBOXSHGSMIHEADER* VBoxSHGSMICommandPrepAsynchIrq(PVBOXSHGSMI pHeap, PVOID pvBuff, PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
     41const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     42    VBoxSHGSMICommandPrepAsynchEvent(PVBOXSHGSMI pHeap, PVOID pvBuff, RTSEMEVENT hEventSem);
     43const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     44    VBoxSHGSMICommandPrepSynch(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd);
     45const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     46    VBoxSHGSMICommandPrepAsynch(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuff,
     47                                PFNVBOXSHGSMICMDCOMPLETION pfnCompletion,  PVOID pvCompletion, uint32_t fFlags);
     48const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *
     49    VBoxSHGSMICommandPrepAsynchIrq(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuff,
     50                                   PFNVBOXSHGSMICMDCOMPLETION_IRQ pfnCompletion, PVOID pvCompletion, uint32_t fFlags);
    4351
    44 void VBoxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader);
    45 int VBoxSHGSMICommandDoneSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader);
    46 void VBoxSHGSMICommandCancelAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader);
    47 void VBoxSHGSMICommandCancelSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader);
     52void VBoxSHGSMICommandDoneAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader);
     53int  VBoxSHGSMICommandDoneSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader);
     54void VBoxSHGSMICommandCancelAsynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader);
     55void VBoxSHGSMICommandCancelSynch(PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader);
    4856
    49 DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandOffset(const PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER* pHeader)
     57DECLINLINE(HGSMIOFFSET) VBoxSHGSMICommandOffset(const PVBOXSHGSMI pHeap, const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHeader)
    5058{
    5159    return HGSMIHeapBufferOffset(&pHeap->Heap, (void*)pHeader);
    … …  
    6169int VBoxSHGSMIInit(PVBOXSHGSMI pHeap, void *pvBase, HGSMISIZE cbArea, HGSMIOFFSET offBase, const HGSMIENV *pEnv);
    6270void VBoxSHGSMITerm(PVBOXSHGSMI pHeap);
    63 void* VBoxSHGSMIHeapAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
    64 void VBoxSHGSMIHeapFree(PVBOXSHGSMI pHeap, void *pvBuffer);
    65 void* VBoxSHGSMIHeapBufferAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData);
    66 void VBoxSHGSMIHeapBufferFree(PVBOXSHGSMI pHeap, void *pvBuffer);
    67 void* VBoxSHGSMICommandAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
    68 void VBoxSHGSMICommandFree(PVBOXSHGSMI pHeap, void *pvBuffer);
     71void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMIHeapAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
     72void VBoxSHGSMIHeapFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer);
     73void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMIHeapBufferAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData);
     74void VBoxSHGSMIHeapBufferFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer);
     75void RT_UNTRUSTED_VOLATILE_HOST *VBoxSHGSMICommandAlloc(PVBOXSHGSMI pHeap, HGSMISIZE cbData, uint8_t u8Channel, uint16_t u16ChannelInfo);
     76void VBoxSHGSMICommandFree(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer);
    6977int VBoxSHGSMICommandProcessCompletion(PVBOXSHGSMI pHeap, VBOXSHGSMIHEADER* pCmd, bool bIrq, struct VBOXVTLIST * pPostProcessList);
    7078int VBoxSHGSMICommandPostprocessCompletion(PVBOXSHGSMI pHeap, struct VBOXVTLIST * pPostProcessList);

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

    r69500 r71590  
    123123#define vboxCmdVbvaSubmit vboxCmdVbvaSubmitHgsmi
    124124
    125 static VBOXCMDVBVA_CTL * vboxCmdVbvaCtlCreate(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, uint32_t cbCtl)
     125static VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_HOST *vboxCmdVbvaCtlCreate(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, uint32_t cbCtl)
    126126{
    127127    Assert(cbCtl >= sizeof (VBOXCMDVBVA_CTL));
    128     return (VBOXCMDVBVA_CTL*)VBoxSHGSMICommandAlloc(&pHGSMICtx->heapCtx, cbCtl, HGSMI_CH_VBVA, VBVA_CMDVBVA_CTL);
    129 }
    130 
    131 static void vboxCmdVbvaCtlFree(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL * pCtl)
     128    return (VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_HOST *)VBoxSHGSMICommandAlloc(&pHGSMICtx->heapCtx, cbCtl,
     129                                                                                HGSMI_CH_VBVA, VBVA_CMDVBVA_CTL);
     130}
     131
     132static void vboxCmdVbvaCtlFree(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_HOST *pCtl)
    132133{
    133134    VBoxSHGSMICommandFree(&pHGSMICtx->heapCtx, pCtl);
    134135}
    135136
    136 static int vboxCmdVbvaCtlSubmitSync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL * pCtl)
    137 {
    138     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pHGSMICtx->heapCtx, pCtl);
     137static int vboxCmdVbvaCtlSubmitSync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL RT_UNTRUSTED_VOLATILE_HOST *pCtl)
     138{
     139    const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHdr = VBoxSHGSMICommandPrepSynch(&pHGSMICtx->heapCtx, pCtl);
    139140    if (!pHdr)
    140141    {
    … …  
    176177static int vboxCmdVbvaCtlSubmitAsync(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CTL * pCtl, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
    177178{
    178     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynch(&pHGSMICtx->heapCtx, pCtl, pfnCompletion, pvCompletion, VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ);
     179    const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHdr = VBoxSHGSMICommandPrepAsynch(&pHGSMICtx->heapCtx, pCtl, pfnCompletion,
     180                                                                                          pvCompletion, VBOXSHGSMI_FLAG_GH_ASYNCH_IRQ);
    179181    HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pHGSMICtx->heapCtx, pHdr);
    180182    if (offCmd == HGSMIOFFSET_VOID)
    … …  
    191193        return rc;
    192194    }
    193     else
    194         WARN(("vboxCmdVbvaSubmit returnd %d", rc));
    195 
     195
     196    WARN(("vboxCmdVbvaSubmit returnd %d", rc));
    196197    VBoxSHGSMICommandCancelAsynch(&pHGSMICtx->heapCtx, pHdr);
    197 
    198198    return rc;
    199199}
    … …  
    201201static int vboxVBVAExCtlSubmitEnableDisable(PVBVAEXBUFFERCONTEXT pCtx, PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, bool fEnable)
    202202{
    203     VBOXCMDVBVA_CTL_ENABLE *pCtl = (VBOXCMDVBVA_CTL_ENABLE*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (*pCtl));
     203    VBOXCMDVBVA_CTL_ENABLE RT_UNTRUSTED_VOLATILE_HOST *pCtl =
     204        (VBOXCMDVBVA_CTL_ENABLE RT_UNTRUSTED_VOLATILE_HOST *)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (*pCtl));
    204205    if (!pCtl)
    205206    {
    … …  
    210211    pCtl->Hdr.u32Type = VBOXCMDVBVACTL_TYPE_ENABLE;
    211212    pCtl->Hdr.i32Result = VERR_NOT_IMPLEMENTED;
    212     memset(&pCtl->Enable, 0, sizeof (pCtl->Enable));
     213    memset((void *)&pCtl->Enable, 0, sizeof(pCtl->Enable));
    213214    pCtl->Enable.u32Flags  = fEnable? VBVA_F_ENABLE: VBVA_F_DISABLE;
    214215    pCtl->Enable.u32Offset = pCtx->offVRAMBuffer;
    … …  
    12321233        uint32_t *pu32ClientID)
    12331234{
    1234     VBOXCMDVBVA_CTL_3DCTL_CONNECT *pConnect = (VBOXCMDVBVA_CTL_3DCTL_CONNECT*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (VBOXCMDVBVA_CTL_3DCTL_CONNECT));
     1235    VBOXCMDVBVA_CTL_3DCTL_CONNECT RT_UNTRUSTED_VOLATILE_HOST *pConnect =
     1236        (VBOXCMDVBVA_CTL_3DCTL_CONNECT RT_UNTRUSTED_VOLATILE_HOST *)vboxCmdVbvaCtlCreate(pHGSMICtx,
     1237                                                                                         sizeof(VBOXCMDVBVA_CTL_3DCTL_CONNECT));
    12351238    if (!pConnect)
    12361239    {
    … …  
    12681271int vboxCmdVbvaConDisconnect(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, uint32_t u32ClientID)
    12691272{
    1270     VBOXCMDVBVA_CTL_3DCTL *pDisconnect = (VBOXCMDVBVA_CTL_3DCTL*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof (VBOXCMDVBVA_CTL_3DCTL));
     1273    VBOXCMDVBVA_CTL_3DCTL RT_UNTRUSTED_VOLATILE_HOST *pDisconnect =
     1274        (VBOXCMDVBVA_CTL_3DCTL RT_UNTRUSTED_VOLATILE_HOST*)vboxCmdVbvaCtlCreate(pHGSMICtx, sizeof(VBOXCMDVBVA_CTL_3DCTL));
    12711275    if (!pDisconnect)
    12721276    {
    … …  
    13311335void vboxCmdVbvaConCmdFree(PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, VBOXCMDVBVA_CRCMD_CMD *pCmd)
    13321336{
    1333     VBOXCMDVBVA_CTL_3DCTL_CMD *pHdr = ((VBOXCMDVBVA_CTL_3DCTL_CMD*)pCmd)-1;
     1337    VBOXCMDVBVA_CTL_3DCTL_CMD RT_UNTRUSTED_VOLATILE_HOST *pHdr = ((VBOXCMDVBVA_CTL_3DCTL_CMD RT_UNTRUSTED_VOLATILE_HOST *)pCmd) - 1;
    13341338    vboxCmdVbvaCtlFree(pHGSMICtx, &pHdr->Hdr);
    13351339}
    … …  
    13511355}
    13521356
    1353 int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
     1357int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd,
     1358                                 PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion)
    13541359{
    13551360    return vboxCmdVbvaConSubmitAsync(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pCmd, pfnCompletion, pvCompletion);
    13561361}
    13571362
    1358 int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd)
    1359 {
    1360     VBOXCMDVBVA_CTL_3DCTL_CMD *pCmd = (VBOXCMDVBVA_CTL_3DCTL_CMD*)pvCmd;
     1363int VBoxCmdVbvaConCmdCompletionData(void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, VBOXCMDVBVA_CRCMD_CMD RT_UNTRUSTED_VOLATILE_HOST **ppCmd)
     1364{
     1365    VBOXCMDVBVA_CTL_3DCTL_CMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = (VBOXCMDVBVA_CTL_3DCTL_CMD RT_UNTRUSTED_VOLATILE_HOST *)pvCmd;
    13611366    if (ppCmd)
    1362         *ppCmd = (VBOXCMDVBVA_CRCMD_CMD*)(pCmd+1);
     1367        *ppCmd = (VBOXCMDVBVA_CRCMD_CMD RT_UNTRUSTED_VOLATILE_HOST *)(pCmd + 1);
    13631368    return pCmd->Hdr.i32Result;
    13641369}
    … …  
    13681373    Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    13691374
    1370     VBOXCMDVBVA_CTL_RESIZE *pResize = (VBOXCMDVBVA_CTL_RESIZE*)vboxCmdVbvaCtlCreate(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, sizeof (VBOXCMDVBVA_CTL_RESIZE));
     1375    VBOXCMDVBVA_CTL_RESIZE RT_UNTRUSTED_VOLATILE_HOST *pResize =
     1376        (VBOXCMDVBVA_CTL_RESIZE RT_UNTRUSTED_VOLATILE_HOST*)vboxCmdVbvaCtlCreate(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
     1377                                                                                 sizeof(VBOXCMDVBVA_CTL_RESIZE));
    13711378    if (!pResize)
    13721379    {
    … …  
    13811388    if (RT_SUCCESS(rc))
    13821389    {
    1383         VBOXCMDVBVA_RESIZE_ENTRY* pEntry = &pResize->Resize.aEntries[0];
    1384         memcpy(pEntry->aTargetMap, pTargetMap, sizeof (pEntry->aTargetMap));
     1390        VBOXCMDVBVA_RESIZE_ENTRY RT_UNTRUSTED_VOLATILE_HOST *pEntry = &pResize->Resize.aEntries[0];
     1391        memcpy((void *)&pEntry->aTargetMap[0], pTargetMap, sizeof(pEntry->aTargetMap));
    13851392        LOG(("[%d] %dx%d, TargetMap0 0x%x, flags 0x%x",
    13861393            pEntry->Screen.u32ViewIndex, pEntry->Screen.u32Width, pEntry->Screen.u32Height, pEntry->aTargetMap[0], pEntry->Screen.u16Flags));

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

    r69500 r71590  
    239239VBOXCMDVBVA_CRCMD_CMD* VBoxCmdVbvaConCmdAlloc(PVBOXMP_DEVEXT pDevExt, uint32_t cbCmd);
    240240void VBoxCmdVbvaConCmdFree(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd);
    241 int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd, FNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion);
    242 int VBoxCmdVbvaConCmdCompletionData(void *pvCmd, VBOXCMDVBVA_CRCMD_CMD **ppCmd);
     241int VBoxCmdVbvaConCmdSubmitAsync(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA_CRCMD_CMD* pCmd,
     242                                 PFNVBOXSHGSMICMDCOMPLETION pfnCompletion, void *pvCompletion);
     243int VBoxCmdVbvaConCmdCompletionData(void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, VBOXCMDVBVA_CRCMD_CMD RT_UNTRUSTED_VOLATILE_HOST **ppCmd);
    243244int VBoxCmdVbvaConCmdResize(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const uint32_t *pTargetMap, const POINT * pVScreenPos, uint16_t fFlags);
    244245#endif /* #ifdef VBOX_WITH_CROGL */

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

    r69500 r71590  
    342342}
    343343
    344 NTSTATUS vboxVdmaCrSubmitWriteReadAsync(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRPACKER *pCrPacker, uint32_t u32CrConClientID, PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, void *pvCompletion)
     344NTSTATUS vboxVdmaCrSubmitWriteReadAsync(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRPACKER *pCrPacker, uint32_t u32CrConClientID,
     345                                        PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION pfnCompletion, void *pvCompletion)
    345346{
    346347    Assert(u32CrConClientID);
    … …  
    547548            }
    548549
    549             void *pvCommandBuffer = NULL;
    550             uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE;
    551             cbCommandBuffer += VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(cVRects);
    552 
    553             pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     550            ;
     551            uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE
     552                                     + VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(cVRects);
     553            void RT_UNTRUSTED_VOLATILE_HOST *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport,
     554                                                                                              cbCommandBuffer);
    554555            if (!pvCommandBuffer)
    555556            {
    … …  
    603604    }
    604605
    605     void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     606    void RT_UNTRUSTED_VOLATILE_HOST *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
    606607    if (!pvCommandBuffer)
    607608    {
    … …  
    878879} VBOXVDMA_CRRXGENERICSYNC, *PVBOXVDMA_CRRXGENERICSYNC;
    879880
    880 static DECLCALLBACK(void) vboxVdmaCrRxGenericSyncCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc, void *pvRx, uint32_t cbRx, void *pvCtx)
     881/** @callback_method_impl{PFNVBOXMP_CRSHGSMITRANSPORT_SENDWRITEREADASYNC_COMPLETION}   */
     882static DECLCALLBACK(void) vboxVdmaCrRxGenericSyncCompletion(PVBOXMP_CRSHGSMITRANSPORT pCon, int rc,
     883                                                            void RT_UNTRUSTED_VOLATILE_HOST *pvRx, uint32_t cbRx, void *pvCtx)
    881884{
    882885    PVBOXMP_VDMACR_WRITEREADCOMPLETION pvCompletionData = (PVBOXMP_VDMACR_WRITEREADCOMPLETION)pvCtx;
    … …  
    884887    if (RT_SUCCESS(rc))
    885888    {
    886         rc = VBoxMpCrCmdRxHandler((CRMessageHeader*)pvRx, cbRx);
     889        rc = VBoxMpCrCmdRxHandler((CRMessageHeader *)pvRx, cbRx);
    887890        if (!RT_SUCCESS(rc))
    888891        {
    … …  
    927930{
    928931    VBOXMP_CRPACKER CrPacker;
    929     void *pvCommandBuffer;
     932    void RT_UNTRUSTED_VOLATILE_HOST *pvCommandBuffer;
    930933} VBOXMP_CRHGSMIMGR;
    931934
    … …  
    10951098    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_VBOXTEXPRESENT(cRects);
    10961099    uint32_t cCommands = 1;
    1097     void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     1100    void RT_UNTRUSTED_VOLATILE_HOST *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
    10981101    if (!pvCommandBuffer)
    10991102    {
    … …  
    11251128    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_CHROMIUMPARAMETERICR;
    11261129    uint32_t cCommands = 1;
    1127     void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     1130    void RT_UNTRUSTED_VOLATILE_HOST *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
    11281131    if (!pvCommandBuffer)
    11291132    {
    … …  
    15281531    int rc = VINF_SUCCESS;
    15291532
    1530     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1533    VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_HOST *pCmd =
     1534        (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_HOST *)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
     1535                                                                           sizeof(VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    15311536    if (pCmd)
    15321537    {
    … …  
    15351540        pCmd->i32Result = VERR_NOT_SUPPORTED;
    15361541
    1537         const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
     1542        const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHdr = VBoxSHGSMICommandPrepSynch(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
     1543                                                                                             pCmd);
    15381544        Assert(pHdr);
    15391545        if (pHdr)
    … …  
    15661572        }
    15671573
    1568         VBoxSHGSMICommandFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
     1574        VBoxSHGSMICommandFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, pCmd);
    15691575    }
    15701576    else
    … …  
    17141720
    17151721#ifdef VBOX_WITH_VDMA
    1716 void vboxVdmaCBufDrFree (PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
    1717 {
    1718     VBoxSHGSMICommandFree (&pInfo->CmdHeap, pDr);
    1719 }
    1720 
    1721 PVBOXVDMACBUF_DR vboxVdmaCBufDrCreate (PVBOXVDMAINFO pInfo, uint32_t cbTrailingData)
     1722void vboxVdmaCBufDrFree(PVBOXVDMAINFO pInfo, VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr)
     1723{
     1724    VBoxSHGSMICommandFree(&pInfo->CmdHeap, pDr);
     1725}
     1726
     1727VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *vboxVdmaCBufDrCreate(PVBOXVDMAINFO pInfo, uint32_t cbTrailingData)
    17221728{
    17231729    uint32_t cbDr = VBOXVDMACBUF_DR_SIZE(cbTrailingData);
    1724     PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)VBoxSHGSMICommandAlloc (&pInfo->CmdHeap, cbDr, HGSMI_CH_VBVA, VBVA_VDMA_CMD);
     1730    VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr =
     1731        (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *)VBoxSHGSMICommandAlloc(&pInfo->CmdHeap, cbDr, HGSMI_CH_VBVA, VBVA_VDMA_CMD);
    17251732    Assert(pDr);
    17261733    if (pDr)
    1727         memset (pDr, 0, cbDr);
     1734        memset((void *)pDr, 0, cbDr);
    17281735    else
    17291736        LOGREL(("VBoxSHGSMICommandAlloc returned NULL"));
    … …  
    17411748}
    17421749
    1743 static DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION) vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void *pvCmd,
    1744                                                                             void *pvContext, void **ppvCompletion)
     1750/** @callback_method_impl{FNVBOXSHGSMICMDCOMPLETION_IRQ} */
     1751static DECLCALLBACK(PFNVBOXSHGSMICMDCOMPLETION)
     1752vboxVdmaCBufDrCompletionIrq(PVBOXSHGSMI pHeap, void RT_UNTRUSTED_VOLATILE_HOST *pvCmd, void *pvContext, void **ppvCompletion)
    17451753{
    17461754    RT_NOREF(pHeap, ppvCompletion);
    17471755    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
    1748     PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvCmd;
     1756    VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr = (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *)pvCmd;
    17491757
    17501758    DXGK_INTERRUPT_TYPE enmComplType;
    … …  
    17561764    else if (pDr->rc == VERR_INTERRUPTED)
    17571765    {
    1758         Assert(0);
     1766        AssertFailed();
    17591767        enmComplType = DXGK_INTERRUPT_DMA_PREEMPTED;
    17601768    }
    17611769    else
    17621770    {
    1763         Assert(0);
     1771        AssertFailed();
    17641772        enmComplType = DXGK_INTERRUPT_DMA_FAULTED;
    17651773    }
    … …  
    17751783}
    17761784
    1777 int vboxVdmaCBufDrSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
    1778 {
    1779     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynchIrq (&pInfo->CmdHeap, pDr, vboxVdmaCBufDrCompletionIrq, pDevExt, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
     1785int vboxVdmaCBufDrSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr)
     1786{
     1787    const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHdr =
     1788        VBoxSHGSMICommandPrepAsynchIrq(&pInfo->CmdHeap, pDr, vboxVdmaCBufDrCompletionIrq, pDevExt, VBOXSHGSMI_FLAG_GH_ASYNCH_FORCE);
    17801789    Assert(pHdr);
    17811790    int rc = VERR_GENERAL_FAILURE;
    … …  
    18081817}
    18091818
    1810 int vboxVdmaCBufDrSubmitSynch(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr)
    1811 {
    1812     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepAsynch (&pInfo->CmdHeap, pDr, NULL, NULL, VBOXSHGSMI_FLAG_GH_SYNCH);
     1819int vboxVdmaCBufDrSubmitSynch(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr)
     1820{
     1821    const VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_HOST *pHdr = VBoxSHGSMICommandPrepAsynch(&pInfo->CmdHeap, pDr, NULL,
     1822                                                                                          NULL, VBOXSHGSMI_FLAG_GH_SYNCH);
    18131823    Assert(pHdr);
    18141824    int rc = VERR_GENERAL_FAILURE;

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

    r69500 r71590  
    7171NTSTATUS vboxVdmaDdiCmdSubmitted(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd);
    7272
    73 DECLINLINE(VOID) vboxVdmaDdiCmdInit(PVBOXVDMADDI_CMD pCmd,
    74         uint32_t u32NodeOrdinal, uint32_t u32FenceId,
    75         PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete, PVOID pvComplete)
     73DECLINLINE(VOID) vboxVdmaDdiCmdInit(PVBOXVDMADDI_CMD pCmd, uint32_t u32NodeOrdinal, uint32_t u32FenceId,
     74                                    PFNVBOXVDMADDICMDCOMPLETE_DPC pfnComplete, PVOID pvComplete)
    7675{
    7776    pCmd->QueueEntry.Blink = NULL;
    … …  
    283282    return VBoxSHGSMICommandPtrOffset(&pInfo->CmdHeap, pvPtr);
    284283}
    285 int vboxVdmaCBufDrSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
    286 int vboxVdmaCBufDrSubmitSynch(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, PVBOXVDMACBUF_DR pDr);
    287 struct VBOXVDMACBUF_DR* vboxVdmaCBufDrCreate(PVBOXVDMAINFO pInfo, uint32_t cbTrailingData);
    288 void vboxVdmaCBufDrFree(PVBOXVDMAINFO pInfo, struct VBOXVDMACBUF_DR* pDr);
     284int vboxVdmaCBufDrSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr);
     285int vboxVdmaCBufDrSubmitSynch(PVBOXMP_DEVEXT pDevExt, PVBOXVDMAINFO pInfo, VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr);
     286struct VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *vboxVdmaCBufDrCreate(PVBOXVDMAINFO pInfo, uint32_t cbTrailingData);
     287void vboxVdmaCBufDrFree(PVBOXVDMAINFO pInfo, struct VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr);
    289288
    290289#define VBOXVDMACBUF_DR_DATA_OFFSET() (sizeof (VBOXVDMACBUF_DR))

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

    r69500 r71590  
    2727
    2828
    29 DECLINLINE(void) vboxVhwaHdrInit(VBOXVHWACMD* pHdr, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd)
    30 {
    31     memset(pHdr, 0, sizeof(VBOXVHWACMD));
     29DECLINLINE(void) vboxVhwaHdrInit(VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pHdr,
     30                                 D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd)
     31{
     32    memset((void *)pHdr, 0, sizeof(VBOXVHWACMD));
    3233    pHdr->iDisplay = srcId;
    3334    pHdr->rc = VERR_GENERAL_FAILURE;
    … …  
    3940
    4041#ifdef VBOXVHWA_WITH_SHGSMI
    41 static int vboxVhwaCommandSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, HGSMIOFFSET offDr)
     42static int vboxVhwaCommandSubmitHgsmi(struct _DEVICE_EXTENSION *pDevExt, HGSMIOFFSET offDr)
    4243{
    4344    VBoxHGSMIGuestWrite(pDevExt, offDr);
    … …  
    4546}
    4647#else
    47 DECLINLINE(void) vbvaVhwaCommandRelease(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
     48DECLINLINE(void) vbvaVhwaCommandRelease(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    4849{
    4950    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
    … …  
    5556}
    5657
    57 DECLINLINE(void) vbvaVhwaCommandRetain(VBOXVHWACMD *pCmd)
     58DECLINLINE(void) vbvaVhwaCommandRetain(VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    5859{
    5960    ASMAtomicIncU32(&pCmd->cRefs);
    … …  
    6162
    6263/* do not wait for completion */
    63 void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void *pContext)
     64void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd,
     65                                 PFNVBOXVHWACMDCOMPLETION pfnCompletion, void *pContext)
    6466{
    6567    pCmd->GuestVBVAReserved1 = (uintptr_t)pfnCompletion;
    … …  
    6971    VBoxHGSMIBufferSubmit(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pCmd);
    7072
    71     if(   !(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
    72        || (   (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
    73            && (pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED) ) )
     73    uint32_t const fFlags = pCmd->Flags;
     74    if(   !(fFlags & VBOXVHWACMD_FLAG_HG_ASYNCH)
     75       || (   (fFlags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
     76           && (fFlags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED) ) )
    7477    {
    7578        /* the command is completed */
    … …  
    8083}
    8184
    82 static DECLCALLBACK(void) vboxVhwaCompletionSetEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD * pCmd, void * pvContext)
    83 {
    84     RT_NOREF(pDevExt,  pCmd);
     85/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */
     86static DECLCALLBACK(void)
     87vboxVhwaCompletionSetEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, void *pvContext)
     88{
     89    RT_NOREF(pDevExt, pCmd);
    8590    RTSemEventSignal((RTSEMEVENT)pvContext);
    8691}
    8792
    88 void vboxVhwaCommandSubmitAsynchByEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent)
     93void vboxVhwaCommandSubmitAsynchByEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, RTSEMEVENT hEvent)
    8994{
    9095    vboxVhwaCommandSubmitAsynch(pDevExt, pCmd, vboxVhwaCompletionSetEvent, hEvent);
    … …  
    98103}
    99104
    100 VBOXVHWACMD* vboxVhwaCommandCreate(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
     105VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *vboxVhwaCommandCreate(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
     106                                                              VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
    101107{
    102108    vboxVhwaCommandCheckCompletion(pDevExt);
     109    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pHdr;
    103110#ifdef VBOXVHWA_WITH_SHGSMI
    104     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap,
    105                               cbCmd + VBOXVHWACMD_HEADSIZE(),
    106                               HGSMI_CH_VBVA,
    107                               VBVA_VHWA_CMD);
     111    pHdr = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap,
     112                                                                            cbCmd + VBOXVHWACMD_HEADSIZE(),
     113                                                                            HGSMI_CH_VBVA,
     114                                                                            VBVA_VHWA_CMD);
    108115#else
    109     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxHGSMIBufferAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
    110                               cbCmd + VBOXVHWACMD_HEADSIZE(),
    111                               HGSMI_CH_VBVA,
    112                               VBVA_VHWA_CMD);
     116    pHdr = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
     117                                                                          cbCmd + VBOXVHWACMD_HEADSIZE(),
     118                                                                          HGSMI_CH_VBVA,
     119                                                                          VBVA_VHWA_CMD);
    113120#endif
    114121    Assert(pHdr);
    115122    if (!pHdr)
    116     {
    117123        LOGREL(("VBoxHGSMIBufferAlloc failed"));
    118     }
    119124    else
    120     {
    121125        vboxVhwaHdrInit(pHdr, srcId, enmCmd);
    122     }
    123126
    124127    return pHdr;
    125128}
    126129
    127 void vboxVhwaCommandFree(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
     130void vboxVhwaCommandFree(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    128131{
    129132#ifdef VBOXVHWA_WITH_SHGSMI
    … …  
    134137}
    135138
    136 int vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
     139int vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    137140{
    138141#ifdef VBOXVHWA_WITH_SHGSMI
    … …  
    184187
    185188#ifndef VBOXVHWA_WITH_SHGSMI
    186 static DECLCALLBACK(void) vboxVhwaCompletionFreeCmd(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD *pCmd, void *pvContext)
     189/** @callback_method_impl{FNVBOXVHWACMDCOMPLETION} */
     190static DECLCALLBACK(void)
     191vboxVhwaCompletionFreeCmd(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, void *pvContext)
    187192{
    188193    RT_NOREF(pvContext);
    … …  
    197202        /* need to save next since the command may be released in a pfnCallback and thus its data might be invalid */
    198203        pNext = pCur->pNext;
    199         VBOXVHWACMD *pCmd = VBOXVHWA_LISTENTRY2CMD(pCur);
     204        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = VBOXVHWA_LISTENTRY2CMD(pCur);
    200205        PFNVBOXVHWACMDCOMPLETION pfnCallback = (PFNVBOXVHWACMDCOMPLETION)pCmd->GuestVBVAReserved1;
    201206        void *pvCallback = (void*)pCmd->GuestVBVAReserved2;
    … …  
    206211#endif
    207212
    208 void vboxVhwaCommandSubmitAsynchAndComplete(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
     213void vboxVhwaCommandSubmitAsynchAndComplete(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    209214{
    210215#ifdef VBOXVHWA_WITH_SHGSMI
    … …  
    231236VBOXVHWACMD_QUERYINFO1* vboxVhwaQueryHostInfo1(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    232237{
    233     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
    234     VBOXVHWACMD_QUERYINFO1 *pInfo1;
    235 
    236     Assert(pCmd);
    237     if (!pCmd)
    238     {
    239         LOGREL(("vboxVhwaCommandCreate failed"));
    240         return NULL;
    241     }
    242 
    243     pInfo1 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
     238    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1,
     239                                                                         sizeof(VBOXVHWACMD_QUERYINFO1));
     240    AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), NULL);
     241
     242    VBOXVHWACMD_QUERYINFO1 *pInfo1 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
    244243    pInfo1->u.in.guestVersion.maj = VBOXVHWA_VERSION_MAJ;
    245244    pInfo1->u.in.guestVersion.min = VBOXVHWA_VERSION_MIN;
    … …  
    249248    int rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
    250249    AssertRC(rc);
    251     if(RT_SUCCESS(rc))
    252     {
    253         if(RT_SUCCESS(pCmd->rc))
    254         {
     250    if (RT_SUCCESS(rc))
     251        if (RT_SUCCESS(pCmd->rc))
    255252            return VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
    256         }
    257     }
    258253
    259254    vboxVhwaCommandFree(pDevExt, pCmd);
    … …  
    263258VBOXVHWACMD_QUERYINFO2* vboxVhwaQueryHostInfo2(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC)
    264259{
    265     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC));
    266     VBOXVHWACMD_QUERYINFO2 *pInfo2;
    267     Assert(pCmd);
    268     if (!pCmd)
    269     {
    270         LOGREL(("vboxVhwaCommandCreate failed"));
    271         return NULL;
    272     }
    273 
    274     pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
     260    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2,
     261                                                                         VBOXVHWAINFO2_SIZE(numFourCC));
     262    AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), NULL);
     263
     264    VBOXVHWACMD_QUERYINFO2 *pInfo2 = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
    275265    pInfo2->numFourCC = numFourCC;
    276266
    … …  
    295285int vboxVhwaEnable(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    296286{
    297     int rc = VERR_GENERAL_FAILURE;
    298     VBOXVHWACMD* pCmd;
    299 
    300     pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
    301     Assert(pCmd);
    302     if (!pCmd)
    303     {
    304         LOGREL(("vboxVhwaCommandCreate failed"));
    305         return rc;
    306     }
    307 
    308     rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     287    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
     288    AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), VERR_GENERAL_FAILURE);
     289
     290    int rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
    309291    AssertRC(rc);
    310292    if(RT_SUCCESS(rc))
    … …  
    325307    vboxVhwaCommandCheckCompletion(pDevExt);
    326308
    327     int rc = VERR_GENERAL_FAILURE;
    328     VBOXVHWACMD* pCmd;
    329 
    330     pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
    331     Assert(pCmd);
    332     if (!pCmd)
    333     {
    334         LOGREL(("vboxVhwaCommandCreate failed"));
    335         return rc;
    336     }
    337 
    338     rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
     309    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd  = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
     310    AssertReturnStmt(pCmd, LOGREL(("vboxVhwaCommandCreate failed")), VERR_GENERAL_FAILURE);
     311
     312    int rc = vboxVhwaCommandSubmit(pDevExt, pCmd);
    339313    AssertRC(rc);
    340     if(RT_SUCCESS(rc))
     314    if (RT_SUCCESS(rc))
    341315    {
    342316        if(RT_SUCCESS(pCmd->rc))
    … …  
    511485        return VERR_INVALID_STATE;
    512486
    513     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
    514             VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
     487    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId, VBOXVHWACMD_TYPE_SURF_DESTROY,
     488                                                                        sizeof(VBOXVHWACMD_SURF_DESTROY));
    515489    Assert(pCmd);
    516     if(pCmd)
     490    if (pCmd)
    517491    {
    518492        VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
    … …  
    636610{
    637611    /* the first thing we need is to post create primary */
    638     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
    639                 VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE));
     612    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId, VBOXVHWACMD_TYPE_SURF_CREATE,
     613                                                                        sizeof(VBOXVHWACMD_SURF_CREATE));
    640614    Assert(pCmd);
    641615    if (pCmd)
    … …  
    671645{
    672646    /* the first thing we need is to post create primary */
    673     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId,
    674             VBOXVHWACMD_TYPE_SURF_GETINFO, sizeof(VBOXVHWACMD_SURF_GETINFO));
     647    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pDevExt, VidPnSourceId, VBOXVHWACMD_TYPE_SURF_GETINFO,
     648                                                                        sizeof(VBOXVHWACMD_SURF_GETINFO));
    675649    Assert(pCmd);
    676650    if (pCmd)
    … …  
    844818        PVBOXWDDM_OVERLAYFLIP_INFO pOurInfo = (PVBOXWDDM_OVERLAYFLIP_INFO)pFlipInfo->pPrivateDriverData;
    845819
    846         VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
    847                 VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP));
     820        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
     821                                                                             VBOXVHWACMD_TYPE_SURF_FLIP,
     822                                                                             sizeof(VBOXVHWACMD_SURF_FLIP));
    848823        Assert(pCmd);
    849         if(pCmd)
     824        if (pCmd)
    850825        {
    851826            VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
    … …  
    915890
    916891    int rc;
    917     VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
    918                 VBOXVHWACMD_TYPE_SURF_FLIP, RT_OFFSETOF(VBOXVHWACMD_SURF_COLORFILL, u.in.aRects[pCF->ClrFill.Rects.cRects]));
     892    VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd =
     893        vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId, VBOXVHWACMD_TYPE_SURF_FLIP,
     894                              RT_OFFSETOF(VBOXVHWACMD_SURF_COLORFILL, u.in.aRects[pCF->ClrFill.Rects.cRects]));
    919895    Assert(pCmd);
    920896    if(pCmd)
    … …  
    1003979        PVBOXWDDM_OVERLAY_INFO pOurInfo = (PVBOXWDDM_OVERLAY_INFO)pOverlayInfo->pPrivateDriverData;
    1004980
    1005         VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
    1006                 VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE, sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
     981        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * pCmd = vboxVhwaCommandCreate(pOverlay->pDevExt, pOverlay->VidPnSourceId,
     982                                                                              VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE,
     983                                                                              sizeof(VBOXVHWACMD_SURF_OVERLAY_UPDATE));
    1007984        Assert(pCmd);
    1008         if(pCmd)
     985        if (pCmd)
    1009986        {
    1010987            VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);

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

    r69500 r71590  
    2323#include "VBoxMPShgsmi.h"
    2424
    25 VBOXVHWACMD* vboxVhwaCommandCreate(PVBOXMP_DEVEXT pDevExt,
    26         D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
    27         VBOXVHWACMD_TYPE enmCmd,
    28         VBOXVHWACMD_LENGTH cbCmd);
     25VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * vboxVhwaCommandCreate(PVBOXMP_DEVEXT pDevExt,
     26                                                               D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
     27                                                               VBOXVHWACMD_TYPE enmCmd,
     28                                                               VBOXVHWACMD_LENGTH cbCmd);
    2929
    30 void vboxVhwaCommandFree(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd);
    31 int vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd);
    32 int vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd);
    33 void vboxVhwaCommandSubmitAsynchAndComplete(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd);
     30void vboxVhwaCommandFree(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd);
     31int  vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * pCmd);
     32void vboxVhwaCommandSubmitAsynchAndComplete(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd);
    3433
    3534#ifndef VBOXVHWA_WITH_SHGSMI
    36 typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD * pCmd, void * pContext);
     35typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * pCmd,
     36                                                   void *pvContext);
    3737typedef FNVBOXVHWACMDCOMPLETION *PFNVBOXVHWACMDCOMPLETION;
    3838
    39 void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext);
    40 void vboxVhwaCommandSubmitAsynchByEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent);
     39void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd,
     40                                 PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext);
     41void vboxVhwaCommandSubmitAsynchByEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd, RTSEMEVENT hEvent);
    4142
    42 #define VBOXVHWA_CMD2LISTENTRY(_pCmd) ((PVBOXVTLIST_ENTRY)&(_pCmd)->u.pNext)
    43 #define VBOXVHWA_LISTENTRY2CMD(_pEntry) ( (VBOXVHWACMD*)((uint8_t *)(_pEntry) - RT_OFFSETOF(VBOXVHWACMD, u.pNext)) )
     43#define VBOXVHWA_CMD2LISTENTRY(_pCmd)   ((PVBOXVTLIST_ENTRY)&(_pCmd)->u.pNext)
     44#define VBOXVHWA_LISTENTRY2CMD(_pEntry) ( (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *)((uint8_t *)(_pEntry) - RT_OFFSETOF(VBOXVHWACMD, u.pNext)) )
    4445
    45 DECLINLINE(void) vboxVhwaPutList(VBOXVTLIST *pList, VBOXVHWACMD* pCmd)
     46DECLINLINE(void) vboxVhwaPutList(VBOXVTLIST *pList, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd)
    4647{
    4748    vboxVtListPut(pList, VBOXVHWA_CMD2LISTENTRY(pCmd), VBOXVHWA_CMD2LISTENTRY(pCmd));

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

    r71514 r71590  
    211211int vboxWddmGhDisplayPostInfoScreen(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
    212212{
    213     void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
    214                                       sizeof (VBVAINFOSCREEN),
    215                                       HGSMI_CH_VBVA,
    216                                       VBVA_INFO_SCREEN);
    217     if (!p)
     213    VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *pScreen =
     214        (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
     215                                                                          sizeof(VBVAINFOSCREEN),
     216                                                                          HGSMI_CH_VBVA,
     217                                                                          VBVA_INFO_SCREEN);
     218    if (!pScreen != NULL)
    218219    {
    219220        WARN(("VBoxHGSMIBufferAlloc failed"));
    220 
    221221        return VERR_OUT_OF_RESOURCES;
    222222    }
    223 
    224     VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
    225223
    226224    int rc = vboxWddmScreenInfoInit(pScreen, pAllocData, pVScreenPos, fFlags);
    227225    if (RT_SUCCESS(rc))
    228226    {
    229         pScreen->u32StartOffset  = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
    230 
    231         rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
     227        pScreen->u32StartOffset = 0; //(uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
     228
     229        rc = VBoxHGSMIBufferSubmit(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pScreen);
    232230        if (RT_FAILURE(rc))
    233231            WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
    … …  
    236234        WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
    237235
    238     VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
     236    VBoxHGSMIBufferFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pScreen);
    239237
    240238    return rc;
    … …  
    251249
    252250    /* Issue the screen info command. */
    253     void *p = VBoxHGSMIBufferAlloc (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
    254                                       sizeof (VBVAINFOVIEW),
    255                                       HGSMI_CH_VBVA,
    256                                       VBVA_INFO_VIEW);
    257     if (!p)
     251    VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_HOST *pView =
     252        (VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx,
     253                                                                        sizeof(VBVAINFOVIEW), HGSMI_CH_VBVA, VBVA_INFO_VIEW);
     254    if (!pView)
    258255    {
    259256        WARN(("VBoxHGSMIBufferAlloc failed"));
    260257        return VERR_OUT_OF_RESOURCES;
    261258    }
    262 
    263     VBVAINFOVIEW *pView = (VBVAINFOVIEW *)p;
    264 
    265259    pView->u32ViewIndex     = pAllocData->SurfDesc.VidPnSourceId;
    266260    pView->u32ViewOffset    = (uint32_t)offVram; /* we pretend the view is located at the start of each framebuffer */
    267261    pView->u32ViewSize      = vboxWddmVramCpuVisibleSegmentSize(pDevExt)/VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
    268 
    269262    pView->u32MaxScreenSize = pView->u32ViewSize;
    270263
    271     int rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
     264    int rc = VBoxHGSMIBufferSubmit (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pView);
    272265    if (RT_FAILURE(rc))
    273266        WARN(("VBoxHGSMIBufferSubmit failed %d", rc));
    274267
    275     VBoxHGSMIBufferFree (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, p);
    276 
     268    VBoxHGSMIBufferFree(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pView);
    277269    return rc;
    278270}
    … …  
    15611553
    15621554            uint16_t chInfo;
    1563             uint8_t *pvCmd = HGSMIBufferDataAndChInfoFromOffset (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, offCmd, &chInfo);
     1555            uint8_t RT_UNTRUSTED_VOLATILE_HOST *pvCmd =
     1556                HGSMIBufferDataAndChInfoFromOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, offCmd, &chInfo);
    15641557            if (!pvCmd)
    15651558            {
    … …  
    15721565                case VBVA_CMDVBVA_CTL:
    15731566                {
    1574                     int rc = VBoxSHGSMICommandProcessCompletion (&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, (VBOXSHGSMIHEADER*)pvCmd, TRUE /*bool bIrq*/ , &CtlList);
     1567                    int rc = VBoxSHGSMICommandProcessCompletion(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
     1568                                                                (VBOXSHGSMIHEADER *)pvCmd, TRUE /*bool bIrq*/ , &CtlList);
    15751569                    AssertRC(rc);
    15761570                    break;
    … …  
    17181712                    {
    17191713                        uint16_t chInfo;
    1720                         uint8_t *pvCmd = HGSMIBufferDataAndChInfoFromOffset(&pHeap->Heap.area, offCmd, &chInfo);
     1714                        uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pvCmd =
     1715                            HGSMIBufferDataAndChInfoFromOffset(&pHeap->Heap.area, offCmd, &chInfo);
    17211716                        Assert(pvCmd);
    17221717                        if (pvCmd)
    … …  
    39623957            }
    39633958            UINT cbCmd = VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_TRANSFER);
    3964             PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, cbCmd);
     3959            VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_HOST *pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    39653960            Assert(pDr);
    39663961            if (pDr)

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

    r71323 r71590  
    164164}
    165165
    166 DECLINLINE(int) vboxWddmScreenInfoInit(VBVAINFOSCREEN *pScreen, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
     166DECLINLINE(int) vboxWddmScreenInfoInit(VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *pScreen,
     167                                       const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint16_t fFlags)
    167168{
    168169    VBOXVIDEOOFFSET offVram = vboxWddmAddrFramOffset(&pAllocData->Addr);

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

    r69500 r71590  
    452452
    453453static DECLCALLBACK(int)
    454 VBoxVbvaChannelGenericHandlerCB(void *pvHandler, uint16_t u16ChannelInfo, void *pvBuffer, HGSMISIZE cbBuffer)
     454VBoxVbvaChannelGenericHandlerCB(void *pvHandler, uint16_t u16ChannelInfo,
     455                                void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer, HGSMISIZE cbBuffer)
    455456{
    456457    VBVA_CHANNELCONTEXTS *pCallbacks = (VBVA_CHANNELCONTEXTS*)pvHandler;

  • trunk/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp

    r69309 r71590  
    6060DECLHIDDEN(int) VBoxHGSMIReportFlagsLocation(PHGSMIGUESTCOMMANDCONTEXT pCtx, HGSMIOFFSET offLocation)
    6161{
    62     HGSMIBUFFERLOCATION *p;
    63 
    64     /* Allocate the IO buffer. */
    65     p = (HGSMIBUFFERLOCATION *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_HGSMI,
    66                                                     HGSMI_CC_HOST_FLAGS_LOCATION);
     62
     63    /* Allocate the IO buffer. */
     64    HGSMIBUFFERLOCATION RT_UNTRUSTED_VOLATILE_HOST *p =
     65        (HGSMIBUFFERLOCATION RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_HGSMI,
     66                                                                               HGSMI_CC_HOST_FLAGS_LOCATION);
    6767    if (!p)
    6868        return VERR_NO_MEMORY;
    … …  
    9090DECLHIDDEN(int) VBoxHGSMISendCapsInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx, uint32_t fCaps)
    9191{
    92     VBVACAPS *p;
    93 
    94     /* Allocate the IO buffer. */
    95     p = (VBVACAPS *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_VBVA, VBVA_INFO_CAPS);
     92
     93    /* Allocate the IO buffer. */
     94    VBVACAPS RT_UNTRUSTED_VOLATILE_HOST *p =
     95        (VBVACAPS RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pCtx, sizeof(*p), HGSMI_CH_VBVA, VBVA_INFO_CAPS);
    9696
    9797    if (!p)

  • trunk/src/VBox/Additions/common/VBoxVideo/HGSMIBuffers.cpp

    r69309 r71590  
    7272 * @param  u16Op    the HGSMI command to be sent, set to the descriptor
    7373 */
    74 DECLHIDDEN(void *) VBoxHGSMIBufferAlloc(PHGSMIGUESTCOMMANDCONTEXT pCtx,
    75                                         HGSMISIZE cbData,
    76                                         uint8_t u8Ch,
    77                                         uint16_t u16Op)
     74DECLHIDDEN(void RT_UNTRUSTED_VOLATILE_HOST *) VBoxHGSMIBufferAlloc(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     75                                                                   HGSMISIZE cbData,
     76                                                                   uint8_t u8Ch,
     77                                                                   uint16_t u16Op)
    7878{
    7979#ifdef VBOX_WDDM_MINIPORT
    80     return VBoxSHGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
     80    return VBoxSHGSMIHeapAlloc(&pCtx->heapCtx, cbData, u8Ch, u16Op);
    8181#else
    82     return HGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
     82    return HGSMIHeapAlloc(&pCtx->heapCtx, cbData, u8Ch, u16Op);
    8383#endif
    8484}
    … …  
    9191 * @param  pvBuffer  the pointer returned by @a VBoxHGSMIBufferAlloc
    9292 */
    93 DECLHIDDEN(void) VBoxHGSMIBufferFree(PHGSMIGUESTCOMMANDCONTEXT pCtx,
    94                                      void *pvBuffer)
     93DECLHIDDEN(void) VBoxHGSMIBufferFree(PHGSMIGUESTCOMMANDCONTEXT pCtx, void  RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    9594{
    9695#ifdef VBOX_WDDM_MINIPORT
    97     VBoxSHGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
     96    VBoxSHGSMIHeapFree(&pCtx->heapCtx, pvBuffer);
    9897#else
    99     HGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
     98    HGSMIHeapFree(&pCtx->heapCtx, pvBuffer);
    10099#endif
    101100}
    … …  
    107106 * @param  pvBuffer  the pointer returned by @a VBoxHGSMIBufferAlloc
    108107 */
    109 DECLHIDDEN(int) VBoxHGSMIBufferSubmit(PHGSMIGUESTCOMMANDCONTEXT pCtx,
    110                                       void *pvBuffer)
     108DECLHIDDEN(int) VBoxHGSMIBufferSubmit(PHGSMIGUESTCOMMANDCONTEXT pCtx, void RT_UNTRUSTED_VOLATILE_HOST *pvBuffer)
    111109{
    112110    /* Initialize the buffer and get the offset for port IO. */
    113     HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (HGSMIGUESTCMDHEAP_GET(&pCtx->heapCtx), pvBuffer);
     111    HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset(HGSMIGUESTCMDHEAP_GET(&pCtx->heapCtx), pvBuffer);
    114112
    115113    Assert(offBuffer != HGSMIOFFSET_VOID);

  • trunk/src/VBox/Additions/common/VBoxVideo/HGSMIHostCmd.cpp

    r69309 r71590  
    7676 *                be completed
    7777 */
    78 DECLHIDDEN(void) VBoxHGSMIHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx,
    79                                           void *pvMem)
    80 {
    81     HGSMIBUFFERHEADER *pHdr = HGSMIBufferHeaderFromData(pvMem);
     78DECLHIDDEN(void) VBoxHGSMIHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx, void RT_UNTRUSTED_VOLATILE_HOST *pvMem)
     79{
     80    HGSMIBUFFERHEADER RT_UNTRUSTED_VOLATILE_GUEST *pHdr = HGSMIBufferHeaderFromData(pvMem);
    8281    HGSMIOFFSET offMem = HGSMIPointerToOffset(&pCtx->areaCtx, pHdr);
    8382    Assert(offMem != HGSMIOFFSET_VOID);
    84     if(offMem != HGSMIOFFSET_VOID)
    85     {
     83    if (offMem != HGSMIOFFSET_VOID)
    8684        HGSMINotifyHostCmdComplete(pCtx, offMem);
    87     }
    8885}
    8986

  • trunk/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp

    r71488 r71590  
    152152    int rc;
    153153    /* Issue the screen info command. */
    154     void *p = VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVAINFOVIEW) * u32Count,
    155                                    HGSMI_CH_VBVA, VBVA_INFO_VIEW);
    156     if (p)
    157     {
    158         VBVAINFOVIEW *pInfo = (VBVAINFOVIEW *)p;
    159         rc = pfnFill(pvData, pInfo, u32Count);
     154    VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_HOST *pInfo =
     155        (VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVAINFOVIEW) * u32Count,
     156                                                                        HGSMI_CH_VBVA, VBVA_INFO_VIEW);
     157    if (pInfo)
     158    {
     159        rc = pfnFill(pvData, (VBVAINFOVIEW *)pInfo /* lazy bird */, u32Count);
    160160        if (RT_SUCCESS(rc))
    161             VBoxHGSMIBufferSubmit (pCtx, p);
    162         VBoxHGSMIBufferFree(pCtx, p);
     161            VBoxHGSMIBufferSubmit(pCtx, pInfo);
     162        VBoxHGSMIBufferFree(pCtx, pInfo);
    163163    }
    164164    else
    … …  
    294294{
    295295    /* Issue the screen info command. */
    296     void *p = VBoxHGSMIBufferAlloc(pCtx,
    297                                    sizeof (VBVAINFOSCREEN),
    298                                    HGSMI_CH_VBVA,
    299                                    VBVA_INFO_SCREEN);
    300     if (!p)
    301     {
    302         // LogFunc(("HGSMIHeapAlloc failed\n"));
    303     }
    304     else
    305     {
    306         VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
    307 
     296    VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *pScreen =
     297        (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVAINFOSCREEN),
     298                                                                          HGSMI_CH_VBVA, VBVA_INFO_SCREEN);
     299    if (pScreen != NULL)
     300    {
    308301        pScreen->u32ViewIndex    = cDisplay;
    309302        pScreen->i32OriginX      = cOriginX;
    … …  
    316309        pScreen->u16Flags        = fFlags;
    317310
    318         VBoxHGSMIBufferSubmit(pCtx, p);
    319 
    320         VBoxHGSMIBufferFree(pCtx, p);
     311        VBoxHGSMIBufferSubmit(pCtx, pScreen);
     312
     313        VBoxHGSMIBufferFree(pCtx, pScreen);
     314    }
     315    else
     316    {
     317        // LogFunc(("HGSMIHeapAlloc failed\n"));
    321318    }
    322319}
    … …  
    338335                                                 uint32_t cWidth, uint32_t cHeight)
    339336{
    340     int rc = VINF_SUCCESS;
     337    int rc;
    341338    VBVAREPORTINPUTMAPPING *p;
    342339    // Log(("%s: cOriginX=%d, cOriginY=%d, cWidth=%u, cHeight=%u\n", __PRETTY_FUNCTION__, (int)cOriginX, (int)cOriginX,
    … …  
    377374{
    378375    int rc;
    379     void *p;
    380 
    381     AssertPtr(paHints);
    382     if (!VALID_PTR(paHints))
    383         return VERR_INVALID_POINTER;
    384 
    385     p = VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVAQUERYMODEHINTS)
    386                                        + cScreens * sizeof(VBVAMODEHINT),
    387                              HGSMI_CH_VBVA, VBVA_QUERY_MODE_HINTS);
    388     if (!p)
    389     {
    390         // LogFunc(("HGSMIHeapAlloc failed\n"));
    391         return VERR_NO_MEMORY;
    392     }
    393     else
    394     {
    395         VBVAQUERYMODEHINTS *pQuery   = (VBVAQUERYMODEHINTS *)p;
    396 
     376    VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_HOST *pQuery;
     377
     378    AssertPtrReturn(paHints, VERR_INVALID_POINTER);
     379    pQuery = (VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pCtx,
     380                                                                                      sizeof(VBVAQUERYMODEHINTS)
     381                                                                                   +  cScreens * sizeof(VBVAMODEHINT),
     382                                                                                   HGSMI_CH_VBVA, VBVA_QUERY_MODE_HINTS);
     383    if (pQuery != NULL)
     384    {
    397385        pQuery->cHintsQueried        = cScreens;
    398386        pQuery->cbHintStructureGuest = sizeof(VBVAMODEHINT);
    399387        pQuery->rc                   = VERR_NOT_SUPPORTED;
    400388
    401         VBoxHGSMIBufferSubmit(pCtx, p);
     389        VBoxHGSMIBufferSubmit(pCtx, pQuery);
    402390        rc = pQuery->rc;
    403391        if (RT_SUCCESS(rc))
    404             memcpy(paHints, ((uint8_t *)p) + sizeof(VBVAQUERYMODEHINTS),
    405                    cScreens * sizeof(VBVAMODEHINT));
    406 
    407         VBoxHGSMIBufferFree(pCtx, p);
     392            memcpy(paHints, (void *)(pQuery + 1), cScreens * sizeof(VBVAMODEHINT));
     393
     394        VBoxHGSMIBufferFree(pCtx, pQuery);
     395    }
     396    else
     397    {
     398        // LogFunc(("HGSMIHeapAlloc failed\n"));
     399        rc = VERR_NO_MEMORY;
    408400    }
    409401    return rc;

  • trunk/src/VBox/Additions/common/VBoxVideo/VBVABase.cpp

    r69309 r71590  
    5656
    5757
    58 static bool vboxVBVAInformHost(PVBVABUFFERCONTEXT pCtx,
    59                                PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
    60                                int32_t cScreen, bool bEnable)
    61 {
    62     bool bRc = false;
     58static bool vboxVBVAInformHost(PVBVABUFFERCONTEXT pCtx, PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, int32_t cScreen, bool fEnable)
     59{
     60    bool fRc = false;
    6361
    6462#if 0  /* All callers check this */
    … …  
    6664#endif
    6765    {
    68         void *p = VBoxHGSMIBufferAlloc(pHGSMICtx,
    69                                        sizeof (VBVAENABLE_EX),
    70                                        HGSMI_CH_VBVA,
    71                                        VBVA_ENABLE);
    72         if (!p)
    73         {
    74             // LogFunc(("HGSMIHeapAlloc failed\n"));
    75         }
    76         else
    77         {
    78             VBVAENABLE_EX *pEnable = (VBVAENABLE_EX *)p;
    79 
    80             pEnable->Base.u32Flags  = bEnable? VBVA_F_ENABLE: VBVA_F_DISABLE;
     66        VBVAENABLE_EX RT_UNTRUSTED_VOLATILE_HOST *pEnable =
     67            (VBVAENABLE_EX RT_UNTRUSTED_VOLATILE_HOST *)VBoxHGSMIBufferAlloc(pHGSMICtx, sizeof(VBVAENABLE_EX),
     68                                                                             HGSMI_CH_VBVA, VBVA_ENABLE);
     69        if (pEnable != NULL)
     70        {
     71            pEnable->Base.u32Flags  = fEnable ? VBVA_F_ENABLE : VBVA_F_DISABLE;
    8172            pEnable->Base.u32Offset = pCtx->offVRAMBuffer;
    8273            pEnable->Base.i32Result = VERR_NOT_SUPPORTED;
    … …  
    8778            }
    8879
    89             VBoxHGSMIBufferSubmit(pHGSMICtx, p);
    90 
    91             if (bEnable)
    92             {
    93                 bRc = RT_SUCCESS(pEnable->Base.i32Result);
    94             }
     80            VBoxHGSMIBufferSubmit(pHGSMICtx, pEnable);
     81
     82            if (fEnable)
     83                fRc = RT_SUCCESS(pEnable->Base.i32Result);
    9584            else
    96             {
    97                 bRc = true;
    98             }
    99 
    100             VBoxHGSMIBufferFree(pHGSMICtx, p);
    101         }
    102     }
    103 
    104     return bRc;
     85                fRc = true;
     86
     87            VBoxHGSMIBufferFree(pHGSMICtx, pEnable);
     88        }
     89        else
     90        {
     91            // LogFunc(("HGSMIHeapAlloc failed\n"));
     92        }
     93    }
     94
     95    return fRc;
    10596}
    10697
    … …  
    112103                                VBVABUFFER *pVBVA, int32_t cScreen)
    113104{
    114     bool bRc = false;
     105    bool fRc = false;
    115106
    116107    // LogFlowFunc(("pVBVA %p\n", pVBVA));
    … …  
    136127        pCtx->pVBVA      = pVBVA;
    137128
    138         bRc = vboxVBVAInformHost(pCtx, pHGSMICtx, cScreen, true);
    139     }
    140 
    141     if (!bRc)
     129        fRc = vboxVBVAInformHost(pCtx, pHGSMICtx, cScreen, true);
     130    }
     131
     132    if (!fRc)
    142133    {
    143134        VBoxVBVADisable(pCtx, pHGSMICtx, cScreen);
    144135    }
    145136
    146     return bRc;
     137    return fRc;
    147138}
    148139
    … …  
    158149
    159150    vboxVBVAInformHost(pCtx, pHGSMICtx, cScreen, false);
    160 
    161     return;
    162151}
    163152
    … …  
    165154                                           PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx)
    166155{
    167     bool bRc = false;
     156    bool fRc = false;
    168157
    169158    // LogFunc(("flags = 0x%08X\n", pCtx->pVBVA? pCtx->pVBVA->u32HostEvents: -1));
    … …  
    205194            pCtx->pRecord = pRecord;
    206195
    207             bRc = true;
    208         }
    209     }
    210 
    211     return bRc;
     196            fRc = true;
     197        }
     198    }
     199
     200    return fRc;
    212201}
    213202
    … …  
    228217    pCtx->fHwBufferOverflow = false;
    229218    pCtx->pRecord = NULL;
    230 
    231     return;
    232219}
    233220
    … …  
    245232{
    246233    /* Issue the flush command. */
    247     void *p = VBoxHGSMIBufferAlloc(pCtx,
    248                                    sizeof (VBVAFLUSH),
    249                                    HGSMI_CH_VBVA,
    250                                    VBVA_FLUSH);
    251     if (!p)
     234    VBVAFLUSH RT_UNTRUSTED_VOLATILE_HOST *pFlush =
     235        (VBVAFLUSH RT_UNTRUSTED_VOLATILE_HOST * )VBoxHGSMIBufferAlloc(pCtx, sizeof(VBVAFLUSH), HGSMI_CH_VBVA, VBVA_FLUSH);
     236    if (pFlush != NULL)
     237    {
     238        pFlush->u32Reserved = 0;
     239
     240        VBoxHGSMIBufferSubmit(pCtx, pFlush);
     241
     242        VBoxHGSMIBufferFree(pCtx, pFlush);
     243    }
     244    else
    252245    {
    253246        // LogFunc(("HGSMIHeapAlloc failed\n"));
    254247    }
    255     else
    256     {
    257         VBVAFLUSH *pFlush = (VBVAFLUSH *)p;
    258 
    259         pFlush->u32Reserved = 0;
    260 
    261         VBoxHGSMIBufferSubmit(pCtx, p);
    262 
    263         VBoxHGSMIBufferFree(pCtx, p);
    264     }
    265 
    266     return;
    267248}
    268249
    … …  
    286267        memcpy (&pVBVA->au8Data[0], (uint8_t *)p + u32BytesTillBoundary, i32Diff);
    287268    }
    288 
    289     return;
    290269}
    291270

  • trunk/src/VBox/Additions/x11/vboxvideo/HGSMIMemAlloc.h

    r69346 r71590  
    4848
    4949int HGSMIMAInit(HGSMIMADATA *pMA, const HGSMIAREA *pArea,
    50                 HGSMIOFFSET *paDescriptors, uint32_t cDescriptors, HGSMISIZE cbMaxBlock,
    51                 const HGSMIENV *pEnv);
     50                HGSMIOFFSET *paDescriptors, uint32_t cDescriptors,
     51                HGSMISIZE cbMaxBlock, const HGSMIENV *pEnv);
    5252void HGSMIMAUninit(HGSMIMADATA *pMA);
    5353
    54 void *HGSMIMAAlloc(HGSMIMADATA *pMA, HGSMISIZE cb);
    55 void HGSMIMAFree(HGSMIMADATA *pMA, void *pv);
     54void RT_UNTRUSTED_VOLATILE_GUEST *HGSMIMAAlloc(HGSMIMADATA *pMA, HGSMISIZE cb);
     55void HGSMIMAFree(HGSMIMADATA *pMA, void RT_UNTRUSTED_VOLATILE_GUEST *pv);
    5656
    5757RT_C_DECLS_END

  • trunk/src/VBox/Additions/x11/vboxvideo/VBoxVideoIPRT.h

    r69346 r71590  
    9494  } while (0)
    9595# define AssertPtr assert
     96# define AssertPtrReturn(pv, rcRet) do { assert(pv); if (pv) {} else return(rcRet); } while(0)
    9697# define AssertRC(expr) assert (!expr)
    9798#else
    … …  
    99100# define AssertFailed() do { } while(0)
    100101# define AssertMsg(expr, msg) do { } while(0)
    101 # define AssertPtr(expr) do { } while(0)
     102# define AssertPtr(ptr) do { } while(0)
     103# define AssertPtrReturn(pv, rcRet) do { if (pv) {} else return(rcRet); } while(0)
    102104# define AssertRC(expr) do { } while(0)
    103105#endif
    … …  
    136138# define UINT32_C(Value) (Value ## U)
    137139#endif
     140#define RT_UNTRUSTED_GUEST
     141#define RT_UNTRUSTED_VOLATILE_GUEST  volatile
     142#define RT_UNTRUSTED_HOST
     143#define RT_UNTRUSTED_VOLATILE_HOST   volatile
     144#define RT_UNTRUSTED_HSTGST
     145#define RT_UNTRUSTED_VOLATILE_HSTGST volatile
    138146
    139147#define likely _X_LIKELY

  • trunk/src/VBox/Additions/x11/vboxvideo/hgsmimemalloc.c

    r69346 r71590  
    3535 * submit and free pattern, we replace the generic allocator with a simple
    3636 * Boolean.  Need more be said?
     37 *
     38 * bird> Yes, it's buggy. You never set fAllocated. See HGSMIMAAlloc().
    3739 */
    3840
    … …  
    6466}
    6567
    66 static HGSMIOFFSET HGSMIMAPointerToOffset(const HGSMIMADATA *pMA, const void *pv)
     68static HGSMIOFFSET HGSMIMAPointerToOffset(const HGSMIMADATA *pMA, const void RT_UNTRUSTED_VOLATILE_GUEST *pv)
    6769{
    6870    if (HGSMIAreaContainsPointer(&pMA->area, pv))
    69     {
    7071        return HGSMIPointerToOffset(&pMA->area, pv);
    71     }
    7272
    7373    AssertFailed();
    … …  
    7575}
    7676
    77 static void *HGSMIMAOffsetToPointer(const HGSMIMADATA *pMA, HGSMIOFFSET off)
     77static void RT_UNTRUSTED_VOLATILE_GUEST *HGSMIMAOffsetToPointer(const HGSMIMADATA *pMA, HGSMIOFFSET off)
    7878{
    7979    if (HGSMIAreaContainsOffset(&pMA->area, off))
    80     {
    8180        return HGSMIOffsetToPointer(&pMA->area, off);
    82     }
    8381
    8482    AssertFailed();
    … …  
    8684}
    8785
    88 void *HGSMIMAAlloc(HGSMIMADATA *pMA, HGSMISIZE cb)
     86void RT_UNTRUSTED_VOLATILE_GUEST *HGSMIMAAlloc(HGSMIMADATA *pMA, HGSMISIZE cb)
    8987{
    9088    (void)cb;
    … …  
    9391    HGSMIOFFSET off = pMA->area.offBase;
    9492    return HGSMIMAOffsetToPointer(pMA, off);
    95     pMA->fAllocated = true;
     93    pMA->fAllocated = true; /** @todo r=bird: Errr. what's this doing *after* the return statement? */
    9694}
    9795
    98 void HGSMIMAFree(HGSMIMADATA *pMA, void *pv)
     96void HGSMIMAFree(HGSMIMADATA *pMA, void RT_UNTRUSTED_VOLATILE_GUEST *pv)
    9997{
    10098    HGSMIOFFSET off = HGSMIMAPointerToOffset(pMA, pv);
    10199    if (off != HGSMIOFFSET_VOID)
    102     {
    103100        pMA->fAllocated = false;
    104     }
    105101    else
    106     {
    107102        AssertFailed();
    108     }
    109103}
     104
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette