VirtualBox

Changeset 5040 in vbox for trunk/src/VBox/Devices/VMMDev


Ignore:
Timestamp:
Sep 26, 2007 9:03:00 AM (17 years ago)
Author:
vboxsync
Message:

GC phys/virt to HC virt functions are no longer accessible in our PDM interface.
Rewrote disassembly functions to use the mapping functions.

Code that runs in EMT (like CSAM/PATM) can still use the old conversion functions. Easier to use
and (far) less overhead.

Location:
trunk/src/VBox/Devices/VMMDev
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/VMMDev/VBoxDev.cpp

    r4915 r5040  
    3535#include <iprt/assert.h>
    3636#include <iprt/time.h>
     37#ifndef IN_GC
     38#include <iprt/mem.h>
     39#endif
    3740
    3841#include "VMMDevState.h"
    … …  
    408411    VMMDevState *pData = (VMMDevState*)pvUser;
    409412    int rcRet = VINF_SUCCESS;
    410     int rc;
    411413
    412414    /*
    413415     * The caller has passed the guest context physical address
    414      * of the request structure. Get the corresponding host virtual
    415      * address.
     416     * of the request structure. Copy the request packet.
    416417     */
    417     VMMDevRequestHeader *requestHeader = NULL;
    418     rc = PDMDevHlpPhys2HCVirt(pDevIns, (RTGCPHYS)u32, 0, (PRTHCPTR)&requestHeader);
    419     if (VBOX_FAILURE(rc) || !requestHeader)
    420     {
    421         AssertMsgFailed(("VMMDev could not convert guest physical address to host virtual! rc = %Vrc\n", rc));
    422         return VINF_SUCCESS;
    423     }
     418    VMMDevRequestHeader requestHeader = {0};
     419    VMMDevRequestHeader *pRequestHeader = NULL;
     420
     421    PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
    424422
    425423    /* the structure size must be greater or equal to the header size */
    426     if (requestHeader->size < sizeof(VMMDevRequestHeader))
    427     {
    428         Log(("VMMDev request header size too small! size = %d\n", requestHeader->size));
    429         return VINF_SUCCESS;
     424    if (requestHeader.size < sizeof(VMMDevRequestHeader))
     425    {
     426        Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
     427        rcRet = VINF_SUCCESS;
     428        goto end;
    430429    }
    431430
    432431    /* check the version of the header structure */
    433     if (requestHeader->version != VMMDEV_REQUEST_HEADER_VERSION)
    434     {
    435         Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader->version, VMMDEV_REQUEST_HEADER_VERSION));
    436         return VINF_SUCCESS;
    437     }
    438 
    439     Log2(("VMMDev request issued: %d\n", requestHeader->requestType));
    440 
    441     if (requestHeader->requestType != VMMDevReq_ReportGuestInfo
     432    if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
     433    {
     434        Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
     435        rcRet = VINF_SUCCESS;
     436        goto end;
     437    }
     438
     439    Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
     440
     441    if (    requestHeader.requestType != VMMDevReq_ReportGuestInfo
    442442        && !pData->fu32AdditionsOk)
    443443    {
    444444        Log(("VMMDev: guest has not yet reported to us. Refusing operation.\n"));
    445         requestHeader->rc = VERR_NOT_SUPPORTED;
    446         return VINF_SUCCESS;
    447     }
     445        requestHeader.rc = VERR_NOT_SUPPORTED;
     446        rcRet = VINF_SUCCESS;
     447        goto end;
     448    }
     449
     450    /* Check upper limit */
     451    if (requestHeader.size > VMMDEV_MAX_VMMDEVREQ_SIZE)
     452    {
     453        LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
     454        requestHeader.rc = VERR_NOT_SUPPORTED;
     455        rcRet = VINF_SUCCESS;
     456        goto end;
     457    }
     458
     459    /* Read the entire request packet */
     460    pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
     461    if (!pRequestHeader)
     462    {
     463        Log(("VMMDev: RTMemAlloc failed!\n"));
     464        rcRet = VINF_SUCCESS;
     465        requestHeader.rc = VERR_NO_MEMORY;
     466        goto end;
     467    }
     468    PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
    448469
    449470    /* which request was sent? */
    450     switch (requestHeader->requestType)
     471    switch (pRequestHeader->requestType)
    451472    {
    452473        /*
    … …  
    456477        {
    457478            /* just return to EMT telling it that we want to halt */
    458             return VINF_EM_HALT;
     479            rcRet = VINF_EM_HALT;
    459480            break;
    460481        }
    … …  
    465486        case VMMDevReq_ReportGuestInfo:
    466487        {
    467             if (requestHeader->size < sizeof(VMMDevReportGuestInfo))
     488            if (pRequestHeader->size < sizeof(VMMDevReportGuestInfo))
    468489            {
    469490                AssertMsgFailed(("VMMDev guest information structure has invalid size!\n"));
    470                 requestHeader->rc = VERR_INVALID_PARAMETER;
    471             }
    472             else
    473             {
    474                 VMMDevReportGuestInfo *guestInfo = (VMMDevReportGuestInfo*)requestHeader;
     491                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     492            }
     493            else
     494            {
     495                VMMDevReportGuestInfo *guestInfo = (VMMDevReportGuestInfo*)pRequestHeader;
    475496
    476497                if (memcmp (&pData->guestInfo, &guestInfo->guestInfo, sizeof (guestInfo->guestInfo)) != 0)
    … …  
    490511                if (pData->fu32AdditionsOk)
    491512                {
    492                     requestHeader->rc = VINF_SUCCESS;
     513                    pRequestHeader->rc = VINF_SUCCESS;
    493514                }
    494515                else
    495516                {
    496                     requestHeader->rc = VERR_VERSION_MISMATCH;
     517                    pRequestHeader->rc = VERR_VERSION_MISMATCH;
    497518                }
    498519            }
    … …  
    503524        case VMMDevReq_ReportGuestCapabilities:
    504525        {
    505             if (requestHeader->size != sizeof(VMMDevReqGuestCapabilities))
     526            if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities))
    506527            {
    507528                AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
    508                 requestHeader->rc = VERR_INVALID_PARAMETER;
    509             }
    510             else
    511             {
    512                 VMMDevReqGuestCapabilities *guestCaps = (VMMDevReqGuestCapabilities*)requestHeader;
     529                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     530            }
     531            else
     532            {
     533                VMMDevReqGuestCapabilities *guestCaps = (VMMDevReqGuestCapabilities*)pRequestHeader;
    513534
    514535                if (pData->guestCaps != guestCaps->caps)
    … …  
    526547                    pData->pDrv->pfnUpdateGuestCapabilities(pData->pDrv, guestCaps->caps);
    527548                }
    528                 requestHeader->rc = VINF_SUCCESS;
     549                pRequestHeader->rc = VINF_SUCCESS;
    529550            }
    530551            break;
    … …  
    536557        case VMMDevReq_GetMouseStatus:
    537558        {
    538             if (requestHeader->size != sizeof(VMMDevReqMouseStatus))
     559            if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
    539560            {
    540561                AssertMsgFailed(("VMMDev mouse status structure has invalid size!\n"));
    541                 requestHeader->rc = VERR_INVALID_PARAMETER;
    542             }
    543             else
    544             {
    545                 VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)requestHeader;
     562                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     563            }
     564            else
     565            {
     566                VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)pRequestHeader;
    546567                mouseStatus->mouseFeatures = 0;
    547568                if (pData->mouseCapabilities & VMMDEV_MOUSEHOSTWANTSABS)
    … …  
    561582                Log2(("returning mouse status: features = %d, absX = %d, absY = %d\n", mouseStatus->mouseFeatures,
    562583                      mouseStatus->pointerXPos, mouseStatus->pointerYPos));
    563                 requestHeader->rc = VINF_SUCCESS;
     584                pRequestHeader->rc = VINF_SUCCESS;
    564585            }
    565586            break;
    … …  
    571592        case VMMDevReq_SetMouseStatus:
    572593        {
    573             if (requestHeader->size != sizeof(VMMDevReqMouseStatus))
     594            if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
    574595            {
    575596                AssertMsgFailed(("VMMDev mouse status structure has invalid size %d (%#x) version=%d!\n",
    576                                  requestHeader->size, requestHeader->size, requestHeader->size, requestHeader->version));
    577                 requestHeader->rc = VERR_INVALID_PARAMETER;
     597                                 pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
     598                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    578599            }
    579600            else
    … …  
    581602                bool bCapsChanged = false;
    582603
    583                 VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)requestHeader;
     604                VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)pRequestHeader;
    584605
    585606                /* check if the guest wants absolute coordinates */
    … …  
    615636                    pData->pDrv->pfnUpdateMouseCapabilities(pData->pDrv, pData->mouseCapabilities);
    616637                }
    617                 requestHeader->rc = VINF_SUCCESS;
     638                pRequestHeader->rc = VINF_SUCCESS;
    618639            }
    619640
    … …  
    626647        case VMMDevReq_SetPointerShape:
    627648        {
    628             if (requestHeader->size < sizeof(VMMDevReqMousePointer))
    629             {
    630                 AssertMsg(requestHeader->size == 0x10028 && requestHeader->version == 10000,  /* don't bitch about legacy!!! */
     649            if (pRequestHeader->size < sizeof(VMMDevReqMousePointer))
     650            {
     651                AssertMsg(pRequestHeader->size == 0x10028 && pRequestHeader->version == 10000,  /* don't bitch about legacy!!! */
    631652                          ("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
    632                            requestHeader->size, requestHeader->size, requestHeader->size, requestHeader->version));
    633                 requestHeader->rc = VERR_INVALID_PARAMETER;
    634             }
    635             else
    636             {
    637                 VMMDevReqMousePointer *pointerShape = (VMMDevReqMousePointer*)requestHeader;
     653                           pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
     654                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     655            }
     656            else
     657            {
     658                VMMDevReqMousePointer *pointerShape = (VMMDevReqMousePointer*)pRequestHeader;
    638659
    639660                bool fVisible = (pointerShape->fFlags & VBOX_MOUSE_POINTER_VISIBLE) != 0;
    … …  
    663684                                                       NULL);
    664685                }
    665                 requestHeader->rc = VINF_SUCCESS;
     686                pRequestHeader->rc = VINF_SUCCESS;
    666687            }
    667688            break;
    … …  
    673694        case VMMDevReq_GetHostTime:
    674695        {
    675             if (requestHeader->size != sizeof(VMMDevReqHostTime))
     696            if (pRequestHeader->size != sizeof(VMMDevReqHostTime))
    676697            {
    677698                AssertMsgFailed(("VMMDev host time structure has invalid size!\n"));
    678                 requestHeader->rc = VERR_INVALID_PARAMETER;
     699                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    679700            }
    680701            else if (RT_UNLIKELY(pData->fGetHostTimeDisabled))
    681                 requestHeader->rc = VERR_NOT_SUPPORTED;
    682             else
    683             {
    684                 VMMDevReqHostTime *hostTimeReq = (VMMDevReqHostTime*)requestHeader;
     702                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     703            else
     704            {
     705                VMMDevReqHostTime *hostTimeReq = (VMMDevReqHostTime*)pRequestHeader;
    685706                RTTIMESPEC now;
    686707                hostTimeReq->time = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
    687                 requestHeader->rc = VINF_SUCCESS;
     708                pRequestHeader->rc = VINF_SUCCESS;
    688709            }
    689710            break;
    … …  
    695716        case VMMDevReq_GetHypervisorInfo:
    696717        {
    697             if (requestHeader->size != sizeof(VMMDevReqHypervisorInfo))
     718            if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
    698719            {
    699720                AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
    700                 requestHeader->rc = VERR_INVALID_PARAMETER;
    701             }
    702             else
    703             {
    704                 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)requestHeader;
     721                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     722            }
     723            else
     724            {
     725                VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
    705726                PVM pVM = PDMDevHlpGetVM(pDevIns);
    706727                size_t hypervisorSize = 0;
    707                 requestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorSize);
     728                pRequestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorSize);
    708729                hypervisorInfo->hypervisorSize = (uint32_t)hypervisorSize;
    709730                Assert(hypervisorInfo->hypervisorSize == hypervisorSize);
    … …  
    717738        case VMMDevReq_SetHypervisorInfo:
    718739        {
    719             if (requestHeader->size != sizeof(VMMDevReqHypervisorInfo))
     740            if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
    720741            {
    721742                AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
    722                 requestHeader->rc = VERR_INVALID_PARAMETER;
    723             }
    724             else
    725             {
    726                 VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)requestHeader;
     743                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     744            }
     745            else
     746            {
     747                VMMDevReqHypervisorInfo *hypervisorInfo = (VMMDevReqHypervisorInfo*)pRequestHeader;
    727748                PVM pVM = PDMDevHlpGetVM(pDevIns);
    728749                if (hypervisorInfo->hypervisorStart == 0)
    729750                {
    730                     requestHeader->rc = PGMR3MappingsUnfix(pVM);
     751                    pRequestHeader->rc = PGMR3MappingsUnfix(pVM);
    731752                } else
    732753                {
    733754                    /* only if the client has queried the size before! */
    734755                    size_t mappingsSize;
    735                     requestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
    736                     if (VBOX_SUCCESS(requestHeader->rc) && (hypervisorInfo->hypervisorSize == mappingsSize))
     756                    pRequestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
     757                    if (VBOX_SUCCESS(pRequestHeader->rc) && (hypervisorInfo->hypervisorSize == mappingsSize))
    737758                    {
    738759                        /* new reservation */
    739                         requestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
     760                        pRequestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
    740761                                                             hypervisorInfo->hypervisorSize);
    741762                        LogRel(("Guest reported fixed hypervisor window at 0x%p (size = 0x%x, rc = %Vrc)\n",
    742763                                hypervisorInfo->hypervisorStart,
    743764                                hypervisorInfo->hypervisorSize,
    744                                 requestHeader->rc));
     765                                pRequestHeader->rc));
    745766                    }
    746767                }
    … …  
    754775        case VMMDevReq_SetPowerStatus:
    755776        {
    756             if (requestHeader->size != sizeof(VMMDevPowerStateRequest))
     777            if (pRequestHeader->size != sizeof(VMMDevPowerStateRequest))
    757778            {
    758779                AssertMsgFailed(("VMMDev power state request structure has invalid size!\n"));
    759                 requestHeader->rc = VERR_INVALID_PARAMETER;
    760             }
    761             else
    762             {
    763                 VMMDevPowerStateRequest *powerStateRequest = (VMMDevPowerStateRequest*)requestHeader;
     780                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     781            }
     782            else
     783            {
     784                VMMDevPowerStateRequest *powerStateRequest = (VMMDevPowerStateRequest*)pRequestHeader;
    764785                switch(powerStateRequest->powerState)
    765786                {
    … …  
    767788                    {
    768789                        LogRel(("Guest requests the VM to be suspended (paused)\n"));
    769                         requestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
     790                        pRequestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
    770791                        break;
    771792                    }
    … …  
    774795                    {
    775796                        LogRel(("Guest requests the VM to be turned off\n"));
    776                         requestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
     797                        pRequestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
    777798                        break;
    778799                    }
    … …  
    781802                    {
    782803                        /** @todo no API for that yet */
    783                         requestHeader->rc = VERR_NOT_IMPLEMENTED;
     804                        pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
    784805                        break;
    785806                    }
    … …  
    787808                    default:
    788809                        AssertMsgFailed(("VMMDev invalid power state request: %d\n", powerStateRequest->powerState));
    789                         requestHeader->rc = VERR_INVALID_PARAMETER;
     810                        pRequestHeader->rc = VERR_INVALID_PARAMETER;
    790811                        break;
    791812                }
    … …  
    799820        case VMMDevReq_GetDisplayChangeRequest:
    800821        {
    801             if (requestHeader->size != sizeof(VMMDevDisplayChangeRequest))
     822            if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest))
    802823            {
    803824                /* Assert only if the size also not equal to a previous version size to prevent
    804825                 * assertion with old additions.
    805826                 */
    806                 AssertMsg(requestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
     827                AssertMsg(pRequestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
    807828                          ("VMMDev display change request structure has invalid size!\n"));
    808                 requestHeader->rc = VERR_INVALID_PARAMETER;
    809             }
    810             else
    811             {
    812                 VMMDevDisplayChangeRequest *displayChangeRequest = (VMMDevDisplayChangeRequest*)requestHeader;
     829                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     830            }
     831            else
     832            {
     833                VMMDevDisplayChangeRequest *displayChangeRequest = (VMMDevDisplayChangeRequest*)pRequestHeader;
    813834                /* just pass on the information */
    814835                Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
    … …  
    824845                }
    825846
    826                 requestHeader->rc = VINF_SUCCESS;
     847                pRequestHeader->rc = VINF_SUCCESS;
    827848            }
    828849            break;
    … …  
    831852        case VMMDevReq_GetDisplayChangeRequest2:
    832853        {
    833             if (requestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
    834             {
    835                 requestHeader->rc = VERR_INVALID_PARAMETER;
    836             }
    837             else
    838             {
    839                 VMMDevDisplayChangeRequest2 *displayChangeRequest = (VMMDevDisplayChangeRequest2*)requestHeader;
     854            if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
     855            {
     856                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     857            }
     858            else
     859            {
     860                VMMDevDisplayChangeRequest2 *displayChangeRequest = (VMMDevDisplayChangeRequest2*)pRequestHeader;
    840861                /* just pass on the information */
    841862                Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
    … …  
    852873                }
    853874
    854                 requestHeader->rc = VINF_SUCCESS;
     875                pRequestHeader->rc = VINF_SUCCESS;
    855876            }
    856877            break;
    … …  
    862883        case VMMDevReq_VideoModeSupported:
    863884        {
    864             if (requestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
     885            if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
    865886            {
    866887                AssertMsgFailed(("VMMDev video mode supported request structure has invalid size!\n"));
    867                 requestHeader->rc = VERR_INVALID_PARAMETER;
    868             }
    869             else
    870             {
    871                 VMMDevVideoModeSupportedRequest *videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest*)requestHeader;
     888                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     889            }
     890            else
     891            {
     892                VMMDevVideoModeSupportedRequest *videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest*)pRequestHeader;
    872893                /* forward the call */
    873                 requestHeader->rc = pData->pDrv->pfnVideoModeSupported(pData->pDrv,
     894                pRequestHeader->rc = pData->pDrv->pfnVideoModeSupported(pData->pDrv,
    874895                                                                       videoModeSupportedRequest->width,
    875896                                                                       videoModeSupportedRequest->height,
    … …  
    885906        case VMMDevReq_GetHeightReduction:
    886907        {
    887             if (requestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
     908            if (pRequestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
    888909            {
    889910                AssertMsgFailed(("VMMDev height reduction request structure has invalid size!\n"));
    890                 requestHeader->rc = VERR_INVALID_PARAMETER;
    891             }
    892             else
    893             {
    894                 VMMDevGetHeightReductionRequest *heightReductionRequest = (VMMDevGetHeightReductionRequest*)requestHeader;
     911                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     912            }
     913            else
     914            {
     915                VMMDevGetHeightReductionRequest *heightReductionRequest = (VMMDevGetHeightReductionRequest*)pRequestHeader;
    895916                /* forward the call */
    896                 requestHeader->rc = pData->pDrv->pfnGetHeightReduction(pData->pDrv,
     917                pRequestHeader->rc = pData->pDrv->pfnGetHeightReduction(pData->pDrv,
    897918                                                                       &heightReductionRequest->heightReduction);
    898919            }
    … …  
    905926        case VMMDevReq_AcknowledgeEvents:
    906927        {
    907             if (requestHeader->size != sizeof(VMMDevEvents))
     928            if (pRequestHeader->size != sizeof(VMMDevEvents))
    908929            {
    909930                AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
    910                 requestHeader->rc = VERR_INVALID_PARAMETER;
     931                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    911932            }
    912933            else
    … …  
    926947                    }
    927948
    928                     pAckRequest = (VMMDevEvents *) requestHeader;
     949                    pAckRequest = (VMMDevEvents *)pRequestHeader;
    929950                    pAckRequest->events =
    930951                        pData->u32HostEventFlags & pData->u32GuestFilterMask;
    … …  
    934955                    PDMDevHlpPCISetIrqNoWait (pData->pDevIns, 0, 0);
    935956                }
    936                 requestHeader->rc = VINF_SUCCESS;
     957                pRequestHeader->rc = VINF_SUCCESS;
    937958            }
    938959            break;
    … …  
    944965        case VMMDevReq_CtlGuestFilterMask:
    945966        {
    946             if (requestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
     967            if (pRequestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
    947968            {
    948969                AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
    949                 requestHeader->rc = VERR_INVALID_PARAMETER;
     970                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    950971            }
    951972            else
    … …  
    953974                VMMDevCtlGuestFilterMask *pCtlMaskRequest;
    954975
    955                 pCtlMaskRequest = (VMMDevCtlGuestFilterMask *) requestHeader;
     976                pCtlMaskRequest = (VMMDevCtlGuestFilterMask *)pRequestHeader;
    956977                /* The HGCM events are enabled by the VMMDev device automatically when any
    957978                 * HGCM command is issued. The guest then can not disable these events.
    … …  
    960981                                              pCtlMaskRequest->u32OrMask,
    961982                                              pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
    962                 requestHeader->rc = VINF_SUCCESS;
     983                pRequestHeader->rc = VINF_SUCCESS;
    963984
    964985            }
    … …  
    972993        case VMMDevReq_HGCMConnect:
    973994        {
    974             if (requestHeader->size < sizeof(VMMDevHGCMConnect))
     995            if (pRequestHeader->size < sizeof(VMMDevHGCMConnect))
    975996            {
    976997                AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
    977                 requestHeader->rc = VERR_INVALID_PARAMETER;
     998                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    978999            }
    9791000            else if (!pData->pHGCMDrv)
    9801001            {
    9811002                Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
    982                 requestHeader->rc = VERR_NOT_SUPPORTED;
    983             }
    984             else
    985             {
    986                 VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)requestHeader;
     1003                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     1004            }
     1005            else
     1006            {
     1007                VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)pRequestHeader;
    9871008
    9881009                Log(("VMMDevReq_HGCMConnect\n"));
    9891010
    990                 requestHeader->rc = vmmdevHGCMConnect (pData, pHGCMConnect, (RTGCPHYS)u32);
     1011                pRequestHeader->rc = vmmdevHGCMConnect (pData, pHGCMConnect, (RTGCPHYS)u32);
    9911012            }
    9921013            break;
    … …  
    9951016        case VMMDevReq_HGCMDisconnect:
    9961017        {
    997             if (requestHeader->size < sizeof(VMMDevHGCMDisconnect))
     1018            if (pRequestHeader->size < sizeof(VMMDevHGCMDisconnect))
    9981019            {
    9991020                AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
    1000                 requestHeader->rc = VERR_INVALID_PARAMETER;
     1021                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    10011022            }
    10021023            else if (!pData->pHGCMDrv)
    10031024            {
    10041025                Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
    1005                 requestHeader->rc = VERR_NOT_SUPPORTED;
    1006             }
    1007             else
    1008             {
    1009                 VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)requestHeader;
     1026                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     1027            }
     1028            else
     1029            {
     1030                VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)pRequestHeader;
    10101031
    10111032                Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
    1012                 requestHeader->rc = vmmdevHGCMDisconnect (pData, pHGCMDisconnect, (RTGCPHYS)u32);
     1033                pRequestHeader->rc = vmmdevHGCMDisconnect (pData, pHGCMDisconnect, (RTGCPHYS)u32);
    10131034            }
    10141035            break;
    … …  
    10171038        case VMMDevReq_HGCMCall:
    10181039        {
    1019             if (requestHeader->size < sizeof(VMMDevHGCMCall))
     1040            if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
    10201041            {
    10211042                AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
    1022                 requestHeader->rc = VERR_INVALID_PARAMETER;
     1043                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    10231044            }
    10241045            else if (!pData->pHGCMDrv)
    10251046            {
    10261047                Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
    1027                 requestHeader->rc = VERR_NOT_SUPPORTED;
    1028             }
    1029             else
    1030             {
    1031                 VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)requestHeader;
     1048                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     1049            }
     1050            else
     1051            {
     1052                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pRequestHeader;
    10321053
    10331054                Log2(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
    1034                 Log2(("%.*Vhxd\n", requestHeader->size, requestHeader));
    1035 
    1036                 requestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32);
     1055                Log2(("%.*Vhxd\n", pRequestHeader->size, requestHeader));
     1056
     1057                pRequestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32);
    10371058            }
    10381059            break;
    … …  
    10421063        case VMMDevReq_VideoAccelEnable:
    10431064        {
    1044             if (requestHeader->size < sizeof(VMMDevVideoAccelEnable))
     1065            if (pRequestHeader->size < sizeof(VMMDevVideoAccelEnable))
    10451066            {
    10461067                Log(("VMMDevReq_VideoAccelEnable request size too small!!!\n"));
    1047                 requestHeader->rc = VERR_INVALID_PARAMETER;
     1068                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    10481069            }
    10491070            else if (!pData->pDrv)
    10501071            {
    10511072                Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
    1052                 requestHeader->rc = VERR_NOT_SUPPORTED;
    1053             }
    1054             else
    1055             {
    1056                 VMMDevVideoAccelEnable *ptr = (VMMDevVideoAccelEnable *)requestHeader;
     1073                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     1074            }
     1075            else
     1076            {
     1077                VMMDevVideoAccelEnable *ptr = (VMMDevVideoAccelEnable *)pRequestHeader;
    10571078
    10581079                if (ptr->cbRingBuffer != VBVA_RING_BUFFER_SIZE)
    … …  
    10601081                    /* The guest driver seems compiled with another headers. */
    10611082                    Log(("VMMDevReq_VideoAccelEnable guest ring buffer size %d, should be %d!!!\n", ptr->cbRingBuffer, VBVA_RING_BUFFER_SIZE));
    1062                     requestHeader->rc = VERR_INVALID_PARAMETER;
     1083                    pRequestHeader->rc = VERR_INVALID_PARAMETER;
    10631084                }
    10641085                else
    … …  
    10691090                    LogFlow(("VMMDevReq_VideoAccelEnable ptr->u32Enable = %d\n", ptr->u32Enable));
    10701091
    1071                     requestHeader->rc = ptr->u32Enable?
     1092                    pRequestHeader->rc = ptr->u32Enable?
    10721093                        pData->pDrv->pfnVideoAccelEnable (pData->pDrv, true, &pData->pVMMDevRAMHC->vbvaMemory):
    10731094                        pData->pDrv->pfnVideoAccelEnable (pData->pDrv, false, NULL);
    10741095
    10751096                    if (   ptr->u32Enable
    1076                         && VBOX_SUCCESS (requestHeader->rc))
     1097                        && VBOX_SUCCESS (pRequestHeader->rc))
    10771098                    {
    10781099                        ptr->fu32Status |= VBVA_F_STATUS_ENABLED;
    … …  
    10951116        case VMMDevReq_VideoAccelFlush:
    10961117        {
    1097             if (requestHeader->size < sizeof(VMMDevVideoAccelFlush))
     1118            if (pRequestHeader->size < sizeof(VMMDevVideoAccelFlush))
    10981119            {
    10991120                AssertMsgFailed(("VMMDevReq_VideoAccelFlush request size too small.\n"));
    1100                 requestHeader->rc = VERR_INVALID_PARAMETER;
     1121                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    11011122            }
    11021123            else if (!pData->pDrv)
    11031124            {
    11041125                Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
    1105                 requestHeader->rc = VERR_NOT_SUPPORTED;
     1126                pRequestHeader->rc = VERR_NOT_SUPPORTED;
    11061127            }
    11071128            else
    … …  
    11091130                pData->pDrv->pfnVideoAccelFlush (pData->pDrv);
    11101131
    1111                 requestHeader->rc = VINF_SUCCESS;
     1132                pRequestHeader->rc = VINF_SUCCESS;
    11121133            }
    11131134            break;
    … …  
    11161137        case VMMDevReq_VideoSetVisibleRegion:
    11171138        {
    1118             if (requestHeader->size < sizeof(VMMDevVideoSetVisibleRegion))
     1139            if (pRequestHeader->size < sizeof(VMMDevVideoSetVisibleRegion))
    11191140            {
    11201141                Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
    1121                 requestHeader->rc = VERR_INVALID_PARAMETER;
     1142                pRequestHeader->rc = VERR_INVALID_PARAMETER;
    11221143            }
    11231144            else if (!pData->pDrv)
    11241145            {
    11251146                Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
    1126                 requestHeader->rc = VERR_NOT_SUPPORTED;
    1127             }
    1128             else
    1129             {
    1130                 VMMDevVideoSetVisibleRegion *ptr = (VMMDevVideoSetVisibleRegion *)requestHeader;
     1147                pRequestHeader->rc = VERR_NOT_SUPPORTED;
     1148            }
     1149            else
     1150            {
     1151                VMMDevVideoSetVisibleRegion *ptr = (VMMDevVideoSetVisibleRegion *)pRequestHeader;
    11311152
    11321153                if (!ptr->cRect)
    11331154                {
    11341155                    Log(("VMMDevReq_VideoSetVisibleRegion no rectangles!!!\n"));
    1135                     requestHeader->rc = VERR_INVALID_PARAMETER;
     1156                    pRequestHeader->rc = VERR_INVALID_PARAMETER;
    11361157                }
    11371158                else
    1138                 if (requestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + (ptr->cRect-1)*sizeof(RTRECT))
     1159                if (pRequestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + (ptr->cRect-1)*sizeof(RTRECT))
    11391160                {
    11401161                    Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
    1141                     requestHeader->rc = VERR_INVALID_PARAMETER;
     1162                    pRequestHeader->rc = VERR_INVALID_PARAMETER;
    11421163                }
    11431164                else
    … …  
    11451166                    Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
    11461167                    /* forward the call */
    1147                     requestHeader->rc = pData->pDrv->pfnSetVisibleRegion(pData->pDrv, ptr->cRect, &ptr->Rect);
     1168                    pRequestHeader->rc = pData->pDrv->pfnSetVisibleRegion(pData->pDrv, ptr->cRect, &ptr->Rect);
    11481169                }
    11491170            }
    … …  
    11531174        case VMMDevReq_GetSeamlessChangeRequest:
    11541175        {
    1155             if (requestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
    1156             {
    1157                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1158             }
    1159             else
    1160             {
    1161                 VMMDevSeamlessChangeRequest *seamlessChangeRequest = (VMMDevSeamlessChangeRequest*)requestHeader;
     1176            if (pRequestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
     1177            {
     1178                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1179            }
     1180            else
     1181            {
     1182                VMMDevSeamlessChangeRequest *seamlessChangeRequest = (VMMDevSeamlessChangeRequest*)pRequestHeader;
    11621183                /* just pass on the information */
    11631184                Log(("VMMDev: returning seamless change request mode=%d\n", pData->fSeamlessEnabled));
    … …  
    11731194                }
    11741195
    1175                 requestHeader->rc = VINF_SUCCESS;
     1196                pRequestHeader->rc = VINF_SUCCESS;
    11761197            }
    11771198            break;
    … …  
    11801201        case VMMDevReq_GetVRDPChangeRequest:
    11811202        {
    1182             if (requestHeader->size != sizeof(VMMDevVRDPChangeRequest))
    1183             {
    1184                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1185             }
    1186             else
    1187             {
    1188                 VMMDevVRDPChangeRequest *vrdpChangeRequest = (VMMDevVRDPChangeRequest*)requestHeader;
     1203            if (pRequestHeader->size != sizeof(VMMDevVRDPChangeRequest))
     1204            {
     1205                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1206            }
     1207            else
     1208            {
     1209                VMMDevVRDPChangeRequest *vrdpChangeRequest = (VMMDevVRDPChangeRequest*)pRequestHeader;
    11891210                /* just pass on the information */
    11901211                Log(("VMMDev: returning VRDP status %d level %d\n", pData->fVRDPEnabled, pData->u32VRDPExperienceLevel));
    … …  
    11931214                vrdpChangeRequest->u32VRDPExperienceLevel = pData->u32VRDPExperienceLevel;
    11941215               
    1195                 requestHeader->rc = VINF_SUCCESS;
     1216                pRequestHeader->rc = VINF_SUCCESS;
    11961217            }
    11971218            break;
    … …  
    12011222        {
    12021223            Log(("VMMDevReq_GetMemBalloonChangeRequest\n"));
    1203             if (requestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
     1224            if (pRequestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
    12041225            {
    12051226                AssertFailed();
    1206                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1207             }
    1208             else
    1209             {
    1210                 VMMDevGetMemBalloonChangeRequest *memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest*)requestHeader;
     1227                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1228            }
     1229            else
     1230            {
     1231                VMMDevGetMemBalloonChangeRequest *memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest*)pRequestHeader;
    12111232                /* just pass on the information */
    12121233                Log(("VMMDev: returning memory balloon size =%d\n", pData->u32MemoryBalloonSize));
    … …  
    12201241                }
    12211242
    1222                 requestHeader->rc = VINF_SUCCESS;
     1243                pRequestHeader->rc = VINF_SUCCESS;
    12231244            }
    12241245            break;
    … …  
    12271248        case VMMDevReq_ChangeMemBalloon:
    12281249        {
    1229             VMMDevChangeMemBalloon *memBalloonChange = (VMMDevChangeMemBalloon*)requestHeader;
     1250            VMMDevChangeMemBalloon *memBalloonChange = (VMMDevChangeMemBalloon*)pRequestHeader;
    12301251
    12311252            Log(("VMMDevReq_ChangeMemBalloon\n"));
    1232             if (    requestHeader->size < sizeof(VMMDevChangeMemBalloon)
     1253            if (    pRequestHeader->size < sizeof(VMMDevChangeMemBalloon)
    12331254                ||  memBalloonChange->cPages != VMMDEV_MEMORY_BALLOON_CHUNK_PAGES
    1234                 ||  requestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
     1255                ||  pRequestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
    12351256            {
    12361257                AssertFailed();
    1237                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1238             }
    1239             else
    1240             {
    1241                 requestHeader->rc = pData->pDrv->pfnChangeMemoryBalloon(pData->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
     1258                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1259            }
     1260            else
     1261            {
     1262                pRequestHeader->rc = pData->pDrv->pfnChangeMemoryBalloon(pData->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
    12421263            }
    12431264            break;
    … …  
    12471268        {
    12481269            Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
    1249             if (requestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
     1270            if (pRequestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
    12501271            {
    12511272                AssertFailed();
    1252                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1253             }
    1254             else
    1255             {
    1256                 VMMDevGetStatisticsChangeRequest *statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest*)requestHeader;
     1273                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1274            }
     1275            else
     1276            {
     1277                VMMDevGetStatisticsChangeRequest *statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest*)pRequestHeader;
    12571278                /* just pass on the information */
    12581279                Log(("VMMDev: returning statistics interval %d seconds\n", pData->u32StatIntervalSize));
    … …  
    12651286                }
    12661287
    1267                 requestHeader->rc = VINF_SUCCESS;
     1288                pRequestHeader->rc = VINF_SUCCESS;
    12681289            }
    12691290            break;
    … …  
    12731294        {
    12741295            Log(("VMMDevReq_ReportGuestStats\n"));
    1275             if (requestHeader->size != sizeof(VMMDevReportGuestStats))
    1276             {
    1277                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1278             }
    1279             else
    1280             {
    1281                 VMMDevReportGuestStats *stats = (VMMDevReportGuestStats*)requestHeader;
     1296            if (pRequestHeader->size != sizeof(VMMDevReportGuestStats))
     1297            {
     1298                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1299            }
     1300            else
     1301            {
     1302                VMMDevReportGuestStats *stats = (VMMDevReportGuestStats*)pRequestHeader;
    12821303
    12831304#ifdef DEBUG
    … …  
    13411362
    13421363                /* forward the call */
    1343                 requestHeader->rc = pData->pDrv->pfnReportStatistics(pData->pDrv, &stats->guestStats);
     1364                pRequestHeader->rc = pData->pDrv->pfnReportStatistics(pData->pDrv, &stats->guestStats);
    13441365            }
    13451366            break;
    … …  
    13481369        case VMMDevReq_QueryCredentials:
    13491370        {
    1350             if (requestHeader->size != sizeof(VMMDevCredentials))
     1371            if (pRequestHeader->size != sizeof(VMMDevCredentials))
    13511372            {
    13521373                AssertMsgFailed(("VMMDevReq_QueryCredentials request size too small.\n"));
    1353                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1354             }
    1355             else
    1356             {
    1357                 VMMDevCredentials *credentials = (VMMDevCredentials*)requestHeader;
     1374                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1375            }
     1376            else
     1377            {
     1378                VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
    13581379
    13591380                /* let's start by nulling out the data */
    … …  
    14191440                }
    14201441
    1421                 requestHeader->rc = VINF_SUCCESS;
     1442                pRequestHeader->rc = VINF_SUCCESS;
    14221443            }
    14231444            break;
    … …  
    14261447        case VMMDevReq_ReportCredentialsJudgement:
    14271448        {
    1428             if (requestHeader->size != sizeof(VMMDevCredentials))
     1449            if (pRequestHeader->size != sizeof(VMMDevCredentials))
    14291450            {
    14301451                AssertMsgFailed(("VMMDevReq_ReportCredentialsJudgement request size too small.\n"));
    1431                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1432             }
    1433             else
    1434             {
    1435                 VMMDevCredentials *credentials = (VMMDevCredentials*)requestHeader;
     1452                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1453            }
     1454            else
     1455            {
     1456                VMMDevCredentials *credentials = (VMMDevCredentials*)pRequestHeader;
    14361457
    14371458                /* what does the guest think about the credentials? (note: the order is important here!) */
    … …  
    14511472                    Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", credentials->u32Flags));
    14521473
    1453                 requestHeader->rc = VINF_SUCCESS;
     1474                pRequestHeader->rc = VINF_SUCCESS;
    14541475            }
    14551476            break;
    … …  
    14591480        case VMMDevReq_LogString:
    14601481        {
    1461             if (requestHeader->size < sizeof(VMMDevReqLogString))
     1482            if (pRequestHeader->size < sizeof(VMMDevReqLogString))
    14621483            {
    14631484                AssertMsgFailed(("VMMDevReq_LogString request size too small.\n"));
    1464                 requestHeader->rc = VERR_INVALID_PARAMETER;
    1465             }
    1466             else
    1467             {
    1468                 VMMDevReqLogString *pReqLogString = (VMMDevReqLogString*)requestHeader;
     1485                pRequestHeader->rc = VERR_INVALID_PARAMETER;
     1486            }
     1487            else
     1488            {
     1489                VMMDevReqLogString *pReqLogString = (VMMDevReqLogString*)pRequestHeader;
    14691490#undef LOG_GROUP
    14701491#define LOG_GROUP LOG_GROUP_DEV_VMM_BACKDOOR
    … …  
    14741495#undef LOG_GROUP
    14751496#define LOG_GROUP LOG_GROUP_DEV_VMM
    1476                 requestHeader->rc = VINF_SUCCESS;
     1497                pRequestHeader->rc = VINF_SUCCESS;
    14771498            }
    14781499            break;
    … …  
    14811502        default:
    14821503        {
    1483             requestHeader->rc = VERR_NOT_IMPLEMENTED;
    1484 
    1485             Log(("VMMDev unknown request type %d\n", requestHeader->requestType));
    1486 
    1487             break;
    1488         }
    1489     }
    1490 
     1504            pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
     1505
     1506            Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
     1507
     1508            break;
     1509        }
     1510    }
     1511
     1512end:
     1513    /* Write the result back to guest memory */
     1514    if (pRequestHeader)
     1515    {
     1516        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
     1517        RTMemFree(pRequestHeader);
     1518    }
     1519    else
     1520    {
     1521        /* early error case; write back header only */
     1522        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
     1523    }
    14911524    return rcRet;
    14921525}
    … …  
    19181951
    19191952
    1920 #define VMMDEV_SSM_VERSION  5
     1953#define VMMDEV_SSM_VERSION  6
    19211954
    19221955/**

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp

    r4599 r5040  
    7070    VBOXHGCMCMDTYPE enmCmdType;
    7171
    72     /* GC pointer of the guest request. */
    73     RTGCPHYS GCPtr;
    74 
    75     /* HC pointer to guest request. */
    76     VMMDevHGCMRequestHeader *pHeader;
     72    /* GC physical address of the guest request. */
     73    RTGCPHYS        GCPhys;
     74
     75    /* Request packet size */
     76    uint32_t        cbSize;
    7777
    7878    /* Pointer to converted host parameters in case of a Call request. */
    … …  
    9999}
    100100
    101 static int vmmdevHGCMAddCommand (VMMDevState *pVMMDevState, PVBOXHGCMCMD pCmd, RTGCPHYS GCPtr, VBOXHGCMCMDTYPE enmCmdType)
     101static int vmmdevHGCMAddCommand (VMMDevState *pVMMDevState, PVBOXHGCMCMD pCmd, RTGCPHYS GCPhys, uint32_t cbSize, VBOXHGCMCMDTYPE enmCmdType)
    102102{
    103103    /* PPDMDEVINS pDevIns = pVMMDevState->pDevIns; */
    … …  
    121121       
    122122        pCmd->enmCmdType = enmCmdType;
    123         pCmd->GCPtr = GCPtr;
     123        pCmd->GCPhys = GCPhys;
     124        pCmd->cbSize = cbSize;
    124125       
    125126        /* Automatically enable HGCM events, if there are HGCM commands. */
    … …  
    287288}
    288289
    289 int vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPtr)
     290int vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys)
    290291{
    291292    int rc = VINF_SUCCESS;
    292293
    293     PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD));
     294    PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD) + pHGCMConnect->header.header.size);
    294295
    295296    if (pCmd)
    296297    {
    297         vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr, VBOXHGCMCMDTYPE_CONNECT);
    298 
    299         pCmd->pHeader = &pHGCMConnect->header;
     298        VMMDevHGCMConnect *pHGCMConnectCopy = (VMMDevHGCMConnect *)(pCmd+1);
     299       
     300        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPhys, pHGCMConnect->header.header.size, VBOXHGCMCMDTYPE_CONNECT);
     301
     302        memcpy(pHGCMConnectCopy, pHGCMConnect, pHGCMConnect->header.header.size);
     303
    300304        pCmd->paHostParms = NULL;
    301305        pCmd->cLinPtrs = 0;
    … …  
    306310        pHGCMConnect->loc.type = VMMDevHGCMLoc_LocalHost_Existing;
    307311
    308         rc = pVMMDevState->pHGCMDrv->pfnConnect (pVMMDevState->pHGCMDrv, pCmd, &pHGCMConnect->loc, &pHGCMConnect->u32ClientID);
     312        rc = pVMMDevState->pHGCMDrv->pfnConnect (pVMMDevState->pHGCMDrv, pCmd, &pHGCMConnectCopy->loc, &pHGCMConnectCopy->u32ClientID);
    309313    }
    310314    else
    … …  
    316320}
    317321
    318 int vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPtr)
     322int vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPhys)
    319323{
    320324    int rc = VINF_SUCCESS;
    … …  
    324328    if (pCmd)
    325329    {
    326         vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr, VBOXHGCMCMDTYPE_DISCONNECT);
    327 
    328         pCmd->pHeader = &pHGCMDisconnect->header;
     330        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPhys, pHGCMDisconnect->header.header.size, VBOXHGCMCMDTYPE_DISCONNECT);
     331
    329332        pCmd->paHostParms = NULL;
    330333        pCmd->cLinPtrs = 0;
    … …  
    342345
    343346
    344 int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPtr)
     347int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPhys)
    345348{
    346349    int rc = VINF_SUCCESS;
    … …  
    392395                Log(("vmmdevHGCMCall: linptr size = %d\n", pGuestParm->u.Pointer.size));
    393396            } break;
     397
    394398            case VMMDevHGCMParmType_32bit:
    395399            case VMMDevHGCMParmType_64bit:
    … …  
    397401            {
    398402            } break;
     403
    399404            default:
    400405            {
    … …  
    420425    memset (pCmd, 0, sizeof (*pCmd));
    421426   
    422     pCmd->pHeader     = &pHGCMCall->header;
    423427    pCmd->paHostParms = NULL;
    424428    pCmd->cLinPtrs    = cLinPtrs;
    … …  
    494498
    495499                     AssertFailed();
    496                      /** @todo It's no longer allowed to save a conversion address for later use! */
    497                      rc = PDMDevHlpPhys2HCVirt (pVMMDevState->pDevIns, physAddr, size, &pHostParm->u.pointer.addr);
     500                     /* rc = PDMDevHlpPhys2HCVirt (pVMMDevState->pDevIns, physAddr, size, &pHostParm->u.pointer.addr); */
    498501
    499502                     Log(("vmmdevHGCMCall: PhysAddr guest parameter %VGp\n", physAddr));
    … …  
    555558    if (VBOX_SUCCESS (rc))
    556559    {
    557         vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr, VBOXHGCMCMDTYPE_CALL);
     560        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPhys, pHGCMCall->header.header.size, VBOXHGCMCMDTYPE_CALL);
    558561
    559562        /* Pass the function call to HGCM connector for actual processing */
    … …  
    573576}
    574577
    575 static int vmmdevHGCMCmdVerify (PVBOXHGCMCMD pCmd)
    576 {
    577     VMMDevHGCMRequestHeader *pHeader = pCmd->pHeader;
    578 
     578static int vmmdevHGCMCmdVerify (PVBOXHGCMCMD pCmd, VMMDevHGCMRequestHeader *pHeader)
     579{
    579580    switch (pCmd->enmCmdType)
    580581    {
    … …  
    602603#define PDMIHGCMPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState *) ((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, HGCMPort)) )
    603604
    604 DECLCALLBACK(void) hgcmCompleted (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmd)
    605 {
    606     int rc = VINF_SUCCESS;
    607 
    608     VMMDevHGCMRequestHeader *pHeader = pCmd->pHeader;
    609 
    610     VMMDevState *pVMMDevState = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
     605DECLCALLBACK(void) hgcmCompletedWorker (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmd)
     606{
     607    VMMDevState             *pVMMDevState = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
     608    VMMDevHGCMRequestHeader *pHeader;
     609    int                      rc = VINF_SUCCESS;
     610
     611    pHeader = (VMMDevHGCMRequestHeader *)RTMemAllocZ (pCmd->cbSize);
     612    Assert(pHeader);
     613    if (pHeader == NULL)
     614        return;
     615
     616    PDMDevHlpPhysRead(pVMMDevState->pDevIns, (RTGCPHYS)pCmd->GCPhys, pHeader, pCmd->cbSize);
    611617
    612618    if (result != VINF_HGCM_SAVE_STATE)
    … …  
    616622       
    617623        /* Verify the request type. */
    618         rc = vmmdevHGCMCmdVerify (pCmd);
     624        rc = vmmdevHGCMCmdVerify (pCmd, pHeader);
    619625
    620626        if (VBOX_SUCCESS (rc))
    621627        {
    622628            /* Update parameters and data buffers. */
    623 
    624             if (pHeader->header.requestType == VMMDevReq_HGCMCall)
     629           
     630            switch (pHeader->header.requestType)
     631            {
     632            case VMMDevReq_HGCMCall:
    625633            {
    626634                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
    … …  
    676684                    }
    677685                }
     686                break;
     687            }
     688
     689            case VMMDevReq_HGCMConnect:
     690            {
     691                VMMDevHGCMConnect *pHGCMConnectCopy = (VMMDevHGCMConnect *)(pCmd+1);
     692
     693                /* save the client id in the guest request packet */
     694                VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)pHeader;
     695                pHGCMConnect->u32ClientID = pHGCMConnectCopy->u32ClientID;
     696                break;
     697            }
    678698            }
    679699        }
    … …  
    687707        pHeader->fu32Flags |= VBOX_HGCM_REQ_DONE;
    688708
     709        /* Write back the request */
     710        PDMDevHlpPhysWrite(pVMMDevState->pDevIns, pCmd->GCPhys, pHeader, pCmd->cbSize);
     711
    689712        VMMDevNotifyGuest (pVMMDevState, VMMDEV_EVENT_HGCM);
    690713
    … …  
    699722        RTMemFree (pCmd);
    700723    }
     724    RTMemFree(pHeader);
    701725
    702726    return;
     727}
     728
     729DECLCALLBACK(void) hgcmCompleted (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmd)
     730{
     731    VMMDevState *pVMMDevState = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
     732
     733    /* Not safe to execute asynchroneously; forward to EMT */
     734    int rc = VMR3ReqCallEx(PDMDevHlpGetVM(pVMMDevState->pDevIns), NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
     735                           (PFNRT)hgcmCompletedWorker, 3, pInterface, result, pCmd);
     736    AssertRC(rc);
    703737}
    704738
    … …  
    739773            PVBOXHGCMCMD pNext = pIter->pNext;
    740774
    741             LogFlowFunc (("Saving %VGp\n", pIter->GCPtr));
    742             rc = SSMR3PutGCPtr(pSSM, pIter->GCPtr);
     775            LogFlowFunc (("Saving %VGp\n", pIter->GCPhys));
     776            rc = SSMR3PutGCPhys(pSSM, pIter->GCPhys);
     777            AssertRCReturn(rc, rc);
     778
     779            rc = SSMR3PutU32(pSSM, pIter->cbSize);
    743780            AssertRCReturn(rc, rc);
    744781
    … …  
    768805    while (cCmds--)
    769806    {
    770         RTGCPHYS GCPtr;
    771         rc = SSMR3GetGCPtr(pSSM, &GCPtr);
     807        RTGCPHYS GCPhys;
     808        uint32_t cbSize;
     809
     810        rc = SSMR3GetGCPhys(pSSM, &GCPhys);
    772811        AssertRCReturn(rc, rc);
    773812
    774         LogFlowFunc (("Restoring %VGp\n", GCPtr));
     813        rc = SSMR3GetU32(pSSM, &cbSize);
     814        AssertRCReturn(rc, rc);
     815
     816        LogFlowFunc (("Restoring %VGp size %x bytes\n", GCPhys, cbSize));
    775817
    776818        PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD));
    777819        AssertReturn(pCmd, VERR_NO_MEMORY);
    778820
    779         vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr, VBOXHGCMCMDTYPE_LOADSTATE);
     821        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPhys, cbSize, VBOXHGCMCMDTYPE_LOADSTATE);
    780822    }
    781823
    … …  
    803845            PVBOXHGCMCMD pNext = pIter->pNext;
    804846
    805             VMMDevRequestHeader *requestHeader = NULL;
    806             rc = PDMDevHlpPhys2HCVirt(pDevIns, pIter->GCPtr, 0, (PRTHCPTR)&requestHeader);
    807 
    808             if (VBOX_FAILURE(rc) || !requestHeader)
     847            VMMDevRequestHeader *requestHeader = (VMMDevRequestHeader *)RTMemAllocZ (pIter->cbSize);
     848            Assert(requestHeader);
     849            if (requestHeader == NULL)
     850                return VERR_NO_MEMORY;
     851
     852            PDMDevHlpPhysRead(pVMMDevState->pDevIns, (RTGCPHYS)pIter->GCPhys, requestHeader, pIter->cbSize);
     853
     854            /* the structure size must be greater or equal to the header size */
     855            if (requestHeader->size < sizeof(VMMDevRequestHeader))
    809856            {
    810                 AssertMsgFailed(("VMMDev::LoadStateDone: could not convert guest physical address to host virtual!!! rc = %Vrc\n", rc));
     857                Log(("VMMDev request header size too small! size = %d\n", requestHeader->size));
    811858            }
    812859            else
    813860            {
    814                 /* the structure size must be greater or equal to the header size */
    815                 if (requestHeader->size < sizeof(VMMDevRequestHeader))
     861                /* check the version of the header structure */
     862                if (requestHeader->version != VMMDEV_REQUEST_HEADER_VERSION)
    816863                {
    817                     Log(("VMMDev request header size too small! size = %d\n", requestHeader->size));
     864                    Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader->version, VMMDEV_REQUEST_HEADER_VERSION));
    818865                }
    819866                else
    820867                {
    821                     /* check the version of the header structure */
    822                     if (requestHeader->version != VMMDEV_REQUEST_HEADER_VERSION)
     868                    Log(("VMMDev request issued: %d\n", requestHeader->requestType));
     869
     870                    switch (requestHeader->requestType)
    823871                    {
    824                         Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader->version, VMMDEV_REQUEST_HEADER_VERSION));
    825                     }
    826                     else
    827                     {
    828                         Log(("VMMDev request issued: %d\n", requestHeader->requestType));
    829 
    830                         switch (requestHeader->requestType)
     872                        case VMMDevReq_HGCMConnect:
    831873                        {
    832                             case VMMDevReq_HGCMConnect:
     874                            if (requestHeader->size < sizeof(VMMDevHGCMConnect))
    833875                            {
    834                                 if (requestHeader->size < sizeof(VMMDevHGCMConnect))
    835                                 {
    836                                     AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
    837                                     requestHeader->rc = VERR_INVALID_PARAMETER;
    838                                 }
    839                                 else if (!pVMMDevState->pHGCMDrv)
    840                                 {
    841                                     Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
    842                                     requestHeader->rc = VERR_NOT_SUPPORTED;
    843                                 }
    844                                 else
    845                                 {
    846                                     VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)requestHeader;
    847 
    848                                     Log(("VMMDevReq_HGCMConnect\n"));
    849 
    850                                     requestHeader->rc = vmmdevHGCMConnect (pVMMDevState, pHGCMConnect, pIter->GCPtr);
    851                                 }
    852                                 break;
     876                                AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
     877                                requestHeader->rc = VERR_INVALID_PARAMETER;
    853878                            }
    854 
    855                             case VMMDevReq_HGCMDisconnect:
     879                            else if (!pVMMDevState->pHGCMDrv)
    856880                            {
    857                                 if (requestHeader->size < sizeof(VMMDevHGCMDisconnect))
    858                                 {
    859                                     AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
    860                                     requestHeader->rc = VERR_INVALID_PARAMETER;
    861                                 }
    862                                 else if (!pVMMDevState->pHGCMDrv)
    863                                 {
    864                                     Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
    865                                     requestHeader->rc = VERR_NOT_SUPPORTED;
    866                                 }
    867                                 else
    868                                 {
    869                                     VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)requestHeader;
    870 
    871                                     Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
    872                                     requestHeader->rc = vmmdevHGCMDisconnect (pVMMDevState, pHGCMDisconnect, pIter->GCPtr);
    873                                 }
    874                                 break;
     881                                Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
     882                                requestHeader->rc = VERR_NOT_SUPPORTED;
    875883                            }
    876 
    877                             case VMMDevReq_HGCMCall:
     884                            else
    878885                            {
    879                                 if (requestHeader->size < sizeof(VMMDevHGCMCall))
    880                                 {
    881                                     AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
    882                                     requestHeader->rc = VERR_INVALID_PARAMETER;
    883                                 }
    884                                 else if (!pVMMDevState->pHGCMDrv)
    885                                 {
    886                                     Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
    887                                     requestHeader->rc = VERR_NOT_SUPPORTED;
    888                                 }
    889                                 else
    890                                 {
    891                                     VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)requestHeader;
    892 
    893                                     Log(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
    894 
    895                                     Log(("%.*Vhxd\n", requestHeader->size, requestHeader));
    896 
    897                                     requestHeader->rc = vmmdevHGCMCall (pVMMDevState, pHGCMCall, pIter->GCPtr);
    898                                 }
    899                                 break;
     886                                VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)requestHeader;
     887
     888                                Log(("VMMDevReq_HGCMConnect\n"));
     889
     890                                requestHeader->rc = vmmdevHGCMConnect (pVMMDevState, pHGCMConnect, pIter->GCPhys);
    900891                            }
    901                             default:
    902                                AssertReleaseFailed();
     892                            break;
    903893                        }
     894
     895                        case VMMDevReq_HGCMDisconnect:
     896                        {
     897                            if (requestHeader->size < sizeof(VMMDevHGCMDisconnect))
     898                            {
     899                                AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
     900                                requestHeader->rc = VERR_INVALID_PARAMETER;
     901                            }
     902                            else if (!pVMMDevState->pHGCMDrv)
     903                            {
     904                                Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
     905                                requestHeader->rc = VERR_NOT_SUPPORTED;
     906                            }
     907                            else
     908                            {
     909                                VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)requestHeader;
     910
     911                                Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
     912                                requestHeader->rc = vmmdevHGCMDisconnect (pVMMDevState, pHGCMDisconnect, pIter->GCPhys);
     913                            }
     914                            break;
     915                        }
     916
     917                        case VMMDevReq_HGCMCall:
     918                        {
     919                            if (requestHeader->size < sizeof(VMMDevHGCMCall))
     920                            {
     921                                AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
     922                                requestHeader->rc = VERR_INVALID_PARAMETER;
     923                            }
     924                            else if (!pVMMDevState->pHGCMDrv)
     925                            {
     926                                Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
     927                                requestHeader->rc = VERR_NOT_SUPPORTED;
     928                            }
     929                            else
     930                            {
     931                                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)requestHeader;
     932
     933                                Log(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
     934
     935                                Log(("%.*Vhxd\n", requestHeader->size, requestHeader));
     936
     937                                requestHeader->rc = vmmdevHGCMCall (pVMMDevState, pHGCMCall, pIter->GCPhys);
     938                            }
     939                            break;
     940                        }
     941                        default:
     942                           AssertReleaseFailed();
    904943                    }
    905944                }
    906945            }
    907946
     947            /* Write back the request */
     948            PDMDevHlpPhysWrite(pVMMDevState->pDevIns, pIter->GCPhys, requestHeader, pIter->cbSize);
     949            RTMemFree(requestHeader);
     950
    908951            vmmdevHGCMRemoveCommand (pVMMDevState, pIter);
     952            RTMemFree(pIter);
    909953            pIter = pNext;
    910954        }
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