VirtualBox

Changeset 60396 in vbox


Ignore:
Timestamp:
Apr 8, 2016 4:17:15 PM (8 years ago)
Author:
vboxsync
Message:

VMMDev,PDM,HM: Changed the VMMDev heap interface a little so HM can init without the fake PCI BIOS code having run.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r60387 r60396  
    6161VMM_INT_DECL(int)       PDMVmmDevHeapR3ToGCPhys(PVM pVM, RTR3PTR pv, RTGCPHYS *pGCPhys);
    6262VMM_INT_DECL(bool)      PDMVmmDevHeapIsEnabled(PVM pVM);
     63
     64/**
     65 * Mapping/unmapping callback for an VMMDev heap allocation.
     66 *
     67 * @param   pVM                 The cross context VM structure.
     68 * @param   pvAllocation        The allocation address (ring-3).
     69 * @param   GCPhysAllocation    The guest physical address of the mapping if
     70 *                              it's being mapped, NIL_RTGCPHYS if it's being
     71 *                              unmapped.
     72 */
     73typedef void FNPDMVMMDEVHEAPNOTIFY(PVM pVM, void *pvAllocation, RTGCPHYS GCPhysAllocation);
     74/** Pointer (ring-3) to a FNPDMVMMDEVHEAPNOTIFY function. */
     75typedef R3PTRTYPE(FNPDMVMMDEVHEAPNOTIFY *) PFNPDMVMMDEVHEAPNOTIFY;
    6376
    6477
    … …  
    157170VMMR3DECL(void)         PDMR3DmaRun(PVM pVM);
    158171VMMR3_INT_DECL(int)     PDMR3LockCall(PVM pVM);
    159 VMMR3_INT_DECL(int)     PDMR3VmmDevHeapRegister(PVM pVM, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize);
    160 VMMR3_INT_DECL(int)     PDMR3VmmDevHeapUnregister(PVM pVM, RTGCPHYS GCPhys);
    161 VMMR3_INT_DECL(int)     PDMR3VmmDevHeapAlloc(PVM pVM, size_t cbSize, RTR3PTR *ppv);
     172
     173VMMR3_INT_DECL(int)     PDMR3VmmDevHeapAlloc(PVM pVM, size_t cbSize, PFNPDMVMMDEVHEAPNOTIFY pfnNotify, RTR3PTR *ppv);
    162174VMMR3_INT_DECL(int)     PDMR3VmmDevHeapFree(PVM pVM, RTR3PTR pv);
    163175VMMR3_INT_DECL(int)     PDMR3TracingConfig(PVM pVM, const char *pszName, size_t cchName, bool fEnable, bool fApply);

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

    r60387 r60396  
    35523552
    35533553    /**
    3554      * Registers the VMM device heap
     3554     * Registers the VMM device heap or notifies about mapping/unmapping.
     3555     *
     3556     * This interface serves three purposes:
     3557     *
     3558     *      -# Register the VMM device heap during device construction
     3559     *         for the HM to use.
     3560     *      -# Notify PDM/HM that it's mapped into guest address
     3561     *         space (i.e. usable).
     3562     *      -# Notify PDM/HM that it is being unmapped from the guest
     3563     *         address space (i.e. not usable).
    35553564     *
    35563565     * @returns VBox status code.
    35573566     * @param   pDevIns             The device instance.
    3558      * @param   GCPhys              The physical address.
     3567     * @param   GCPhys              The physical address if mapped, NIL_RTGCPHYS if
     3568     *                              not mapped.
    35593569     * @param   pvHeap              Ring 3 heap pointer.
    3560      * @param   cbSize              Size of the heap.
     3570     * @param   cbHeap              Size of the heap.
    35613571     * @thread  EMT.
    35623572     */
    3563     DECLR3CALLBACKMEMBER(int, pfnRegisterVMMDevHeap,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize));
    3564 
    3565     /**
    3566      * Unregisters the VMM device heap
     3573    DECLR3CALLBACKMEMBER(int, pfnRegisterVMMDevHeap,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap));
     3574
     3575    /**
     3576     * Unregisters the VMM device heap - OBSOLETE.
     3577     *
     3578     * This entry can be reused.
     3579     * This entry can be reused.
     3580     * This entry can be reused.
    35673581     *
    35683582     * @returns VBox status code.
    … …  
    35703584     * @param   GCPhys              The physical address.
    35713585     * @thread  EMT.
     3586     * @obsolete
    35723587     */
    35733588    DECLR3CALLBACKMEMBER(int, pfnUnregisterVMMDevHeap,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys));
    … …  
    52775292 * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
    52785293 */
    5279 DECLINLINE(int) PDMDevHlpRegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
    5280 {
    5281     return pDevIns->pHlpR3->pfnRegisterVMMDevHeap(pDevIns, GCPhys, pvHeap, cbSize);
    5282 }
    5283 
    5284 /**
    5285  * @copydoc PDMDEVHLPR3::pfnUnregisterVMMDevHeap
    5286  */
    5287 DECLINLINE(int) PDMDevHlpUnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
    5288 {
    5289     return pDevIns->pHlpR3->pfnUnregisterVMMDevHeap(pDevIns, GCPhys);
     5294DECLINLINE(int) PDMDevHlpRegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
     5295{
     5296    return pDevIns->pHlpR3->pfnRegisterVMMDevHeap(pDevIns, GCPhys, pvHeap, cbHeap);
    52905297}
    52915298

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

    r58164 r60396  
    29262926             * It is about to be unmapped, just clean up.
    29272927             */
    2928             PDMDevHlpUnregisterVMMDevHeap(pPciDev->pDevIns, pThis->GCPhysVMMDevHeap);
     2928            PDMDevHlpRegisterVMMDevHeap(pPciDev->pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
    29292929            pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
    29302930            rc = VINF_SUCCESS;
    … …  
    41514151            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    41524152                                       N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
     4153
     4154        /* Register the memory area with PDM so HM can access it before it's mapped. */
     4155        rc = PDMDevHlpRegisterVMMDevHeap(pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
     4156        AssertLogRelRCReturn(rc, rc);
    41534157    }
    41544158

  • trunk/src/VBox/VMM/VMMAll/PDMAll.cpp

    r60382 r60396  
    501501VMM_INT_DECL(int) PDMVmmDevHeapR3ToGCPhys(PVM pVM, RTR3PTR pv, RTGCPHYS *pGCPhys)
    502502{
    503     /* Don't assert here as this is called before we can catch ring-0 assertions. */
    504     if (RT_UNLIKELY((RTR3UINTPTR)pv - (RTR3UINTPTR)pVM->pdm.s.pvVMMDevHeap >= pVM->pdm.s.cbVMMDevHeap))
    505     {
     503    if (RT_LIKELY(pVM->pdm.s.GCPhysVMMDevHeap != NIL_RTGCPHYS))
     504    {
     505        RTR3UINTPTR const offHeap = (RTR3UINTPTR)pv - (RTR3UINTPTR)pVM->pdm.s.pvVMMDevHeap;
     506        if (RT_LIKELY(offHeap < pVM->pdm.s.cbVMMDevHeap))
     507        {
     508            *pGCPhys = pVM->pdm.s.GCPhysVMMDevHeap + offHeap;
     509            return VINF_SUCCESS;
     510        }
     511
     512        /* Don't assert here as this is called before we can catch ring-0 assertions. */
    506513        Log(("PDMVmmDevHeapR3ToGCPhys: pv=%p pvVMMDevHeap=%p cbVMMDevHeap=%#x\n",
    507514             pv, pVM->pdm.s.pvVMMDevHeap, pVM->pdm.s.cbVMMDevHeap));
    508         return VERR_PDM_DEV_HEAP_R3_TO_GCPHYS;
    509     }
    510 
    511     *pGCPhys = (pVM->pdm.s.GCPhysVMMDevHeap + ((RTR3UINTPTR)pv - (RTR3UINTPTR)pVM->pdm.s.pvVMMDevHeap));
    512     return VINF_SUCCESS;
    513 }
     515    }
     516    else
     517        Log(("PDMVmmDevHeapR3ToGCPhys: GCPhysVMMDevHeap=%RGp (pv=%p)\n", pVM->pdm.s.GCPhysVMMDevHeap, pv));
     518    return VERR_PDM_DEV_HEAP_R3_TO_GCPHYS;
     519}
     520
    514521
    515522/**
    … …  
    521528VMM_INT_DECL(bool) PDMVmmDevHeapIsEnabled(PVM pVM)
    522529{
    523     return (pVM->pdm.s.pvVMMDevHeap != NULL);
    524 }
     530    return pVM->pdm.s.GCPhysVMMDevHeap != NIL_RTGCPHYS;
     531}

  • trunk/src/VBox/VMM/VMMR3/HM.cpp

    r60307 r60396  
    11051105
    11061106/**
     1107 * @callback_method_impl{FNPDMVMMDEVHEAPNOTIFY}
     1108 */
     1109static DECLCALLBACK(void) hmR3VmmDevHeapNotify(PVM pVM, void *pvAllocation,  RTGCPHYS GCPhysAllocation)
     1110{
     1111    NOREF(pVM);
     1112    NOREF(pvAllocation);
     1113    NOREF(GCPhysAllocation);
     1114}
     1115
     1116
     1117/**
    11071118 * Finish VT-x initialization (after ring-0 init).
    11081119 *
    … …  
    13361347    {
    13371348        /* Allocate three pages for the TSS we need for real mode emulation. (2 pages for the IO bitmap) */
    1338         rc = PDMR3VmmDevHeapAlloc(pVM, HM_VTX_TOTAL_DEVHEAP_MEM, (RTR3PTR *)&pVM->hm.s.vmx.pRealModeTSS);
     1349        rc = PDMR3VmmDevHeapAlloc(pVM, HM_VTX_TOTAL_DEVHEAP_MEM, hmR3VmmDevHeapNotify, (RTR3PTR *)&pVM->hm.s.vmx.pRealModeTSS);
    13391350        if (RT_SUCCESS(rc))
    13401351        {
    … …  
    13711382
    13721383            /* We convert it here every time as pci regions could be reconfigured. */
    1373             rc = PDMVmmDevHeapR3ToGCPhys(pVM, pVM->hm.s.vmx.pRealModeTSS, &GCPhys);
    1374             AssertRCReturn(rc, rc);
    1375             LogRel(("HM: Real Mode TSS guest physaddr    = %#RGp\n", GCPhys));
    1376 
    1377             rc = PDMVmmDevHeapR3ToGCPhys(pVM, pVM->hm.s.vmx.pNonPagingModeEPTPageTable, &GCPhys);
    1378             AssertRCReturn(rc, rc);
    1379             LogRel(("HM: Non-Paging Mode EPT CR3         = %#RGp\n", GCPhys));
     1384            if (PDMVmmDevHeapIsEnabled(pVM))
     1385            {
     1386                rc = PDMVmmDevHeapR3ToGCPhys(pVM, pVM->hm.s.vmx.pRealModeTSS, &GCPhys);
     1387                AssertRCReturn(rc, rc);
     1388                LogRel(("HM: Real Mode TSS guest physaddr    = %#RGp\n", GCPhys));
     1389
     1390                rc = PDMVmmDevHeapR3ToGCPhys(pVM, pVM->hm.s.vmx.pNonPagingModeEPTPageTable, &GCPhys);
     1391                AssertRCReturn(rc, rc);
     1392                LogRel(("HM: Non-Paging Mode EPT CR3         = %#RGp\n", GCPhys));
     1393            }
    13801394        }
    13811395        else

  • trunk/src/VBox/VMM/VMMR3/PDM.cpp

    r60387 r60396  
    24522452
    24532453/**
    2454  * Registers the VMM device heap
    2455  *
    2456  * @returns VBox status code.
    2457  * @param   pVM             The cross context VM structure.
    2458  * @param   GCPhys          The physical address.
    2459  * @param   pvHeap          Ring-3 pointer.
    2460  * @param   cbSize          Size of the heap.
    2461  */
    2462 VMMR3_INT_DECL(int) PDMR3VmmDevHeapRegister(PVM pVM, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
    2463 {
    2464     Assert(pVM->pdm.s.pvVMMDevHeap == NULL);
    2465 
    2466     Log(("PDMR3VmmDevHeapRegister %RGp %RHv %x\n", GCPhys, pvHeap, cbSize));
    2467     pVM->pdm.s.pvVMMDevHeap     = pvHeap;
    2468     pVM->pdm.s.GCPhysVMMDevHeap = GCPhys;
    2469     pVM->pdm.s.cbVMMDevHeap     = cbSize;
    2470     pVM->pdm.s.cbVMMDevHeapLeft = cbSize;
    2471     return VINF_SUCCESS;
    2472 }
    2473 
    2474 
    2475 /**
    2476  * Unregisters the VMM device heap
    2477  *
    2478  * @returns VBox status code.
    2479  * @param   pVM             The cross context VM structure.
    2480  * @param   GCPhys          The physical address.
    2481  */
    2482 VMMR3_INT_DECL(int) PDMR3VmmDevHeapUnregister(PVM pVM, RTGCPHYS GCPhys)
    2483 {
    2484     Assert(pVM->pdm.s.GCPhysVMMDevHeap == GCPhys);
    2485 
    2486     Log(("PDMR3VmmDevHeapUnregister %RGp\n", GCPhys));
    2487     pVM->pdm.s.pvVMMDevHeap     = NULL;
    2488     pVM->pdm.s.GCPhysVMMDevHeap = NIL_RTGCPHYS;
    2489     pVM->pdm.s.cbVMMDevHeap     = 0;
    2490     pVM->pdm.s.cbVMMDevHeapLeft = 0;
    2491     return VINF_SUCCESS;
    2492 }
    2493 
    2494 
    2495 /**
    2496  * Allocates memory from the VMM device heap
     2454 * Allocates memory from the VMM device heap.
    24972455 *
    24982456 * @returns VBox status code.
    24992457 * @param   pVM             The cross context VM structure.
    25002458 * @param   cbSize          Allocation size.
     2459 * @param   pfnNotify       Mapping/unmapping notification callback.
    25012460 * @param   ppv             Ring-3 pointer. (out)
    25022461 */
    2503 VMMR3_INT_DECL(int) PDMR3VmmDevHeapAlloc(PVM pVM, size_t cbSize, RTR3PTR *ppv)
     2462VMMR3_INT_DECL(int) PDMR3VmmDevHeapAlloc(PVM pVM, size_t cbSize, PFNPDMVMMDEVHEAPNOTIFY pfnNotify, RTR3PTR *ppv)
    25042463{
    25052464#ifdef DEBUG_bird
    … …  
    25152474    *ppv = pVM->pdm.s.pvVMMDevHeap;
    25162475    pVM->pdm.s.cbVMMDevHeapLeft = 0;
     2476    pVM->pdm.s.pfnVMMDevHeapNotify = pfnNotify;
    25172477    return VINF_SUCCESS;
    25182478}
    … …  
    25322492    /** @todo not a real heap as there's currently only one user. */
    25332493    pVM->pdm.s.cbVMMDevHeapLeft = pVM->pdm.s.cbVMMDevHeap;
     2494    pVM->pdm.s.pfnVMMDevHeapNotify = NULL;
    25342495    return VINF_SUCCESS;
    25352496}

  • trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp

    r60381 r60396  
    32723272 * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
    32733273 */
    3274 static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
    3275 {
    3276     PDMDEV_ASSERT_DEVINS(pDevIns);
    3277     VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    3278 
    3279     int rc = PDMR3VmmDevHeapRegister(pDevIns->Internal.s.pVMR3, GCPhys, pvHeap, cbSize);
    3280     return rc;
     3274static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
     3275{
     3276    PDMDEV_ASSERT_DEVINS(pDevIns);
     3277    PVM pVM = pDevIns->Internal.s.pVMR3;
     3278    VM_ASSERT_EMT(pVM);
     3279    LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
     3280             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
     3281
     3282    if (pVM->pdm.s.pvVMMDevHeap == NULL)
     3283    {
     3284        pVM->pdm.s.pvVMMDevHeap     = pvHeap;
     3285        pVM->pdm.s.GCPhysVMMDevHeap = GCPhys;
     3286        pVM->pdm.s.cbVMMDevHeap     = cbHeap;
     3287        pVM->pdm.s.cbVMMDevHeapLeft = cbHeap;
     3288    }
     3289    else
     3290    {
     3291        Assert(pVM->pdm.s.pvVMMDevHeap == pvHeap);
     3292        Assert(pVM->pdm.s.cbVMMDevHeap == cbHeap);
     3293        Assert(pVM->pdm.s.GCPhysVMMDevHeap != GCPhys || GCPhys == NIL_RTGCPHYS);
     3294        if (pVM->pdm.s.GCPhysVMMDevHeap != GCPhys)
     3295        {
     3296            pVM->pdm.s.GCPhysVMMDevHeap = GCPhys;
     3297            if (pVM->pdm.s.pfnVMMDevHeapNotify)
     3298                pVM->pdm.s.pfnVMMDevHeapNotify(pVM, pvHeap, GCPhys);
     3299        }
     3300    }
     3301
     3302    LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
     3303             pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
     3304    return VINF_SUCCESS;
    32813305}
    32823306
    … …  
    32873311static DECLCALLBACK(int) pdmR3DevHlp_UnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
    32883312{
    3289     PDMDEV_ASSERT_DEVINS(pDevIns);
    3290     VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    3291 
    3292     int rc = PDMR3VmmDevHeapUnregister(pDevIns->Internal.s.pVMR3, GCPhys);
    3293     return rc;
     3313    /* Free to replace this interface. */
     3314    AssertFailedReturn(VERR_NOT_IMPLEMENTED);
    32943315}
    32953316

  • trunk/src/VBox/VMM/include/PDMInternal.h

    r60387 r60396  
    11411141    /** The current mapping. NIL_RTGCPHYS if not mapped or registered. */
    11421142    RTGCPHYS                        GCPhysVMMDevHeap;
     1143    /** Ring-3 mapping/unmapping notification callback for the user. */
     1144    PFNPDMVMMDEVHEAPNOTIFY          pfnVMMDevHeapNotify;
    11431145    /** @} */
    11441146
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