VirtualBox

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


Ignore:
Timestamp:
Feb 21, 2013 1:32:50 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
83890
Message:

Sad Dijstra => Happy Dijstra.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r44774 r44778  
    21872187
    21882188
    2189 /**
    2190  * @callback_method_impl{FNIOMIOPORTOUT, Port I/O Handler for the generic
    2191  *                      request interface.}
    2192  */
    2193 static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    2194 {
    2195     PVMMDEV pThis = (VMMDevState*)pvUser;
     2189static int vmmdevReqDispatcher(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
     2190{
    21962191    int rcRet = VINF_SUCCESS;
    2197     PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    2198 
    2199     /*
    2200      * The caller has passed the guest context physical address
    2201      * of the request structure. Copy the request packet.
    2202      */
    2203     VMMDevRequestHeader *pRequestHeader = NULL;
    2204     VMMDevRequestHeader requestHeader;
    2205     RT_ZERO(requestHeader);
    2206 
    2207     PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
    2208 
    2209     /* the structure size must be greater or equal to the header size */
    2210     if (requestHeader.size < sizeof(VMMDevRequestHeader))
    2211     {
    2212         Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
    2213         rcRet = VINF_SUCCESS;
    2214         goto l_end; /** @todo shouldn't (/ no need to) write back.*/
    2215     }
    2216 
    2217     /* check the version of the header structure */
    2218     if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
    2219     {
    2220         Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
    2221         rcRet = VINF_SUCCESS;
    2222         goto l_end; /** @todo shouldn't (/ no need to) write back.*/
    2223     }
    2224 
    2225     Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
    2226 
    2227     /* Newer additions starts with VMMDevReq_ReportGuestInfo2, older additions
    2228        started with VMMDevReq_ReportGuestInfo. */
    2229     if (   !pThis->fu32AdditionsOk
    2230         && requestHeader.requestType != VMMDevReq_ReportGuestInfo2
    2231         && requestHeader.requestType != VMMDevReq_ReportGuestInfo
    2232         && requestHeader.requestType != VMMDevReq_WriteCoreDump
    2233         && requestHeader.requestType != VMMDevReq_GetHostVersion) /* Always allow the guest to query the host capabilities. */
    2234     {
    2235         Log(("VMMDev: guest has not yet reported to us. Refusing operation of request #%d!\n",
    2236              requestHeader.requestType));
    2237         requestHeader.rc = VERR_NOT_SUPPORTED;
    2238         static int cRelWarn;
    2239         if (cRelWarn < 10)
    2240         {
    2241             cRelWarn++;
    2242             LogRel(("VMMDev: the guest has not yet reported to us -- refusing operation of request #%d\n",
    2243                     requestHeader.requestType));
    2244         }
    2245         rcRet = VINF_SUCCESS;
    2246         goto l_end;
    2247     }
    2248 
    2249     /* Check upper limit */
    2250     if (requestHeader.size > VMMDEV_MAX_VMMDEVREQ_SIZE)
    2251     {
    2252         static int cRelWarn;
    2253         if (cRelWarn < 50)
    2254         {
    2255             cRelWarn++;
    2256             LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
    2257         }
    2258         requestHeader.rc = VERR_NOT_SUPPORTED;
    2259         rcRet = VINF_SUCCESS;
    2260         goto l_end;
    2261     }
    2262 
    2263     /* Read the entire request packet */
    2264     pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
    2265     if (!pRequestHeader)
    2266     {
    2267         Log(("VMMDev: RTMemAlloc failed!\n"));
    2268         rcRet = VINF_SUCCESS;
    2269         requestHeader.rc = VERR_NO_MEMORY;
    2270         goto l_end;
    2271     }
    2272     PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
    2273 
    2274     /* which request was sent? */
    2275     switch (pRequestHeader->requestType)
     2192
     2193    switch (pReqHdr->requestType)
    22762194    {
    22772195        case VMMDevReq_ReportGuestInfo:
    2278             pRequestHeader->rc = vmmdevReqHandler_ReportGuestInfo(pThis, pRequestHeader);
     2196            pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo(pThis, pReqHdr);
    22792197            break;
    22802198
    22812199        case VMMDevReq_ReportGuestInfo2:
    2282             pRequestHeader->rc = vmmdevReqHandler_ReportGuestInfo2(pThis, pRequestHeader);
     2200            pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo2(pThis, pReqHdr);
    22832201            break;
    22842202
    22852203        case VMMDevReq_ReportGuestStatus:
    2286             pRequestHeader->rc = vmmdevReqHandler_ReportGuestStatus(pThis, pRequestHeader);
     2204            pReqHdr->rc = vmmdevReqHandler_ReportGuestStatus(pThis, pReqHdr);
    22872205            break;
    22882206
    22892207        case VMMDevReq_ReportGuestCapabilities:
    2290             pRequestHeader->rc = vmmdevReqHandler_ReportGuestCapabilities(pThis, pRequestHeader);
     2208            pReqHdr->rc = vmmdevReqHandler_ReportGuestCapabilities(pThis, pReqHdr);
    22912209            break;
    22922210
    22932211        case VMMDevReq_SetGuestCapabilities:
    2294             pRequestHeader->rc = vmmdevReqHandler_SetGuestCapabilities(pThis, pRequestHeader);
     2212            pReqHdr->rc = vmmdevReqHandler_SetGuestCapabilities(pThis, pReqHdr);
    22952213            break;
    22962214
    22972215        case VMMDevReq_WriteCoreDump:
    2298             pRequestHeader->rc = vmmdevReqHandler_WriteCoreDump(pThis, pRequestHeader);
     2216            pReqHdr->rc = vmmdevReqHandler_WriteCoreDump(pThis, pReqHdr);
    22992217            break;
    23002218
    23012219        case VMMDevReq_GetMouseStatus:
    2302             pRequestHeader->rc = vmmdevReqHandler_GetMouseStatus(pThis, pRequestHeader);
     2220            pReqHdr->rc = vmmdevReqHandler_GetMouseStatus(pThis, pReqHdr);
    23032221            break;
    23042222
    23052223        case VMMDevReq_SetMouseStatus:
    2306             pRequestHeader->rc = vmmdevReqHandler_SetMouseStatus(pThis, pRequestHeader);
     2224            pReqHdr->rc = vmmdevReqHandler_SetMouseStatus(pThis, pReqHdr);
    23072225            break;
    23082226
    23092227        case VMMDevReq_SetPointerShape:
    2310             pRequestHeader->rc = vmmdevReqHandler_SetPointerShape(pThis, pRequestHeader);
     2228            pReqHdr->rc = vmmdevReqHandler_SetPointerShape(pThis, pReqHdr);
    23112229            break;
    23122230
    23132231        case VMMDevReq_GetHostTime:
    2314             pRequestHeader->rc = vmmdevReqHandler_GetHostTime(pThis, pRequestHeader);
     2232            pReqHdr->rc = vmmdevReqHandler_GetHostTime(pThis, pReqHdr);
    23152233            break;
    23162234
    23172235        case VMMDevReq_GetHypervisorInfo:
    2318             pRequestHeader->rc = vmmdevReqHandler_GetHypervisorInfo(pThis, pRequestHeader);
     2236            pReqHdr->rc = vmmdevReqHandler_GetHypervisorInfo(pThis, pReqHdr);
    23192237            break;
    23202238
    23212239        case VMMDevReq_SetHypervisorInfo:
    2322             pRequestHeader->rc = vmmdevReqHandler_SetHypervisorInfo(pThis, pRequestHeader);
     2240            pReqHdr->rc = vmmdevReqHandler_SetHypervisorInfo(pThis, pReqHdr);
    23232241            break;
    23242242
    23252243        case VMMDevReq_RegisterPatchMemory:
    2326             pRequestHeader->rc = vmmdevReqHandler_RegisterPatchMemory(pThis, pRequestHeader);
     2244            pReqHdr->rc = vmmdevReqHandler_RegisterPatchMemory(pThis, pReqHdr);
    23272245            break;
    23282246
    23292247        case VMMDevReq_DeregisterPatchMemory:
    2330             pRequestHeader->rc = vmmdevReqHandler_DeregisterPatchMemory(pThis, pRequestHeader);
     2248            pReqHdr->rc = vmmdevReqHandler_DeregisterPatchMemory(pThis, pReqHdr);
    23312249            break;
    23322250
    23332251        case VMMDevReq_SetPowerStatus:
    23342252        {
    2335             int rc = pRequestHeader->rc = vmmdevReqHandler_SetPowerStatus(pThis, pRequestHeader);
     2253            int rc = pReqHdr->rc = vmmdevReqHandler_SetPowerStatus(pThis, pReqHdr);
    23362254            if (rc != VINF_SUCCESS && RT_SUCCESS(rc))
    23372255                rcRet = rc;
    … …  
    23402258
    23412259        case VMMDevReq_GetDisplayChangeRequest:
    2342             pRequestHeader->rc = vmmdevReqHandler_GetDisplayChangeRequest(pThis, pRequestHeader);
     2260            pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest(pThis, pReqHdr);
    23432261            break;
    23442262
    23452263        case VMMDevReq_GetDisplayChangeRequest2:
    2346             pRequestHeader->rc = vmmdevReqHandler_GetDisplayChangeRequest2(pThis, pRequestHeader);
     2264            pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest2(pThis, pReqHdr);
    23472265            break;
    23482266
    23492267        case VMMDevReq_GetDisplayChangeRequestEx:
    2350             pRequestHeader->rc = vmmdevReqHandler_GetDisplayChangeRequestEx(pThis, pRequestHeader);
     2268            pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequestEx(pThis, pReqHdr);
    23512269            break;
    23522270
    23532271        case VMMDevReq_VideoModeSupported:
    2354             pRequestHeader->rc = vmmdevReqHandler_VideoModeSupported(pThis, pRequestHeader);
     2272            pReqHdr->rc = vmmdevReqHandler_VideoModeSupported(pThis, pReqHdr);
    23552273            break;
    23562274
    23572275        case VMMDevReq_VideoModeSupported2:
    2358             pRequestHeader->rc = vmmdevReqHandler_VideoModeSupported2(pThis, pRequestHeader);
     2276            pReqHdr->rc = vmmdevReqHandler_VideoModeSupported2(pThis, pReqHdr);
    23592277            break;
    23602278
    23612279        case VMMDevReq_GetHeightReduction:
    2362             pRequestHeader->rc = vmmdevReqHandler_GetHeightReduction(pThis, pRequestHeader);
     2280            pReqHdr->rc = vmmdevReqHandler_GetHeightReduction(pThis, pReqHdr);
    23632281            break;
    23642282
    23652283        case VMMDevReq_AcknowledgeEvents:
    2366             pRequestHeader->rc = vmmdevReqHandler_AcknowledgeEvents(pThis, pRequestHeader);
     2284            pReqHdr->rc = vmmdevReqHandler_AcknowledgeEvents(pThis, pReqHdr);
    23672285            break;
    23682286
    23692287        case VMMDevReq_CtlGuestFilterMask:
    2370             pRequestHeader->rc = vmmdevReqHandler_CtlGuestFilterMask(pThis, pRequestHeader);
     2288            pReqHdr->rc = vmmdevReqHandler_CtlGuestFilterMask(pThis, pReqHdr);
    23712289            break;
    23722290
    23732291#ifdef VBOX_WITH_HGCM
    23742292        case VMMDevReq_HGCMConnect:
    2375             pRequestHeader->rc = vmmdevReqHandler_HGCMConnect(pThis, pRequestHeader, u32);
     2293            pReqHdr->rc = vmmdevReqHandler_HGCMConnect(pThis, pReqHdr, GCPhysReqHdr);
    23762294            break;
    23772295
    23782296        case VMMDevReq_HGCMDisconnect:
    2379             pRequestHeader->rc = vmmdevReqHandler_HGCMDisconnect(pThis, pRequestHeader, u32);
     2297            pReqHdr->rc = vmmdevReqHandler_HGCMDisconnect(pThis, pReqHdr, GCPhysReqHdr);
    23802298            break;
    23812299
    … …  
    23862304        case VMMDevReq_HGCMCall:
    23872305# endif /* VBOX_WITH_64_BITS_GUESTS */
    2388             pRequestHeader->rc = vmmdevReqHandler_HGCMCall(pThis, pRequestHeader, u32);
     2306            pReqHdr->rc = vmmdevReqHandler_HGCMCall(pThis, pReqHdr, GCPhysReqHdr);
    23892307            break;
    23902308#endif /* VBOX_WITH_HGCM */
    23912309
    23922310        case VMMDevReq_HGCMCancel:
    2393             pRequestHeader->rc = vmmdevReqHandler_HGCMCancel(pThis, pRequestHeader, u32);
     2311            pReqHdr->rc = vmmdevReqHandler_HGCMCancel(pThis, pReqHdr, GCPhysReqHdr);
    23942312            break;
    23952313
    23962314        case VMMDevReq_HGCMCancel2:
    2397             pRequestHeader->rc = vmmdevReqHandler_HGCMCancel2(pThis, pRequestHeader);
     2315            pReqHdr->rc = vmmdevReqHandler_HGCMCancel2(pThis, pReqHdr);
    23982316            break;
    23992317
    24002318        case VMMDevReq_VideoAccelEnable:
    2401             pRequestHeader->rc = vmmdevReqHandler_VideoAccelEnable(pThis, pRequestHeader);
     2319            pReqHdr->rc = vmmdevReqHandler_VideoAccelEnable(pThis, pReqHdr);
    24022320            break;
    24032321
    24042322        case VMMDevReq_VideoAccelFlush:
    2405             pRequestHeader->rc = vmmdevReqHandler_VideoAccelFlush(pThis, pRequestHeader);
     2323            pReqHdr->rc = vmmdevReqHandler_VideoAccelFlush(pThis, pReqHdr);
    24062324            break;
    24072325
    24082326        case VMMDevReq_VideoSetVisibleRegion:
    2409             pRequestHeader->rc = vmmdevReqHandler_VideoSetVisibleRegion(pThis, pRequestHeader);
     2327            pReqHdr->rc = vmmdevReqHandler_VideoSetVisibleRegion(pThis, pReqHdr);
    24102328            break;
    24112329
    24122330        case VMMDevReq_GetSeamlessChangeRequest:
    2413             pRequestHeader->rc = vmmdevReqHandler_GetSeamlessChangeRequest(pThis, pRequestHeader);
     2331            pReqHdr->rc = vmmdevReqHandler_GetSeamlessChangeRequest(pThis, pReqHdr);
    24142332            break;
    24152333
    24162334        case VMMDevReq_GetVRDPChangeRequest:
    2417             pRequestHeader->rc = vmmdevReqHandler_GetVRDPChangeRequest(pThis, pRequestHeader);
     2335            pReqHdr->rc = vmmdevReqHandler_GetVRDPChangeRequest(pThis, pReqHdr);
    24182336            break;
    24192337
    24202338        case VMMDevReq_GetMemBalloonChangeRequest:
    2421             pRequestHeader->rc = vmmdevReqHandler_GetMemBalloonChangeRequest(pThis, pRequestHeader);
     2339            pReqHdr->rc = vmmdevReqHandler_GetMemBalloonChangeRequest(pThis, pReqHdr);
    24222340            break;
    24232341
    24242342        case VMMDevReq_ChangeMemBalloon:
    2425             pRequestHeader->rc = vmmdevReqHandler_ChangeMemBalloon(pThis, pRequestHeader);
     2343            pReqHdr->rc = vmmdevReqHandler_ChangeMemBalloon(pThis, pReqHdr);
    24262344            break;
    24272345
    24282346        case VMMDevReq_GetStatisticsChangeRequest:
    2429             pRequestHeader->rc = vmmdevReqHandler_GetStatisticsChangeRequest(pThis, pRequestHeader);
     2347            pReqHdr->rc = vmmdevReqHandler_GetStatisticsChangeRequest(pThis, pReqHdr);
    24302348            break;
    24312349
    24322350        case VMMDevReq_ReportGuestStats:
    2433             pRequestHeader->rc = vmmdevReqHandler_ReportGuestStats(pThis, pRequestHeader);
     2351            pReqHdr->rc = vmmdevReqHandler_ReportGuestStats(pThis, pReqHdr);
    24342352            break;
    24352353
    24362354        case VMMDevReq_QueryCredentials:
    2437             pRequestHeader->rc = vmmdevReqHandler_QueryCredentials(pThis, pRequestHeader);
     2355            pReqHdr->rc = vmmdevReqHandler_QueryCredentials(pThis, pReqHdr);
    24382356            break;
    24392357
    24402358        case VMMDevReq_ReportCredentialsJudgement:
    2441             pRequestHeader->rc = vmmdevReqHandler_ReportCredentialsJudgement(pThis, pRequestHeader);
     2359            pReqHdr->rc = vmmdevReqHandler_ReportCredentialsJudgement(pThis, pReqHdr);
    24422360            break;
    24432361
    24442362        case VMMDevReq_GetHostVersion:
    2445             pRequestHeader->rc = vmmdevReqHandler_GetHostVersion(pThis, pRequestHeader);
     2363            pReqHdr->rc = vmmdevReqHandler_GetHostVersion(pThis, pReqHdr);
    24462364            break;
    24472365
    24482366        case VMMDevReq_GetCpuHotPlugRequest:
    2449             pRequestHeader->rc = vmmdevReqHandler_GetCpuHotPlugRequest(pThis, pRequestHeader);
     2367            pReqHdr->rc = vmmdevReqHandler_GetCpuHotPlugRequest(pThis, pReqHdr);
    24502368            break;
    24512369
    24522370        case VMMDevReq_SetCpuHotPlugStatus:
    2453             pRequestHeader->rc = vmmdevReqHandler_SetCpuHotPlugStatus(pThis, pRequestHeader);
     2371            pReqHdr->rc = vmmdevReqHandler_SetCpuHotPlugStatus(pThis, pReqHdr);
    24542372            break;
    24552373
    24562374#ifdef VBOX_WITH_PAGE_SHARING
    24572375        case VMMDevReq_RegisterSharedModule:
    2458             pRequestHeader->rc = vmmdevReqHandler_RegisterSharedModule(pDevIns, pRequestHeader);
     2376            pReqHdr->rc = vmmdevReqHandler_RegisterSharedModule(pDevIns, pReqHdr);
    24592377            break;
    24602378
    24612379        case VMMDevReq_UnregisterSharedModule:
    2462             pRequestHeader->rc = vmmdevReqHandler_UnregisterSharedModule(pDevIns, pRequestHeader);
     2380            pReqHdr->rc = vmmdevReqHandler_UnregisterSharedModule(pDevIns, pReqHdr);
    24632381            break;
    24642382
    24652383        case VMMDevReq_CheckSharedModules:
    2466             pRequestHeader->rc = vmmdevReqHandler_CheckSharedModules(pDevIns, pRequestHeader);
     2384            pReqHdr->rc = vmmdevReqHandler_CheckSharedModules(pDevIns, pReqHdr);
    24672385            break;
    24682386
    24692387        case VMMDevReq_GetPageSharingStatus:
    2470             pRequestHeader->rc = vmmdevReqHandler_GetPageSharingStatus(pThis, pRequestHeader);
     2388            pReqHdr->rc = vmmdevReqHandler_GetPageSharingStatus(pThis, pReqHdr);
    24712389            break;
    24722390
    24732391        case VMMDevReq_DebugIsPageShared:
    2474             pRequestHeader->rc = vmmdevReqHandler_DebugIsPageShared(pDevIns, pRequestHeader);
     2392            pReqHdr->rc = vmmdevReqHandler_DebugIsPageShared(pDevIns, pReqHdr);
    24752393            break;
    24762394
    … …  
    24792397#ifdef DEBUG
    24802398        case VMMDevReq_LogString:
    2481             pRequestHeader->rc = vmmdevReqHandler_LogString(pThis, pRequestHeader);
     2399            pReqHdr->rc = vmmdevReqHandler_LogString(pThis, pReqHdr);
    24822400            break;
    24832401#endif
    24842402
    24852403        case VMMDevReq_GetSessionId:
    2486             pRequestHeader->rc = vmmdevReqHandler_GetSessionId(pThis, pRequestHeader);
     2404            pReqHdr->rc = vmmdevReqHandler_GetSessionId(pThis, pReqHdr);
    24872405            break;
    24882406
    24892407        /*
    2490          * Guest wants to give up a timeslice
    2491          * Note! this was only ever used by experimental GAs!
     2408         * Guest wants to give up a timeslice.
     2409         * Note! This was only ever used by experimental GAs!
    24922410         */
    24932411        /** @todo maybe we could just remove this? */
    … …  
    25012419        default:
    25022420        {
    2503             pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
    2504             Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
     2421            pReqHdr->rc = VERR_NOT_IMPLEMENTED;
     2422            Log(("VMMDev unknown request type %d\n", pReqHdr->requestType));
    25052423            break;
    25062424        }
    25072425    }
    2508 
    2509 l_end:
    2510     /* Write the result back to guest memory */
     2426    return rcRet;
     2427}
     2428
     2429
     2430/**
     2431 * @callback_method_impl{FNIOMIOPORTOUT, Port I/O Handler for the generic
     2432 *                      request interface.}
     2433 */
     2434static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
     2435{
     2436    PVMMDEV pThis = (VMMDevState*)pvUser;
     2437
     2438    /*
     2439     * The caller has passed the guest context physical address of the request
     2440     * structure. Copy the request packet.
     2441     */
     2442    VMMDevRequestHeader requestHeader;
     2443    RT_ZERO(requestHeader);
     2444    PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
     2445
     2446    /* the structure size must be greater or equal to the header size */
     2447    if (requestHeader.size < sizeof(VMMDevRequestHeader))
     2448    {
     2449        Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
     2450        return VINF_SUCCESS;
     2451    }
     2452
     2453    /* check the version of the header structure */
     2454    if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
     2455    {
     2456        Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
     2457        return VINF_SUCCESS;
     2458    }
     2459
     2460    Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
     2461
     2462    int                  rcRet          = VINF_SUCCESS;
     2463    VMMDevRequestHeader *pRequestHeader = NULL;
     2464
     2465    if (requestHeader.size <= VMMDEV_MAX_VMMDEVREQ_SIZE)
     2466    {
     2467        PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED); /** @todo could probably move this to after the 2nd memory read, maybe after fu32AdditionsOk making volatile, if feeling paranoid. */
     2468
     2469        /* Newer additions starts with VMMDevReq_ReportGuestInfo2, older additions
     2470           started with VMMDevReq_ReportGuestInfo. */
     2471        if (   pThis->fu32AdditionsOk
     2472            || requestHeader.requestType == VMMDevReq_ReportGuestInfo2
     2473            || requestHeader.requestType == VMMDevReq_ReportGuestInfo
     2474            || requestHeader.requestType == VMMDevReq_WriteCoreDump
     2475            || requestHeader.requestType == VMMDevReq_GetHostVersion) /* Always allow the guest to query the host capabilities. */
     2476        {
     2477            /*
     2478             * Read the entire request packet and feed it to the dispatcher function.
     2479             */
     2480            pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
     2481            if (pRequestHeader)
     2482            {
     2483                PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
     2484
     2485                rcRet = vmmdevReqDispatcher(pThis, pRequestHeader, u32);
     2486            }
     2487            else
     2488            {
     2489                Log(("VMMDev: RTMemAlloc failed!\n"));
     2490                requestHeader.rc = VERR_NO_MEMORY;
     2491            }
     2492        }
     2493        else
     2494        {
     2495            static int s_cRelWarn;
     2496            if (s_cRelWarn < 10)
     2497            {
     2498                s_cRelWarn++;
     2499                LogRel(("VMMDev: the guest has not yet reported to us -- refusing operation of request #%d\n",
     2500                        requestHeader.requestType));
     2501            }
     2502            requestHeader.rc = VERR_NOT_SUPPORTED;
     2503        }
     2504
     2505        PDMCritSectLeave(&pThis->CritSect);
     2506    }
     2507    else
     2508    {
     2509        static int s_cRelWarn;
     2510        if (s_cRelWarn < 50)
     2511        {
     2512            s_cRelWarn++;
     2513            LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
     2514        }
     2515        requestHeader.rc = VERR_NOT_SUPPORTED;
     2516    }
     2517
     2518    /*
     2519     * Write the result back to guest memory
     2520     */
    25112521    if (pRequestHeader)
    25122522    {
    2513         PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
     2523        PDMDevHlpPhysWrite(pDevIns, u32, pRequestHeader, pRequestHeader->size);
    25142524        RTMemFree(pRequestHeader);
    25152525    }
    … …  
    25172527    {
    25182528        /* early error case; write back header only */
    2519         PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
    2520     }
    2521 
    2522     PDMCritSectLeave(&pThis->CritSect);
     2529        PDMDevHlpPhysWrite(pDevIns, u32, &requestHeader, sizeof(requestHeader));
     2530    }
     2531
    25232532    return rcRet;
    25242533}
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