VirtualBox

Changeset 39603 in vbox


Ignore:
Timestamp:
Dec 14, 2011 11:12:56 AM (13 years ago)
Author:
vboxsync
Message:

crHgsmi: cleanup

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideo.h

    r39359 r39603  
    11351135}
    11361136
     1137#define VBoxSHGSMIBufferHeaderSize() (sizeof (VBOXSHGSMIHEADER))
     1138
    11371139DECLINLINE(PVBOXSHGSMIHEADER) VBoxSHGSMIBufferHeader (const void *pvData)
    11381140{
    … …  
    12681270#define VBOXVDMACMD_SIZE(_t) (VBOXVDMACMD_SIZE_FROMBODYSIZE(sizeof (_t)))
    12691271#define VBOXVDMACMD_BODY(_pCmd, _t) ( (_t*)(((uint8_t*)(_pCmd)) + VBOXVDMACMD_HEADER_SIZE()) )
     1272#define VBOXVDMACMD_BODY_SIZE(_s) ( (_s) - VBOXVDMACMD_HEADER_SIZE() )
    12701273#define VBOXVDMACMD_FROM_BODY(_pCmd) ( (VBOXVDMACMD*)(((uint8_t*)(_pCmd)) - VBOXVDMACMD_HEADER_SIZE()) )
    12711274#define VBOXVDMACMD_BODY_FIELD_OFFSET(_ot, _t, _f) ( (_ot)(uintptr_t)( VBOXVDMACMD_BODY(0, uint8_t) + RT_OFFSETOF(_t, _f) ) )
    … …  
    14031406    union
    14041407    {
    1405         void *pvRamBase;
     1408        void *pvVRamBase;
    14061409        uint64_t uAlignment;
    14071410    };
     1411    uint64_t cbVRam;
    14081412} VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP, *PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP;
    14091413

  • trunk/include/VBox/vmm/pdmifs.h

    r38878 r39603  
    715715     * @thread  The emulation thread.
    716716     */
    717     DECLR3CALLBACKMEMBER(void, pfnCrHgsmiCommandProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd));
     717    DECLR3CALLBACKMEMBER(void, pfnCrHgsmiCommandProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd));
    718718
    719719    /**
    … …  
    724724     * @thread  The emulation thread.
    725725     */
    726     DECLR3CALLBACKMEMBER(void, pfnCrHgsmiControlProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl));
     726    DECLR3CALLBACKMEMBER(void, pfnCrHgsmiControlProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl));
    727727
    728728

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r36899 r39603  
    512512int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements);
    513513int vboxVDMADestruct(PVBOXVDMAHOST pVdma);
    514 void vboxVDMAControl(PVBOXVDMAHOST pVdma, PVBOXVDMA_CTL pCmd);
    515 void vboxVDMACommand(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd);
     514void vboxVDMAControl(PVBOXVDMAHOST pVdma, PVBOXVDMA_CTL pCmd, uint32_t cbCmd);
     515void vboxVDMACommand(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd);
    516516int vboxVDMASaveStateExecPrep(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM);
    517517int vboxVDMASaveStateExecDone(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM);

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

    r38514 r39603  
    16571657        case VBVA_VDMA_CMD:
    16581658        {
     1659            if (cbBuffer < VBoxSHGSMIBufferHeaderSize() + sizeof (VBOXVDMACBUF_DR))
     1660            {
     1661                rc = VERR_INVALID_PARAMETER;
     1662                break;
     1663            }
    16591664            PVBOXVDMACBUF_DR pCmd = (PVBOXVDMACBUF_DR)VBoxSHGSMIBufferData ((PVBOXSHGSMIHEADER)pvBuffer);
    1660             vboxVDMACommand(pVGAState->pVdma, pCmd);
     1665            vboxVDMACommand(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
    16611666            rc = VINF_SUCCESS;
    16621667            break;
    … …  
    16641669        case VBVA_VDMA_CTL:
    16651670        {
     1671            if (cbBuffer < VBoxSHGSMIBufferHeaderSize() + sizeof (VBOXVDMA_CTL))
     1672            {
     1673                rc = VERR_INVALID_PARAMETER;
     1674                break;
     1675            }
    16661676            PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMIBufferData ((PVBOXSHGSMIHEADER)pvBuffer);
    1667             vboxVDMAControl(pVGAState->pVdma, pCmd);
     1677            vboxVDMAControl(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
    16681678            rc = VINF_SUCCESS;
    16691679            break;

  • trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

    r37490 r39603  
    157157
    158158
    159 static int vboxVDMACrCtlPostAsync (PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, PFNVBOXVDMACRCTL_CALLBACK pfnCompletion, void *pvCompletion)
     159static int vboxVDMACrCtlPostAsync (PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd, PFNVBOXVDMACRCTL_CALLBACK pfnCompletion, void *pvCompletion)
    160160{
    161161    if (pVGAState->pDrv->pfnCrHgsmiControlProcess)
    … …  
    164164        pHdr->pfnCompletion = pfnCompletion;
    165165        pHdr->pvCompletion = pvCompletion;
    166         pVGAState->pDrv->pfnCrHgsmiControlProcess(pVGAState->pDrv, pCmd);
     166        pVGAState->pDrv->pfnCrHgsmiControlProcess(pVGAState->pDrv, pCmd, cbCmd);
    167167        return VINF_SUCCESS;
    168168    }
    … …  
    173173}
    174174
    175 static int vboxVDMACrCtlPost(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd)
     175static int vboxVDMACrCtlPost(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
    176176{
    177177    RTSEMEVENT hComplEvent;
    … …  
    180180    if(RT_SUCCESS(rc))
    181181    {
    182         rc = vboxVDMACrCtlPostAsync (pVGAState, pCmd, vboxVDMACrCtlCbSetEvent, (void*)hComplEvent);
     182        rc = vboxVDMACrCtlPostAsync (pVGAState, pCmd, cbCmd, vboxVDMACrCtlCbSetEvent, (void*)hComplEvent);
    183183#ifdef DEBUG_misha
    184184        AssertRC(rc);
    … …  
    209209    {
    210210        PVGASTATE pVGAState = pVdma->pVGAState;
    211         pCmd->pvRamBase = pVGAState->vram_ptrR3;
    212         int rc = vboxVDMACrCtlPost(pVGAState, &pCmd->Hdr);
     211        pCmd->pvVRamBase = pVGAState->vram_ptrR3;
     212        pCmd->cbVRam = pVGAState->vram_size;
     213        int rc = vboxVDMACrCtlPost(pVGAState, &pCmd->Hdr, sizeof (*pCmd));
    213214        AssertRC(rc);
    214215        if (RT_SUCCESS(rc))
    … …  
    225226
    226227/* check if this is external cmd to be passed to chromium backend */
    227 static bool vboxVDMACmdCheckCrCmd(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmd)
    228 {
    229     PVBOXVDMACMD pDmaCmd;
     228static int vboxVDMACmdCheckCrCmd(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmdDr, uint32_t cbCmdDr)
     229{
     230    PVBOXVDMACMD pDmaCmd = NULL;
     231    uint32_t cbDmaCmd = 0;
    230232    uint8_t * pvRam = pVdma->pVGAState->vram_ptrR3;
    231     bool bCompleted = false;
    232 
    233     if (pCmd->fFlags & VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR)
    234         pDmaCmd = VBOXVDMACBUF_DR_TAIL(pCmd, VBOXVDMACMD);
    235     else
    236         pDmaCmd = NULL;
     233    int rc = VINF_NOT_SUPPORTED;
     234
     235    if (pCmdDr->fFlags & VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR)
     236    {
     237        if (cbCmdDr < sizeof (*pCmdDr) + VBOXVDMACMD_HEADER_SIZE())
     238        {
     239            AssertMsgFailed(("invalid buffer data!"));
     240            return VERR_INVALID_PARAMETER;
     241        }
     242
     243        cbDmaCmd = pCmdDr->cbBuf;
     244        if (cbDmaCmd < cbCmdDr - sizeof (*pCmdDr) - VBOXVDMACMD_HEADER_SIZE())
     245        {
     246            AssertMsgFailed(("invalid command buffer data!"));
     247            return VERR_INVALID_PARAMETER;
     248        }
     249
     250        pDmaCmd = VBOXVDMACBUF_DR_TAIL(pCmdDr, VBOXVDMACMD);
     251    }
    237252
    238253    if (pDmaCmd)
    239254    {
    240         uint32_t cbCmd = pCmd->cbBuf;
    241         Assert(cbCmd >= VBOXVDMACMD_HEADER_SIZE());
    242 
    243         if (cbCmd >= VBOXVDMACMD_HEADER_SIZE())
    244         {
    245             switch (pDmaCmd->enmType)
    246             {
    247                 case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
     255        Assert(cbDmaCmd >= VBOXVDMACMD_HEADER_SIZE());
     256        uint32_t cbBody = VBOXVDMACMD_BODY_SIZE(cbDmaCmd);
     257
     258        switch (pDmaCmd->enmType)
     259        {
     260            case VBOXVDMACMD_TYPE_CHROMIUM_CMD:
     261            {
     262                PVBOXVDMACMD_CHROMIUM_CMD pCrCmd = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_CHROMIUM_CMD);
     263                if (cbBody < sizeof (*pCrCmd))
    248264                {
    249                     PVBOXVDMACMD_CHROMIUM_CMD pCrCmd = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_CHROMIUM_CMD);
    250                     PVGASTATE pVGAState = pVdma->pVGAState;
    251                     bCompleted = true;
    252                     if (pVGAState->pDrv->pfnCrHgsmiCommandProcess)
    253                     {
    254                         VBoxSHGSMICommandMarkAsynchCompletion(pCmd);
    255                         pVGAState->pDrv->pfnCrHgsmiCommandProcess(pVGAState->pDrv, pCrCmd);
    256                         break;
    257                     }
    258                     else
    259                     {
    260                         Assert(0);
    261                     }
    262 
    263                     int tmpRc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmd);
    264                     AssertRC(tmpRc);
    265 //                uint32_t cBufs = pCrCmd->cBuffers;
    266 //                for (uint32_t i = 0; i < cBufs; ++i)
    267 //                {
    268 //                    PVBOXVDMACMD_CHROMIUM_BUFFER pBuf = &pCrCmd->aBuffers[i];
    269 //                    void *pvBuffer = pvRam + pBuf->offBuffer;
    270 //                    uint32_t cbBuffer = pBuf->cbBuffer;
    271 //                }
     265                    AssertMsgFailed(("invalid chromium command buffer size!"));
     266                    return VERR_INVALID_PARAMETER;
     267                }
     268                PVGASTATE pVGAState = pVdma->pVGAState;
     269                rc = VINF_SUCCESS;
     270                if (pVGAState->pDrv->pfnCrHgsmiCommandProcess)
     271                {
     272                    VBoxSHGSMICommandMarkAsynchCompletion(pCmdDr);
     273                    pVGAState->pDrv->pfnCrHgsmiCommandProcess(pVGAState->pDrv, pCrCmd, cbBody);
    272274                    break;
    273275                }
    274                 case VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER:
     276                else
    275277                {
    276                     PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_DMA_BPB_TRANSFER);
    277                     int rc = vboxVDMACmdExecBpbTransfer(pVdma, pTransfer, sizeof (*pTransfer));
     278                    Assert(0);
     279                }
     280
     281                int tmpRc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmdDr);
     282                AssertRC(tmpRc);
     283                break;
     284            }
     285            case VBOXVDMACMD_TYPE_DMA_BPB_TRANSFER:
     286            {
     287                PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer = VBOXVDMACMD_BODY(pDmaCmd, VBOXVDMACMD_DMA_BPB_TRANSFER);
     288                if (cbBody < sizeof (*pTransfer))
     289                {
     290                    AssertMsgFailed(("invalid bpb transfer buffer size!"));
     291                    return VERR_INVALID_PARAMETER;
     292                }
     293
     294                rc = vboxVDMACmdExecBpbTransfer(pVdma, pTransfer, sizeof (*pTransfer));
     295                AssertRC(rc);
     296                if (RT_SUCCESS(rc))
     297                {
     298                    pCmdDr->rc = VINF_SUCCESS;
     299                    rc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmdDr);
    278300                    AssertRC(rc);
    279                     if (RT_SUCCESS(rc))
    280                     {
    281                         pCmd->rc = VINF_SUCCESS;
    282                         rc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmd);
    283                         AssertRC(rc);
    284                         bCompleted = true;
    285                     }
    286                     break;
     301                    rc = VINF_SUCCESS;
    287302                }
    288                 default:
    289                     break;
    290             }
    291         }
    292     }
    293     return bCompleted;
     303                break;
     304            }
     305            default:
     306                break;
     307        }
     308    }
     309    return rc;
    294310}
    295311
    … …  
    920936#endif
    921937
    922 static void vboxVDMACommandProcess(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd)
     938static void vboxVDMACommandProcess(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd)
    923939{
    924940    PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi;
    … …  
    11711187    if (pCmd)
    11721188    {
    1173         int rc = vboxVDMACrCtlPost(pVGAState, pCmd);
     1189        int rc = vboxVDMACrCtlPost(pVGAState, pCmd, sizeof (*pCmd));
    11741190        AssertRC(rc);
    11751191        if (RT_SUCCESS(rc))
    … …  
    11951211    if (pCmd)
    11961212    {
    1197         int rc = vboxVDMACrCtlPost(pVGAState, pCmd);
     1213        int rc = vboxVDMACrCtlPost(pVGAState, pCmd, sizeof (*pCmd));
    11981214        AssertRC(rc);
    11991215        if (RT_SUCCESS(rc))
    … …  
    12111227
    12121228
    1213 void vboxVDMAControl(struct VBOXVDMAHOST *pVdma, PVBOXVDMA_CTL pCmd)
     1229void vboxVDMAControl(struct VBOXVDMAHOST *pVdma, PVBOXVDMA_CTL pCmd, uint32_t cbCmd)
    12141230{
    12151231#if 1
    … …  
    12641280}
    12651281
    1266 void vboxVDMACommand(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmd)
    1267 {
     1282void vboxVDMACommand(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd)
     1283{
     1284    int rc = VERR_NOT_IMPLEMENTED;
     1285
    12681286#ifdef VBOX_WITH_CRHGSMI
    12691287    /* chromium commands are processed by crhomium hgcm thread independently from our internal cmd processing pipeline
    12701288     * this is why we process them specially */
    1271     if (vboxVDMACmdCheckCrCmd(pVdma, pCmd))
     1289    rc = vboxVDMACmdCheckCrCmd(pVdma, pCmd, cbCmd);
     1290    if (rc == VINF_SUCCESS)
    12721291        return;
     1292
     1293    if (RT_FAILURE(rc))
     1294    {
     1295        pCmd->rc = rc;
     1296        rc = VBoxSHGSMICommandComplete (pVdma->pHgsmi, pCmd);
     1297        AssertRC(rc);
     1298        return;
     1299    }
    12731300#endif
    12741301
    12751302#ifndef VBOX_VDMA_WITH_WORKERTHREAD
    1276     vboxVDMACommandProcess(pVdma, pCmd);
     1303    vboxVDMACommandProcess(pVdma, pCmd, cbCmd);
    12771304#else
    1278     int rc = VERR_NOT_IMPLEMENTED;
    12791305
    12801306# ifdef DEBUG_misha

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h

    r39288 r39603  
    315315 * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
    316316 * */
    317 extern DECLEXPORT(int32_t) crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd);
    318 extern DECLEXPORT(int32_t) crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl);
     317extern DECLEXPORT(int32_t) crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, uint32_t cbCmd);
     318extern DECLEXPORT(int32_t) crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl, uint32_t cbCtl);
    319319#endif
    320320

  • trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

    r39507 r39603  
    939939            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    940940            {
    941                 rc = crVBoxServerCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr);
     941                rc = crVBoxServerCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr, paParms[0].u.pointer.size);
    942942                if (VERR_NOT_SUPPORTED == rc)
    943943                {
    … …  
    952952            Assert(cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR);
    953953            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    954                 rc = crVBoxServerCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr);
     954                rc = crVBoxServerCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr, paParms[0].u.pointer.size);
    955955            else
    956956                rc = VERR_INVALID_PARAMETER;

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r39288 r39603  
    2020
    2121extern uint8_t* g_pvVRamBase;
     22extern uint32_t g_cbVRam;
    2223extern HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion;
    2324extern PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion;
    2425
    2526#define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
     27#define VBOXCRHGSMI_PTR_SAFE(_off, _cb, _t) ((_t*)crServerCrHgsmiPtrGet(_off, _cb))
     28
     29DECLINLINE(void*) crServerCrHgsmiPtrGet(VBOXVIDEOOFFSET offBuffer, uint32_t cbBuffer)
     30{
     31    return ((offBuffer) + (cbBuffer) <= g_cbVRam ? VBOXCRHGSMI_PTR(offBuffer, void) : NULL);
     32}
    2633
    2734DECLINLINE(void) crServerCrHgsmiCmdComplete(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, int cmdProcessingRc)

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

    r39288 r39603  
    3333# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
    3434uint8_t* g_pvVRamBase = NULL;
     35uint32_t g_cbVRam = 0;
    3536HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion = NULL;
    3637PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion = NULL;
    … …  
    13531354 * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
    13541355 * */
    1355 int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd)
     1356int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, uint32_t cbCmd)
    13561357{
    13571358    int32_t rc;
    13581359    uint32_t cBuffers = pCmd->cBuffers;
    13591360    uint32_t cParams;
     1361    uint32_t cbHdr;
    13601362    CRVBOXHGSMIHDR *pHdr;
    13611363    uint32_t u32Function;
    … …  
    13651367    if (!g_pvVRamBase)
    13661368    {
    1367         CRASSERT(0);
     1369        crWarning("g_pvVRamBase is not initialized");
    13681370        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_STATE);
    13691371        return VINF_SUCCESS;
    … …  
    13721374    if (!cBuffers)
    13731375    {
    1374         CRASSERT(0);
     1376        crWarning("zero buffers passed in!");
    13751377        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
    13761378        return VINF_SUCCESS;
    … …  
    13791381    cParams = cBuffers-1;
    13801382
    1381     pHdr = VBOXCRHGSMI_PTR(pCmd->aBuffers[0].offBuffer, CRVBOXHGSMIHDR);
     1383    cbHdr = pCmd->aBuffers[0].cbBuffer;
     1384    pHdr = VBOXCRHGSMI_PTR_SAFE(pCmd->aBuffers[0].offBuffer, cbHdr, CRVBOXHGSMIHDR);
     1385    if (!pHdr)
     1386    {
     1387        crWarning("invalid header buffer!");
     1388        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     1389        return VINF_SUCCESS;
     1390    }
     1391
     1392    if (cbHdr < sizeof (*pHdr))
     1393    {
     1394        crWarning("invalid header buffer size!");
     1395        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     1396        return VINF_SUCCESS;
     1397    }
     1398
    13821399    u32Function = pHdr->u32Function;
    13831400    u32ClientID = pHdr->u32ClientID;
    … …  
    13951412                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    13961413                /* Fetch parameters. */
    1397                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    13981414                uint32_t cbBuffer = pBuf->cbBuffer;
    1399 
    1400                 CRASSERT(pBuffer);
     1415                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1416
     1417                if (cbHdr < sizeof (*pFnCmd))
     1418                {
     1419                    crWarning("invalid write cmd buffer size!");
     1420                    rc = VERR_INVALID_PARAMETER;
     1421                    break;
     1422                }
     1423
    14011424                CRASSERT(cbBuffer);
     1425                if (!pBuffer)
     1426                {
     1427                    crWarning("invalid buffer data received from guest!");
     1428                    rc = VERR_INVALID_PARAMETER;
     1429                    break;
     1430                }
    14021431
    14031432                rc = crVBoxServerClientGet(u32ClientID, &pClient);
    … …  
    14381467                uint32_t u32InjectClientID = pFnCmd->u32ClientID;
    14391468                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    1440                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    14411469                uint32_t cbBuffer = pBuf->cbBuffer;
    1442 
    1443                 CRASSERT(pBuffer);
     1470                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1471
     1472                if (cbHdr < sizeof (*pFnCmd))
     1473                {
     1474                    crWarning("invalid inject cmd buffer size!");
     1475                    rc = VERR_INVALID_PARAMETER;
     1476                    break;
     1477                }
     1478
    14441479                CRASSERT(cbBuffer);
     1480                if (!pBuffer)
     1481                {
     1482                    crWarning("invalid buffer data received from guest!");
     1483                    rc = VERR_INVALID_PARAMETER;
     1484                    break;
     1485                }
    14451486
    14461487                rc = crVBoxServerClientGet(u32InjectClientID, &pClient);
    … …  
    14771518                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    14781519                /* Fetch parameters. */
    1479                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    14801520                uint32_t cbBuffer = pBuf->cbBuffer;
     1521                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1522
     1523                if (cbHdr < sizeof (*pFnCmd))
     1524                {
     1525                    crWarning("invalid read cmd buffer size!");
     1526                    rc = VERR_INVALID_PARAMETER;
     1527                    break;
     1528                }
     1529
     1530
     1531                if (!pBuffer)
     1532                {
     1533                    crWarning("invalid buffer data received from guest!");
     1534                    rc = VERR_INVALID_PARAMETER;
     1535                    break;
     1536                }
    14811537
    14821538                rc = crVBoxServerClientGet(u32ClientID, &pClient);
    … …  
    15181574
    15191575                /* Fetch parameters. */
    1520                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    15211576                uint32_t cbBuffer = pBuf->cbBuffer;
    1522 
    1523                 uint8_t *pWriteback  = VBOXCRHGSMI_PTR(pWbBuf->offBuffer, uint8_t);
     1577                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1578
    15241579                uint32_t cbWriteback = pWbBuf->cbBuffer;
    1525 
    1526                 CRASSERT(pBuffer);
     1580                uint8_t *pWriteback  = VBOXCRHGSMI_PTR_SAFE(pWbBuf->offBuffer, cbWriteback, uint8_t);
     1581
     1582                if (cbHdr < sizeof (*pFnCmd))
     1583                {
     1584                    crWarning("invalid write_read cmd buffer size!");
     1585                    rc = VERR_INVALID_PARAMETER;
     1586                    break;
     1587                }
     1588
     1589
    15271590                CRASSERT(cbBuffer);
    1528 
     1591                if (!pBuffer)
     1592                {
     1593                    crWarning("invalid write buffer data received from guest!");
     1594                    rc = VERR_INVALID_PARAMETER;
     1595                    break;
     1596                }
     1597
     1598                CRASSERT(cbWriteback);
     1599                if (!pWriteback)
     1600                {
     1601                    crWarning("invalid writeback buffer data received from guest!");
     1602                    rc = VERR_INVALID_PARAMETER;
     1603                    break;
     1604                }
    15291605                rc = crVBoxServerClientGet(u32ClientID, &pClient);
    15301606                if (RT_FAILURE(rc))
    … …  
    15821658}
    15831659
    1584 int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl)
     1660int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl, uint32_t cbCtl)
    15851661{
    15861662    int rc = VINF_SUCCESS;
    … …  
    15911667        {
    15921668            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP)pCtl;
    1593             g_pvVRamBase = (uint8_t*)pSetup->pvRamBase;
     1669            g_pvVRamBase = (uint8_t*)pSetup->pvVRamBase;
     1670            g_cbVRam = pSetup->cbVRam;
    15941671            rc = VINF_SUCCESS;
    15951672            break;

  • trunk/src/VBox/Main/include/DisplayImpl.h

    r35638 r39603  
    131131#endif
    132132#ifdef VBOX_WITH_CRHGSMI
    133     void handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd);
    134     void handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl);
     133    void handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
     134    void handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
    135135
    136136    void handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
    … …  
    202202
    203203#ifdef VBOX_WITH_CRHGSMI
    204     static DECLCALLBACK(void)  displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd);
    205     static DECLCALLBACK(void)  displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl);
     204    static DECLCALLBACK(void)  displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
     205    static DECLCALLBACK(void)  displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
    206206
    207207    static DECLCALLBACK(void) displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r39391 r39603  
    34973497}
    34983498
    3499 void Display::handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd)
     3499void Display::handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
    35003500{
    35013501    int rc = VERR_INVALID_FUNCTION;
    … …  
    35033503    parm.type = VBOX_HGCM_SVC_PARM_PTR;
    35043504    parm.u.pointer.addr = pCmd;
    3505     parm.u.pointer.size = 0;
     3505    parm.u.pointer.size = cbCmd;
    35063506
    35073507    if (mhCrOglSvc)
    … …  
    35253525}
    35263526
    3527 void Display::handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl)
     3527void Display::handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
    35283528{
    35293529    int rc = VERR_INVALID_FUNCTION;
    … …  
    35313531    parm.type = VBOX_HGCM_SVC_PARM_PTR;
    35323532    parm.u.pointer.addr = pCtl;
    3533     parm.u.pointer.size = 0;
     3533    parm.u.pointer.size = cbCtl;
    35343534
    35353535    if (mhCrOglSvc)
    … …  
    35523552
    35533553
    3554 DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd)
     3554DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
    35553555{
    35563556    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    35573557
    3558     pDrv->pDisplay->handleCrHgsmiCommandProcess(pInterface, pCmd);
    3559 }
    3560 
    3561 DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd)
     3558    pDrv->pDisplay->handleCrHgsmiCommandProcess(pInterface, pCmd, cbCmd);
     3559}
     3560
     3561DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
    35623562{
    35633563    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    35643564
    3565     pDrv->pDisplay->handleCrHgsmiControlProcess(pInterface, pCmd);
     3565    pDrv->pDisplay->handleCrHgsmiControlProcess(pInterface, pCmd, cbCmd);
    35663566}
    35673567
Note: See TracChangeset for help on using the changeset viewer.

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