VirtualBox

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


Ignore:
Timestamp:
Mar 23, 2007 2:45:10 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
19817
Message:

Implemented HGCM save/load state

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

Legend:

Unmodified
Added
Removed

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

    r1624 r1681  
    2222
    2323/* #define LOG_ENABLED */
    24 
    25 #define TIMESYNC_BACKDOOR
    2624
    2725#include <stdio.h>
    … …  
    904902                Log(("VMMDevReq_HGCMConnect\n"));
    905903
    906                 requestHeader->rc = vmmdevHGCMConnect (pData, pHGCMConnect);
     904                requestHeader->rc = vmmdevHGCMConnect (pData, pHGCMConnect, (RTGCPHYS)u32);
    907905            }
    908906            break;
    … …  
    926924
    927925                Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
    928                 requestHeader->rc = vmmdevHGCMDisconnect (pData, pHGCMDisconnect);
     926                requestHeader->rc = vmmdevHGCMDisconnect (pData, pHGCMDisconnect, (RTGCPHYS)u32);
    929927            }
    930928            break;
    … …  
    951949                Log(("%.*Vhxd\n", requestHeader->size, requestHeader));
    952950
    953                 requestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall);
     951                requestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32);
    954952            }
    955953            break;
    … …  
    14731471
    14741472
    1475 #define VMMDEV_SSM_VERSION 2
     1473#define VMMDEV_SSM_VERSION 3
    14761474
    14771475/**
    … …  
    14921490    SSMR3PutBool(pSSMHandle, pData->fNewGuestFilterMask);
    14931491    SSMR3PutU32(pSSMHandle, pData->u32NewGuestFilterMask);
     1492    SSMR3PutU32(pSSMHandle, pData->u32GuestFilterMask);
    14941493    SSMR3PutU32(pSSMHandle, pData->u32HostEventFlags);
    14951494    // here be dragons (probably)
    … …  
    15001499    SSMR3PutU32(pSSMHandle, pData->fu32AdditionsOk);
    15011500    SSMR3PutU32(pSSMHandle, pData->u32VideoAccelEnabled);
     1501
     1502#ifdef VBOX_HGCM
     1503    vmmdevHGCMSaveState (pData, pSSMHandle);
     1504#endif /* VBOX_HGCM */
     1505
    15021506    return VINF_SUCCESS;
    15031507}
    … …  
    15231527    SSMR3GetBool(pSSMHandle, &pData->fNewGuestFilterMask);
    15241528    SSMR3GetU32(pSSMHandle, &pData->u32NewGuestFilterMask);
     1529    SSMR3GetU32(pSSMHandle, &pData->u32GuestFilterMask);
    15251530    SSMR3GetU32(pSSMHandle, &pData->u32HostEventFlags);
    15261531//    SSMR3GetBool(pSSMHandle, &pData->pVMMDevRAMHC->fHaveEvents);
    … …  
    15311536    SSMR3GetU32(pSSMHandle, &pData->fu32AdditionsOk);
    15321537    SSMR3GetU32(pSSMHandle, &pData->u32VideoAccelEnabled);
     1538
     1539#ifdef VBOX_HGCM
     1540    vmmdevHGCMLoadState (pData, pSSMHandle);
     1541#endif /* VBOX_HGCM */
    15331542
    15341543    /*
    … …  
    15581567{
    15591568    VMMDevState *pData = PDMINS2DATA(pDevIns, VMMDevState*);
     1569
     1570#ifdef VBOX_HGCM
     1571    vmmdevHGCMLoadStateDone (pData, pSSMHandle);
     1572#endif /* VBOX_HGCM */
    15601573
    15611574    VMMDevNotifyGuest (pData, VMMDEV_EVENT_RESTORED);
    … …  
    17181731        AssertMsgFailed(("VMMDev SUPPageAlloc(%#x,) -> %d\n", VMMDEV_RAM_SIZE, rc));
    17191732    }
     1733   
     1734#ifdef VBOX_HGCM
     1735    rc = RTCritSectInit(&pData->critsectHGCMCmdList);
     1736    AssertRC(rc);
     1737#endif /* VBOX_HGCM */
    17201738
    17211739    /* initialize the VMMDev memory */

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

    r1562 r1681  
    5757struct VBOXHGCMCMD
    5858{
     59    /* Active commands, list is protected by critsectHGCMCmdList. */
     60    struct VBOXHGCMCMD *pNext;
     61    struct VBOXHGCMCMD *pPrev;
     62   
     63    /* GC ptr of the command header. */
     64    RTGCPHYS GCPtr;
     65
    5966    /* Pointer to guest request. */
    6067    VMMDevHGCMRequestHeader *pHeader;
    … …  
    6269    /* Pointer to converted host parameters in case of a Call request. */
    6370    VBOXHGCMSVCPARM *paHostParms;
    64    
     71
    6572    /* Linear pointer parameters information. */
    6673    int cLinPtrs;
    67    
     74
    6875    /* Pointer to descriptions of linear pointers.  */
    6976    VBOXHGCMLINPTR *paLinPtrs;
    7077};
     78
     79static int vmmdevHGCMCmdListLock (VMMDevState *pVMMDevState)
     80{
     81    int rc = RTCritSectEnter (&pVMMDevState->critsectHGCMCmdList);
     82    AssertRC (rc);
     83    return rc;
     84}
     85
     86static void vmmdevHGCMCmdListUnlock (VMMDevState *pVMMDevState)
     87{
     88    int rc = RTCritSectLeave (&pVMMDevState->critsectHGCMCmdList);
     89    AssertRC (rc);
     90}
     91
     92static int vmmdevHGCMAddCommand (VMMDevState *pVMMDevState, PVBOXHGCMCMD pCmd, RTGCPHYS GCPtr)
     93{
     94    PPDMDEVINS pDevIns = pVMMDevState->pDevIns;
     95
     96    int rc = vmmdevHGCMCmdListLock (pVMMDevState);
     97   
     98    if (VBOX_SUCCESS (rc))
     99    {
     100        LogFlowFunc(("%p\n", pCmd));
     101
     102        /* Insert at the head of the list. The vmmdevHGCMLoadStateDone depends on this. */
     103        pCmd->pNext = pVMMDevState->pHGCMCmdList;
     104        pCmd->pPrev = NULL;
     105       
     106        if (pVMMDevState->pHGCMCmdList)
     107        {
     108            pVMMDevState->pHGCMCmdList->pPrev = pCmd;
     109        }
     110       
     111        pVMMDevState->pHGCMCmdList = pCmd;
     112       
     113        pCmd->GCPtr = GCPtr;
     114
     115        vmmdevHGCMCmdListUnlock (pVMMDevState);
     116    }
     117   
     118    return rc;
     119}
     120
     121static int vmmdevHGCMRemoveCommand (VMMDevState *pVMMDevState, PVBOXHGCMCMD pCmd)
     122{
     123    PPDMDEVINS pDevIns = pVMMDevState->pDevIns;
     124
     125    int rc = vmmdevHGCMCmdListLock (pVMMDevState);
     126   
     127    if (VBOX_SUCCESS (rc))
     128    {
     129        LogFlowFunc(("%p\n", pCmd));
     130
     131        if (pCmd->pNext)
     132        {
     133            pCmd->pNext->pPrev = pCmd->pPrev;
     134        }
     135        else
     136        {
     137           /* Tail, do nothing. */
     138        }
     139       
     140        if (pCmd->pPrev)
     141        {
     142            pCmd->pPrev->pNext = pCmd->pNext;
     143        }
     144        else
     145        {
     146            pVMMDevState->pHGCMCmdList = pCmd->pNext;
     147        }
     148
     149        vmmdevHGCMCmdListUnlock (pVMMDevState);
     150    }
     151   
     152    return rc;
     153}
    71154
    72155static int vmmdevHGCMSaveLinPtr (PPDMDEVINS pDevIns,
    … …  
    183266}
    184267
    185 int vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect)
     268int vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPtr)
    186269{
    187270    int rc = VINF_SUCCESS;
    188271
    189     PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAlloc (sizeof (struct VBOXHGCMCMD));
     272    PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD));
    190273
    191274    if (pCmd)
    192275    {
     276        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr);
     277
    193278        pCmd->pHeader = &pHGCMConnect->header;
    194279        pCmd->paHostParms = NULL;
    … …  
    210295}
    211296
    212 int vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect)
     297int vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPtr)
    213298{
    214299    int rc = VINF_SUCCESS;
    215300
    216     PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAlloc (sizeof (struct VBOXHGCMCMD));
     301    PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD));
    217302
    218303    if (pCmd)
    219304    {
     305        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr);
     306
    220307        pCmd->pHeader = &pHGCMDisconnect->header;
    221308        pCmd->paHostParms = NULL;
    … …  
    234321
    235322
    236 int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall)
     323int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPtr)
    237324{
    238325    int rc = VINF_SUCCESS;
    … …  
    271358            case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
    272359            case VMMDevHGCMParmType_LinAddr:     /* In & Out */
    273 #if 0
    274             case VMMDevHGCMParmType_Virt16Addr:
    275             case VMMDevHGCMParmType_VirtAddr:
    276 #endif
    277360            {
    278361                cbCmdSize += pGuestParm->u.Pointer.size;
    … …  
    313396    }
    314397
     398    memset (pCmd, 0, sizeof (*pCmd));
     399   
    315400    pCmd->pHeader     = &pHGCMCall->header;
    316401    pCmd->paHostParms = NULL;
    … …  
    446531    if (VBOX_SUCCESS (rc))
    447532    {
     533        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr);
     534
    448535        /* Pass the function call to HGCM connector for actual processing */
    449536        rc = pVMMDevState->pHGCMDrv->pfnCall (pVMMDevState->pHGCMDrv, pCmd, pHGCMCall->u32ClientID, pHGCMCall->u32Function, cParms, pCmd->paHostParms);
    … …  
    472559    VMMDevState *pVMMDevState = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
    473560
    474     /* Setup return codes. */
    475     pHeader->result = result;
    476 
    477     /* Update parameters and data buffers. */
    478 
    479     if (pHeader->header.requestType == VMMDevReq_HGCMCall)
    480     {
    481         VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
    482 
    483         uint32_t cParms = pHGCMCall->cParms;
    484 
    485         HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
    486 
    487         VBOXHGCMSVCPARM *pHostParm = pCmd->paHostParms;
    488 
    489         uint32_t i;
    490         uint32_t iLinPtr = 0;
    491 
    492         for (i = 0; i < cParms; i++, pGuestParm++, pHostParm++)
    493         {
    494             switch (pGuestParm->type)
     561    if (result != VINF_HGCM_SAVE_STATE)
     562    {
     563        /* Setup return codes. */
     564        pHeader->result = result;
     565
     566        /* Update parameters and data buffers. */
     567
     568        if (pHeader->header.requestType == VMMDevReq_HGCMCall)
     569        {
     570            VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
     571
     572            uint32_t cParms = pHGCMCall->cParms;
     573
     574            HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     575
     576            VBOXHGCMSVCPARM *pHostParm = pCmd->paHostParms;
     577
     578            uint32_t i;
     579            uint32_t iLinPtr = 0;
     580
     581            for (i = 0; i < cParms; i++, pGuestParm++, pHostParm++)
    495582            {
    496                 case VMMDevHGCMParmType_32bit:
     583                switch (pGuestParm->type)
    497584                {
    498                     pGuestParm->u.value32 = pHostParm->u.uint32;
    499                 } break;
    500 
    501                 case VMMDevHGCMParmType_64bit:
    502                 {
    503                     pGuestParm->u.value64 = pHostParm->u.uint64;
    504                 } break;
    505 
    506                 case VMMDevHGCMParmType_PhysAddr:
    507                 {
    508                     /* do nothing */
    509                 } break;
    510 
    511                 case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
    512                 case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
    513                 case VMMDevHGCMParmType_LinAddr:     /* In & Out */
    514                 {
    515                     /* Copy buffer back to guest memory. */
    516                     uint32_t size = pGuestParm->u.Pointer.size;
    517 
    518                     if (size > 0 && pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     585                    case VMMDevHGCMParmType_32bit:
    519586                    {
    520                         /* Use the saved page list. */
    521                         rc = vmmdevHGCMWriteLinPtr (pVMMDevState->pDevIns, i, pHostParm->u.pointer.addr, size, iLinPtr++, pCmd->paLinPtrs);
    522 
    523 //                        RTGCPTR linearAddr = pGuestParm->u.Pointer.u.linearAddr;
    524 //
    525 //                        rc = pVMMDevState->pDevIns->pDevHlp->pfnPhysWriteGCVirt (pVMMDevState->pDevIns,
    526 //                                                                                 linearAddr,
    527 //                                                                                 pHostParm->u.pointer.addr,
    528 //                                                                                 size);
    529                         AssertReleaseRC(rc);
     587                        pGuestParm->u.value32 = pHostParm->u.uint32;
     588                    } break;
     589
     590                    case VMMDevHGCMParmType_64bit:
     591                    {
     592                        pGuestParm->u.value64 = pHostParm->u.uint64;
     593                    } break;
     594
     595                    case VMMDevHGCMParmType_PhysAddr:
     596                    {
     597                        /* do nothing */
     598                    } break;
     599
     600                    case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     601                    case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     602                    case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     603                    {
     604                        /* Copy buffer back to guest memory. */
     605                        uint32_t size = pGuestParm->u.Pointer.size;
     606
     607                        if (size > 0 && pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     608                        {
     609                            /* Use the saved page list. */
     610                            rc = vmmdevHGCMWriteLinPtr (pVMMDevState->pDevIns, i, pHostParm->u.pointer.addr, size, iLinPtr++, pCmd->paLinPtrs);
     611                            AssertReleaseRC(rc);
     612                        }
     613                    } break;
     614
     615                    default:
     616                    {
     617                        /* This indicates that the guest request memory was corrupted. */
     618                        AssertReleaseMsgFailed(("hgcmCompleted: invalid parameter type %08X\n", pGuestParm->type));
    530619                    }
    531                 } break;
    532 
    533                 default:
    534                 {
    535                     /* This indicates that the guest request memory was corrupted. */
    536                     AssertReleaseMsgFailed(("hgcmCompleted: invalid parameter type %08X\n", pGuestParm->type));
    537620                }
    538621            }
    539622        }
    540     }
    541 
    542     /* Mark request as processed*/
    543     pHeader->fu32Flags |= VBOX_HGCM_REQ_DONE;
    544 
    545     VMMDevNotifyGuest (pVMMDevState, VMMDEV_EVENT_HGCM);
    546 
    547     if (pCmd->paLinPtrs)
    548     {
    549         RTMemFree (pCmd->paLinPtrs);
    550     }
    551        
    552     RTMemFree (pCmd);
     623
     624        /* Mark request as processed*/
     625        pHeader->fu32Flags |= VBOX_HGCM_REQ_DONE;
     626
     627        VMMDevNotifyGuest (pVMMDevState, VMMDEV_EVENT_HGCM);
     628
     629        /* It it assumed that VMMDev saves state after the HGCM services. */
     630        vmmdevHGCMRemoveCommand (pVMMDevState, pCmd);
     631
     632        if (pCmd->paLinPtrs)
     633        {
     634            RTMemFree (pCmd->paLinPtrs);
     635        }
     636       
     637        RTMemFree (pCmd);
     638    }
    553639
    554640    return;
    555641}
     642
     643/* @thread EMT */
     644int vmmdevHGCMSaveState(VMMDevState *pVMMDevState, PSSMHANDLE pSSM)
     645{
     646    /* Save information about pending requests.
     647     * Only GCPtrs are of interest.
     648     */
     649    int rc = VINF_SUCCESS;
     650
     651    LogFlowFunc(("\n"));
     652
     653    /* Compute how many commands are pending. */
     654    uint32_t cCmds = 0;
     655
     656    PVBOXHGCMCMD pIter = pVMMDevState->pHGCMCmdList;
     657
     658    while (pIter)
     659    {
     660        LogFlowFunc (("pIter %p\n", pIter));
     661        cCmds++;
     662        pIter = pIter->pNext;
     663    }
     664
     665    LogFlowFunc(("cCmds = %d\n", cCmds));
     666
     667    /* Save number of commands. */
     668    rc = SSMR3PutU32(pSSM, cCmds);
     669    AssertRCReturn(rc, rc);
     670
     671    if (cCmds > 0)
     672    {
     673        pIter = pVMMDevState->pHGCMCmdList;
     674
     675        while (pIter)
     676        {
     677            PVBOXHGCMCMD pNext = pIter->pNext;
     678
     679            LogFlowFunc (("Saving %VGp\n", pIter->GCPtr));
     680            rc = SSMR3PutGCPtr(pSSM, pIter->GCPtr);
     681            AssertRCReturn(rc, rc);
     682
     683            vmmdevHGCMRemoveCommand (pVMMDevState, pIter);
     684
     685            pIter = pNext;
     686        }
     687    }
     688
     689    return rc;
     690}
     691
     692/* @thread EMT */
     693int vmmdevHGCMLoadState(VMMDevState *pVMMDevState, PSSMHANDLE pSSM)
     694{
     695    int rc = VINF_SUCCESS;
     696
     697    LogFlowFunc(("\n"));
     698
     699    /* Read how many commands were pending. */
     700    uint32_t cCmds = 0;
     701    rc = SSMR3GetU32(pSSM, &cCmds);
     702    AssertRCReturn(rc, rc);
     703
     704    LogFlowFunc(("cCmds = %d\n", cCmds));
     705
     706    while (cCmds--)
     707    {
     708        RTGCPHYS GCPtr;
     709        rc = SSMR3GetGCPtr(pSSM, &GCPtr);
     710        AssertRCReturn(rc, rc);
     711
     712        LogFlowFunc (("Restoring %VGp\n", GCPtr));
     713
     714        PVBOXHGCMCMD pCmd = (PVBOXHGCMCMD)RTMemAllocZ (sizeof (struct VBOXHGCMCMD));
     715        AssertReturn(pCmd, VERR_NO_MEMORY);
     716
     717        vmmdevHGCMAddCommand (pVMMDevState, pCmd, GCPtr);
     718    }
     719
     720    return rc;
     721}
     722
     723/* @thread EMT */
     724int vmmdevHGCMLoadStateDone(VMMDevState *pVMMDevState, PSSMHANDLE pSSM)
     725{
     726    LogFlowFunc(("\n"));
     727
     728    /* Reissue pending requests. */
     729    PPDMDEVINS pDevIns = pVMMDevState->pDevIns;
     730
     731    int rc = vmmdevHGCMCmdListLock (pVMMDevState);
     732
     733    if (VBOX_SUCCESS (rc))
     734    {
     735        PVBOXHGCMCMD pIter = pVMMDevState->pHGCMCmdList;
     736
     737        while (pIter)
     738        {
     739            LogFlowFunc (("pIter %p\n", pIter));
     740
     741            PVBOXHGCMCMD pNext = pIter->pNext;
     742
     743            VMMDevRequestHeader *requestHeader = NULL;
     744            rc = PDMDevHlpPhys2HCVirt(pDevIns, pIter->GCPtr, 0, (PRTHCPTR)&requestHeader);
     745
     746            if (VBOX_FAILURE(rc) || !requestHeader)
     747            {
     748                AssertMsgFailed(("VMMDev::LoadStateDone: could not convert guest physical address to host virtual!!! rc = %Vrc\n", rc));
     749            }
     750            else
     751            {
     752                /* the structure size must be greater or equal to the header size */
     753                if (requestHeader->size < sizeof(VMMDevRequestHeader))
     754                {
     755                    Log(("VMMDev request header size too small! size = %d\n", requestHeader->size));
     756                }
     757                else
     758                {
     759                    /* check the version of the header structure */
     760                    if (requestHeader->version != VMMDEV_REQUEST_HEADER_VERSION)
     761                    {
     762                        Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader->version, VMMDEV_REQUEST_HEADER_VERSION));
     763                    }
     764                    else
     765                    {
     766                        Log(("VMMDev request issued: %d\n", requestHeader->requestType));
     767
     768                        switch (requestHeader->requestType)
     769                        {
     770                            case VMMDevReq_HGCMConnect:
     771                            {
     772                                if (requestHeader->size < sizeof(VMMDevHGCMConnect))
     773                                {
     774                                    AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
     775                                    requestHeader->rc = VERR_INVALID_PARAMETER;
     776                                }
     777                                else if (!pVMMDevState->pHGCMDrv)
     778                                {
     779                                    Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
     780                                    requestHeader->rc = VERR_NOT_SUPPORTED;
     781                                }
     782                                else
     783                                {
     784                                    VMMDevHGCMConnect *pHGCMConnect = (VMMDevHGCMConnect *)requestHeader;
     785
     786                                    Log(("VMMDevReq_HGCMConnect\n"));
     787
     788                                    requestHeader->rc = vmmdevHGCMConnect (pVMMDevState, pHGCMConnect, pIter->GCPtr);
     789                                }
     790                                break;
     791                            }
     792
     793                            case VMMDevReq_HGCMDisconnect:
     794                            {
     795                                if (requestHeader->size < sizeof(VMMDevHGCMDisconnect))
     796                                {
     797                                    AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
     798                                    requestHeader->rc = VERR_INVALID_PARAMETER;
     799                                }
     800                                else if (!pVMMDevState->pHGCMDrv)
     801                                {
     802                                    Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
     803                                    requestHeader->rc = VERR_NOT_SUPPORTED;
     804                                }
     805                                else
     806                                {
     807                                    VMMDevHGCMDisconnect *pHGCMDisconnect = (VMMDevHGCMDisconnect *)requestHeader;
     808
     809                                    Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
     810                                    requestHeader->rc = vmmdevHGCMDisconnect (pVMMDevState, pHGCMDisconnect, pIter->GCPtr);
     811                                }
     812                                break;
     813                            }
     814
     815                            case VMMDevReq_HGCMCall:
     816                            {
     817                                if (requestHeader->size < sizeof(VMMDevHGCMCall))
     818                                {
     819                                    AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
     820                                    requestHeader->rc = VERR_INVALID_PARAMETER;
     821                                }
     822                                else if (!pVMMDevState->pHGCMDrv)
     823                                {
     824                                    Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
     825                                    requestHeader->rc = VERR_NOT_SUPPORTED;
     826                                }
     827                                else
     828                                {
     829                                    VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)requestHeader;
     830
     831                                    Log(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
     832
     833                                    Log(("%.*Vhxd\n", requestHeader->size, requestHeader));
     834
     835                                    requestHeader->rc = vmmdevHGCMCall (pVMMDevState, pHGCMCall, pIter->GCPtr);
     836                                }
     837                                break;
     838                            }
     839                            default:
     840                               AssertReleaseFailed();
     841                        }
     842                    }
     843                }
     844            }
     845
     846            vmmdevHGCMRemoveCommand (pVMMDevState, pIter);
     847            pIter = pNext;
     848        }
     849
     850        vmmdevHGCMCmdListUnlock (pVMMDevState);
     851    }
     852   
     853    return rc;
     854}

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

    r1 r1681  
    3232
    3333__BEGIN_DECLS
    34 DECLCALLBACK(int) vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect);
    35 DECLCALLBACK(int) vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect);
    36 DECLCALLBACK(int) vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall);
     34DECLCALLBACK(int) vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPtr);
     35DECLCALLBACK(int) vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPtr);
     36DECLCALLBACK(int) vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPtr);
    3737
    3838DECLCALLBACK(void) hgcmCompleted (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmdPtr);
     39
     40int vmmdevHGCMSaveState(VMMDevState *pVMMDevState, PSSMHANDLE pSSM);
     41int vmmdevHGCMLoadState(VMMDevState *pVMMDevState, PSSMHANDLE pSSM);
     42int vmmdevHGCMLoadStateDone(VMMDevState *pVMMDevState, PSSMHANDLE pSSM);
    3943__END_DECLS
    4044

  • trunk/src/VBox/Devices/VMMDev/VMMDevState.h

    r1624 r1681  
    2828
    2929#include <VBox/pdm.h>
     30
     31#define TIMESYNC_BACKDOOR
    3032
    3133/** device structure containing all state information */
    … …  
    137139    bool fBackdoorLogDisabled;
    138140
     141#ifdef VBOX_HGCM
     142    /** List of pending HGCM requests, used for saving the HGCM state. */
     143    PVBOXHGCMCMD pHGCMCmdList;
     144    /** Critical section to protect the list. */
     145    RTCRITSECT critsectHGCMCmdList;
     146#endif /* VBOX_HGCM */
     147
    139148} VMMDevState;
    140149
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