VirtualBox

Changeset 91897 in vbox


Ignore:
Timestamp:
Oct 20, 2021 1:42:39 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
147701
Message:

VMM,Devices: Add callbacks to required MMR3* APIs to the helper callbacks tables and convert devices and drivers to make use of those, bugref:10074

Location:
trunk
Files:
33 edited

Legend:

Unmodified
Added
Removed

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

    r91000 r91897  
    4242#include <VBox/vmm/pdmpcidev.h>
    4343#include <VBox/vmm/iom.h>
     44#include <VBox/vmm/mm.h>
    4445#include <VBox/vmm/tm.h>
    4546#include <VBox/vmm/ssm.h>
    … …  
    24232424
    24242425/** Current PDMDEVHLPR3 version number. */
    2425 #define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 49, 1)
     2426#define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 50, 1)
    24262427
    24272428/**
    … …  
    31483149
    31493150    /**
     3151     * Allocating string printf.
     3152     *
     3153     * @returns Pointer to the string.
     3154     * @param   pDevIns             The device instance.
     3155     * @param   enmTag              The statistics tag.
     3156     * @param   pszFormat           The format string.
     3157     * @param   va                  Format arguments.
     3158     */
     3159    DECLR3CALLBACKMEMBER(char *, pfnMMHeapAPrintfV,(PPDMDEVINS pDevIns, MMTAG enmTag, const char *pszFormat, va_list va));
     3160
     3161    /**
    31503162     * Free memory allocated with pfnMMHeapAlloc() and pfnMMHeapAllocZ().
    31513163     *
    … …  
    31543166     */
    31553167    DECLR3CALLBACKMEMBER(void, pfnMMHeapFree,(PPDMDEVINS pDevIns, void *pv));
     3168
     3169    /**
     3170     * Returns the physical RAM size of the VM.
     3171     *
     3172     * @returns RAM size in bytes.
     3173     * @param   pDevIns             The device instance.
     3174     */
     3175    DECLR3CALLBACKMEMBER(uint64_t, pfnMMPhysGetRamSize,(PPDMDEVINS pDevIns));
     3176
     3177    /**
     3178     * Returns the physical RAM size of the VM below the 4GB boundary.
     3179     *
     3180     * @returns RAM size in bytes.
     3181     * @param   pDevIns             The device instance.
     3182     */
     3183    DECLR3CALLBACKMEMBER(uint32_t, pfnMMPhysGetRamSizeBelow4GB,(PPDMDEVINS pDevIns));
     3184
     3185    /**
     3186     * Returns the physical RAM size of the VM above the 4GB boundary.
     3187     *
     3188     * @returns RAM size in bytes.
     3189     * @param   pDevIns             The device instance.
     3190     */
     3191    DECLR3CALLBACKMEMBER(uint64_t, pfnMMPhysGetRamSizeAbove4GB,(PPDMDEVINS pDevIns));
    31563192
    31573193    /**
    … …  
    67236759
    67246760/**
     6761 * Allocating string printf.
     6762 *
     6763 * @returns Pointer to the string.
     6764 * @param   pDevIns     The device instance.
     6765 * @param   enmTag      The statistics tag.
     6766 * @param   pszFormat   The format string.
     6767 * @param   ...         Format arguments.
     6768 */
     6769DECLINLINE(char *) RT_IPRT_FORMAT_ATTR(2, 3) PDMDevHlpMMHeapAPrintf(PPDMDEVINS pDevIns, MMTAG enmTag, const char *pszFormat, ...)
     6770{
     6771    va_list va;
     6772    va_start(va, pszFormat);
     6773    char *psz = pDevIns->pHlpR3->pfnMMHeapAPrintfV(pDevIns, enmTag, pszFormat, va);
     6774    va_end(va);
     6775
     6776    return psz;
     6777}
     6778
     6779/**
    67256780 * @copydoc PDMDEVHLPR3::pfnMMHeapFree
    67266781 */
    … …  
    67286783{
    67296784    pDevIns->pHlpR3->pfnMMHeapFree(pDevIns, pv);
     6785}
     6786
     6787/**
     6788 * @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSize
     6789 */
     6790DECLINLINE(uint64_t) PDMDevHlpMMPhysGetRamSize(PPDMDEVINS pDevIns)
     6791{
     6792    return pDevIns->pHlpR3->pfnMMPhysGetRamSize(pDevIns);
     6793}
     6794
     6795/**
     6796 * @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSizeBelow4GB
     6797 */
     6798DECLINLINE(uint32_t) PDMDevHlpMMPhysGetRamSizeBelow4GB(PPDMDEVINS pDevIns)
     6799{
     6800    return pDevIns->pHlpR3->pfnMMPhysGetRamSizeBelow4GB(pDevIns);
     6801}
     6802
     6803/**
     6804 * @copydoc PDMDEVHLPR3::pfnMMPhysGetRamSizeAbove4GB
     6805 */
     6806DECLINLINE(uint64_t) PDMDevHlpMMPhysGetRamSizeAbove4GB(PPDMDEVINS pDevIns)
     6807{
     6808    return pDevIns->pHlpR3->pfnMMPhysGetRamSizeAbove4GB(pDevIns);
    67306809}
    67316810#endif /* IN_RING3 */

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

    r91860 r91897  
    10651065
    10661066    /**
     1067     * Free memory allocated with pfnMMHeapAlloc() and pfnMMHeapAllocZ().
     1068     *
     1069     * @param   pDrvIns             Driver instance.
     1070     * @param   pv                  Pointer to the memory to free.
     1071     */
     1072    DECLR3CALLBACKMEMBER(void, pfnMMHeapFree,(PPDMDRVINS pDrvIns, void *pv));
     1073
     1074    /**
    10671075     * Register an info handler with DBGF.
    10681076     *
    … …  
    14521460} PDMDRVHLPR3;
    14531461/** Current DRVHLP version number. */
    1454 #define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 9, 0)
     1462#define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 10, 0)
    14551463
    14561464
    … …  
    17111719                                              NULL /*pfnSavePrep*/, NULL /*pfnSaveExec*/, NULL /*pfnSaveDone*/,
    17121720                                              NULL /*pfnLoadPrep*/, NULL /*pfnLoadExec*/, pfnLoadDone);
     1721}
     1722
     1723/**
     1724 * @copydoc PDMDEVHLPR3::pfnMMHeapFree
     1725 */
     1726DECLINLINE(void) PDMDrvHlpMMHeapFree(PPDMDRVINS pDrvIns, void *pv)
     1727{
     1728    pDrvIns->pHlpR3->pfnMMHeapFree(pDrvIns, pv);
    17131729}
    17141730

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

    r91879 r91897  
    540540     */
    541541    DECLR3CALLBACKMEMBER(void *, pfnMMHeapAllocZ,(PPDMUSBINS pUsbIns, size_t cb));
     542
     543    /**
     544     * Free memory allocated with pfnMMHeapAlloc() and pfnMMHeapAllocZ().
     545     *
     546     * @param   pUsbIns             The USB device instance.
     547     * @param   pv                  Pointer to the memory to free.
     548     */
     549    DECLR3CALLBACKMEMBER(void, pfnMMHeapFree,(PPDMUSBINS pUsbIns, void *pv));
    542550
    543551    /**
    … …  
    921929
    922930/** Current USBHLP version number. */
    923 #define PDM_USBHLP_VERSION                      PDM_VERSION_MAKE(0xeefe, 5, 0)
     931#define PDM_USBHLP_VERSION                      PDM_VERSION_MAKE(0xeefe, 6, 0)
    924932
    925933#endif /* IN_RING3 */
    … …  
    11781186DECLINLINE(void) PDMUsbHlpMMHeapFree(PPDMUSBINS pUsbIns, void *pv)
    11791187{
    1180     NOREF(pUsbIns);
    1181     MMR3HeapFree(pv);
     1188    return pUsbIns->pHlpR3->pfnMMHeapFree(pUsbIns, pv);
    11821189}
    11831190

  • trunk/src/VBox/Devices/Audio/DrvHostAudioCoreAudio.cpp

    r91861 r91897  
    27752775    {
    27762776        rc = drvHstAudCaSetDevice(pThis, &pThis->InputDevice, true /*fInput*/, false /*fNotify*/, pszTmp);
    2777         MMR3HeapFree(pszTmp);
     2777        PDMDrvHlpMMHeapFree(pDrvIns, pszTmp);
    27782778    }
    27792779    else if (rc != VERR_CFGM_VALUE_NOT_FOUND && rc != VERR_CFGM_NO_PARENT)
    … …  
    27842784    {
    27852785        rc = drvHstAudCaSetDevice(pThis, &pThis->OutputDevice, false /*fInput*/, false /*fNotify*/, pszTmp);
    2786         MMR3HeapFree(pszTmp);
     2786        PDMDrvHlpMMHeapFree(pDrvIns, pszTmp);
    27872787    }
    27882788    else if (rc != VERR_CFGM_VALUE_NOT_FOUND && rc != VERR_CFGM_NO_PARENT)

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r91890 r91897  
    747747    PDEVPCIROOT     pGlobals   = PDMINS_2_DATA(pDevIns, PDEVPCIROOT);
    748748    PVM             pVM        = PDMDevHlpGetVM(pDevIns); Assert(pVM);
    749     PVMCPU          pVCpu      = PDMDevHlpGetVMCPU(pDevIns); Assert(pVM);
    750     uint32_t const  cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
    751     uint64_t const  cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
     749    PVMCPU          pVCpu      = PDMDevHlpGetVMCPU(pDevIns); Assert(pVCpu);
     750    uint32_t const  cbBelow4GB = PDMDevHlpMMPhysGetRamSizeBelow4GB(pDevIns);
     751    uint64_t const  cbAbove4GB = PDMDevHlpMMPhysGetRamSizeAbove4GB(pDevIns);
    752752    RT_NOREF(cbBelow4GB, cbAbove4GB);
    753753

  • trunk/src/VBox/Devices/Bus/DevPciIch9.cpp

    r91890 r91897  
    24312431{
    24322432    PDEVPCIROOT     pPciRoot   = PDMINS_2_DATA(pDevIns, PDEVPCIROOT);
    2433     PVM             pVM        = PDMDevHlpGetVM(pDevIns);
    2434     uint32_t const  cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
    2435     uint64_t const  cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
     2433    uint32_t const  cbBelow4GB = PDMDevHlpMMPhysGetRamSizeBelow4GB(pDevIns);
     2434    uint64_t const  cbAbove4GB = PDMDevHlpMMPhysGetRamSizeAbove4GB(pDevIns);
    24362435
    24372436    LogRel(("PCI: setting up topology, resources and interrupts\n"));

  • trunk/src/VBox/Devices/EFI/DevEFI.cpp

    r91689 r91897  
    908908    PDEVEFIR3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDEVEFIR3);
    909909
    910     PVM pVM                    = PDMDevHlpGetVM(pDevIns);
    911     uint64_t const  cbRamSize  = MMR3PhysGetRamSize(pVM);
    912     uint32_t const  cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
    913     uint64_t const  cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
     910    uint64_t const  cbRamSize  = PDMDevHlpMMPhysGetRamSize(pDevIns);
     911    uint32_t const  cbBelow4GB = PDMDevHlpMMPhysGetRamSizeBelow4GB(pDevIns);
     912    uint64_t const  cbAbove4GB = PDMDevHlpMMPhysGetRamSizeAbove4GB(pDevIns);
    914913    NOREF(cbAbove4GB);
    915914

  • trunk/src/VBox/Devices/GIMDev/DrvUDP.cpp

    r91862 r91897  
    159159    }
    160160
    161     MMR3HeapFree(pThis->pszServerAddress);
     161    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszServerAddress);
    162162    pThis->pszServerAddress = NULL;
    163163}

  • trunk/src/VBox/Devices/Network/DevINIP.cpp

    r85193 r91897  
    556556        vboxLwipCoreFinalize(devINIPTcpipFiniDone, pThis);
    557557
    558     MMR3HeapFree(pThis->pszIP);
     558    PDMDevHlpMMHeapFree(pDevIns, pThis->pszIP);
    559559    pThis->pszIP = NULL;
    560     MMR3HeapFree(pThis->pszNetmask);
     560    PDMDevHlpMMHeapFree(pDevIns, pThis->pszNetmask);
    561561    pThis->pszNetmask = NULL;
    562     MMR3HeapFree(pThis->pszGateway);
     562    PDMDevHlpMMHeapFree(pDevIns, pThis->pszGateway);
    563563    pThis->pszGateway = NULL;
    564564

  • trunk/src/VBox/Devices/Network/DrvNAT.cpp

    r91892 r91897  
    16801680        slirp_set_binding_address(pThis->pNATState, pszBindIP);
    16811681        if (pszBindIP != NULL)
    1682             MMR3HeapFree(pszBindIP);
     1682            PDMDrvHlpMMHeapFree(pDrvIns, pszBindIP);
    16831683
    16841684#define SLIRP_SET_TUNING_VALUE(name, setter)                    \

  • trunk/src/VBox/Devices/Network/DrvTAP.cpp

    r91872 r91897  
    815815        RTStrFree(pThis->pszDeviceName);    /* allocated by drvTAPSetupApplication */
    816816    else
    817         MMR3HeapFree(pThis->pszDeviceName);
     817        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDeviceName);
    818818#else
    819     MMR3HeapFree(pThis->pszDeviceName);
     819    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDeviceName);
    820820#endif
    821821    pThis->pszDeviceName = NULL;
    822     MMR3HeapFree(pThis->pszSetupApplication);
     822    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszSetupApplication);
    823823    pThis->pszSetupApplication = NULL;
    824     MMR3HeapFree(pThis->pszTerminateApplication);
     824    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszTerminateApplication);
    825825    pThis->pszTerminateApplication = NULL;
    826826

  • trunk/src/VBox/Devices/Network/DrvUDPTunnel.cpp

    r91872 r91897  
    414414    if (pThis->pszDestIP)
    415415    {
    416         MMR3HeapFree(pThis->pszDestIP);
     416        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDestIP);
    417417        pThis->pszDestIP = NULL;
    418418    }

  • trunk/src/VBox/Devices/Network/DrvVDE.cpp

    r91872 r91897  
    502502    }
    503503
    504     MMR3HeapFree(pThis->pszDeviceName);
     504    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDeviceName);
    505505    pThis->pszDeviceName = NULL;
    506506

  • trunk/src/VBox/Devices/PC/ACPI/VBoxAcpi.cpp

    r91885 r91897  
    347347            RTFileClose(hFileAml);
    348348        }
    349         MMR3HeapFree(pszAmlFilePath);
     349        PDMDevHlpMMHeapFree(pDevIns, pszAmlFilePath);
    350350    }
    351351

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r91238 r91897  
    37743774     * The latter starts never below 4G.
    37753775     */
    3776     PVM pVM                    = PDMDevHlpGetVM(pDevIns);
    3777     uint32_t        cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
    3778     uint64_t const  cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
    3779 
    3780     pThis->u64RamSize = MMR3PhysGetRamSize(pVM);
     3776    uint32_t        cbBelow4GB = PDMDevHlpMMPhysGetRamSizeBelow4GB(pDevIns);
     3777    uint64_t const  cbAbove4GB = PDMDevHlpMMPhysGetRamSizeAbove4GB(pDevIns);
     3778
     3779    pThis->u64RamSize = PDMDevHlpMMPhysGetRamSize(pDevIns);
    37813780    if (pThis->fPciPref64Enabled)
    37823781    {

  • trunk/src/VBox/Devices/PC/DevFwCommon.cpp

    r85948 r91897  
    826826         * DMI Physical Memory Array (Type 16) *
    827827         ***************************************/
    828         uint64_t const  cbRamSize = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
     828        uint64_t const  cbRamSize = PDMDevHlpMMPhysGetRamSize(pDevIns);
    829829
    830830        PDMIRAMARRAY pMemArray = (PDMIRAMARRAY)pszStr;

  • trunk/src/VBox/Devices/PC/DevPcArch.cpp

    r82968 r91897  
    244244                                               pcarchReservedMemoryWrite, pcarchReservedMemoryRead,
    245245                                               IOMMMIO_FLAGS_READ_PASSTHRU | IOMMMIO_FLAGS_WRITE_PASSTHRU | IOMMMIO_FLAGS_ABS,
    246                                                MMR3HeapAPrintf(pVM, MM_TAG_PGM_PHYS /* bad bird*/, "PC Arch Reserved #%u", iRegion),
     246                                               PDMDevHlpMMHeapAPrintf(pDevIns, MM_TAG_PGM_PHYS /* bad bird*/, "PC Arch Reserved #%u", iRegion),
    247247                                               &hMmioRegion);
    248248            AssertLogRelRCReturn(rc, rc);

  • trunk/src/VBox/Devices/PC/DevPcBios.cpp

    r91566 r91897  
    773773    LogFlow(("pcbiosInitComplete:\n"));
    774774
    775     PVM pVM                    = PDMDevHlpGetVM(pDevIns);
    776     uint64_t const  cbRamSize  = MMR3PhysGetRamSize(pVM);
    777     uint32_t const  cbBelow4GB = MMR3PhysGetRamSizeBelow4GB(pVM);
    778     uint64_t const  cbAbove4GB = MMR3PhysGetRamSizeAbove4GB(pVM);
     775    uint64_t const  cbRamSize  = PDMDevHlpMMPhysGetRamSize(pDevIns);
     776    uint32_t const  cbBelow4GB = PDMDevHlpMMPhysGetRamSizeBelow4GB(pDevIns);
     777    uint64_t const  cbAbove4GB = PDMDevHlpMMPhysGetRamSizeAbove4GB(pDevIns);
    779778
    780779    /*

  • trunk/src/VBox/Devices/PC/DevQemuFwCfg.cpp

    r86034 r91897  
    323323        else
    324324            LogRel(("QemuFwCfg: Failed to open file \"%s\" -> %Rrc\n", pszFilePath, rc));
    325         MMR3HeapFree(pszFilePath);
     325        PDMDevHlpMMHeapFree(pThis->pDevIns, pszFilePath);
    326326    }
    327327    else
    … …  
    405405        else
    406406            LogRel(("QemuFwCfg: Failed to open file \"%s\" -> %Rrc\n", pszFilePath, rc));
    407         MMR3HeapFree(pszFilePath);
     407        PDMDevHlpMMHeapFree(pThis->pDevIns, pszFilePath);
    408408    }
    409409    else

  • trunk/src/VBox/Devices/Parallel/DrvHostParallel.cpp

    r91865 r91897  
    901901    if (pThis->pszDevicePath)
    902902    {
    903         MMR3HeapFree(pThis->pszDevicePath);
     903        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDevicePath);
    904904        pThis->pszDevicePath = NULL;
    905905    }

  • trunk/src/VBox/Devices/Serial/DrvHostSerial.cpp

    r91868 r91897  
    763763    if (pThis->pszDevicePath)
    764764    {
    765         MMR3HeapFree(pThis->pszDevicePath);
     765        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDevicePath);
    766766        pThis->pszDevicePath = NULL;
    767767    }

  • trunk/src/VBox/Devices/Serial/DrvNamedPipe.cpp

    r91868 r91897  
    849849#endif /* !RT_OS_WINDOWS */
    850850
    851     MMR3HeapFree(pThis->pszLocation);
     851    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszLocation);
    852852    pThis->pszLocation = NULL;
    853853

  • trunk/src/VBox/Devices/Serial/DrvRawFile.cpp

    r91868 r91897  
    165165
    166166    if (pThis->pszLocation)
    167         MMR3HeapFree(pThis->pszLocation);
     167        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszLocation);
    168168
    169169    if (pThis->hOutputFile != NIL_RTFILE)

  • trunk/src/VBox/Devices/Serial/DrvTCP.cpp

    r91868 r91897  
    529529    }
    530530
    531     MMR3HeapFree(pThis->pszLocation);
     531    PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszLocation);
    532532    pThis->pszLocation = NULL;
    533533

  • trunk/src/VBox/Devices/Storage/DrvDiskIntegrity.cpp

    r91869 r91897  
    20372037        {
    20382038            rc = RTTraceLogWrCreateFile(&pThis->hIoLogger, NULL, pszIoLogFilename);
    2039             MMR3HeapFree(pszIoLogFilename);
     2039            PDMDrvHlpMMHeapFree(pDrvIns, pszIoLogFilename);
    20402040        }
    20412041        else if (!RTStrICmp(pszIoLogType, "Server"))
    … …  
    20432043            rc = RTTraceLogWrCreateTcpServer(&pThis->hIoLogger, NULL, pszAddress, uPort);
    20442044            if (pszAddress)
    2045                 MMR3HeapFree(pszAddress);
     2045                PDMDrvHlpMMHeapFree(pDrvIns, pszAddress);
    20462046        }
    20472047        else if (!RTStrICmp(pszIoLogType, "Client"))
    20482048        {
    20492049            rc = RTTraceLogWrCreateTcpClient(&pThis->hIoLogger, NULL, pszAddress, uPort);
    2050             MMR3HeapFree(pszAddress);
     2050            PDMDrvHlpMMHeapFree(pDrvIns, pszAddress);
    20512051        }
    20522052        else
    20532053            AssertMsgFailed(("Invalid I/O log type given: %s\n", pszIoLogType));
    20542054
    2055         MMR3HeapFree(pszIoLogType);
     2055        PDMDrvHlpMMHeapFree(pDrvIns, pszIoLogType);
    20562056    }
    20572057

  • trunk/src/VBox/Devices/Storage/DrvHostBase.cpp

    r91869 r91897  
    12231223    if (pThis->pszDevice)
    12241224    {
    1225         MMR3HeapFree(pThis->pszDevice);
     1225        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDevice);
    12261226        pThis->pszDevice = NULL;
    12271227    }
    … …  
    14161416        {
    14171417            AssertMsgFailed(("Configuration error: Uuid from string failed on \"%s\", rc=%Rrc.\n", psz, rc));
    1418             MMR3HeapFree(psz);
     1418            PDMDrvHlpMMHeapFree(pDrvIns, psz);
    14191419            return rc;
    14201420        }
    1421         MMR3HeapFree(psz);
     1421        PDMDrvHlpMMHeapFree(pDrvIns, psz);
    14221422    }
    14231423    else

  • trunk/src/VBox/Devices/Storage/DrvVD.cpp

    r91876 r91897  
    39673967            rc = VDFilterAdd(pThis->pDisk, pszFilterName, VD_FILTER_FLAGS_DEFAULT, pVDIfsFilter);
    39683968
    3969             MMR3HeapFree(pszFilterName);
     3969            PDMDrvHlpMMHeapFree(pThis->pDrvIns, pszFilterName);
    39703970        }
    39713971    }
    … …  
    44534453    if (pThis->pszBwGroup)
    44544454    {
    4455         MMR3HeapFree(pThis->pszBwGroup);
     4455        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszBwGroup);
    44564456        pThis->pszBwGroup = NULL;
    44574457    }
    … …  
    48184818                PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_BLOCK_UNKNOWN_TYPE, RT_SRC_POS,
    48194819                                    N_("Unknown type \"%s\""), psz);
    4820                 MMR3HeapFree(psz);
     4820                PDMDrvHlpMMHeapFree(pDrvIns, psz);
    48214821                return VERR_PDM_BLOCK_UNKNOWN_TYPE;
    48224822            }
    4823             MMR3HeapFree(psz); psz = NULL;
     4823            PDMDrvHlpMMHeapFree(pDrvIns, psz); psz = NULL;
    48244824
    48254825            rc = pHlp->pfnCFGMQueryStringAlloc(pCurNode, "CachePath", &pszCachePath);
    … …  
    48844884                {
    48854885                    PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Uuid from string failed on \"%s\""), psz);
    4886                     MMR3HeapFree(psz);
     4886                    PDMDrvHlpMMHeapFree(pDrvIns, psz);
    48874887                    return rc;
    48884888                }
    4889                 MMR3HeapFree(psz); psz = NULL;
     4889                PDMDrvHlpMMHeapFree(pDrvIns, psz); psz = NULL;
    48904890            }
    48914891            else
    … …  
    52445244            }
    52455245
    5246             MMR3HeapFree(pszName);
     5246            PDMDrvHlpMMHeapFree(pDrvIns, pszName);
    52475247            pszName = NULL;
    5248             MMR3HeapFree(pszFormat);
     5248            PDMDrvHlpMMHeapFree(pDrvIns, pszFormat);
    52495249            pszFormat = NULL;
    52505250
    … …  
    52935293
    52945294        if (RT_VALID_PTR(pszCachePath))
    5295             MMR3HeapFree(pszCachePath);
     5295            PDMDrvHlpMMHeapFree(pDrvIns, pszCachePath);
    52965296        if (RT_VALID_PTR(pszCacheFormat))
    5297             MMR3HeapFree(pszCacheFormat);
     5297            PDMDrvHlpMMHeapFree(pDrvIns, pszCacheFormat);
    52985298
    52995299        if (   RT_SUCCESS(rc)
    … …  
    54515451    {
    54525452        if (RT_VALID_PTR(pszName))
    5453             MMR3HeapFree(pszName);
     5453            PDMDrvHlpMMHeapFree(pDrvIns, pszName);
    54545454        if (RT_VALID_PTR(pszFormat))
    5455             MMR3HeapFree(pszFormat);
     5455            PDMDrvHlpMMHeapFree(pDrvIns, pszFormat);
    54565456        /* drvvdDestruct does the rest. */
    54575457    }

  • trunk/src/VBox/Devices/Trace/DrvIfsTrace.cpp

    r91870 r91897  
    8080    if (pThis->pszTraceFilePath)
    8181    {
    82         MMR3HeapFree(pThis->pszTraceFilePath);
     82        PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszTraceFilePath);
    8383        pThis->pszTraceFilePath = NULL;
    8484    }

  • trunk/src/VBox/Devices/USB/DrvVUSBRootHub.cpp

    r91871 r91897  
    13771377                                       pszCaptureFilename);
    13781378
    1379         MMR3HeapFree(pszCaptureFilename);
     1379        PDMDrvHlpMMHeapFree(pDrvIns, pszCaptureFilename);
    13801380    }
    13811381

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

    r91887 r91897  
    46314631
    46324632    RTStrCopy(pThis->szGuestCoreDumpDir, sizeof(pThis->szGuestCoreDumpDir), pszGuestCoreDumpDir);
    4633     MMR3HeapFree(pszGuestCoreDumpDir);
     4633    PDMDevHlpMMHeapFree(pDevIns, pszGuestCoreDumpDir);
    46344634
    46354635    rc = pHlp->pfnCFGMQueryU32Def(pCfg, "GuestCoreDumpCount", &pThis->cGuestCoreDumps, 3);
    … …  
    47284728     * <missing comment>
    47294729     */
    4730     pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
     4730    pThis->cbGuestRAM = PDMDevHlpMMPhysGetRamSize(pDevIns);
    47314731
    47324732    /*

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

    r90997 r91897  
    10921092
    10931093
     1094/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAPrintfV} */
     1095static DECLCALLBACK(char *) pdmR3DevHlp_MMHeapAPrintfV(PPDMDEVINS pDevIns, MMTAG enmTag, const char *pszFormat, va_list va)
     1096{
     1097    PDMDEV_ASSERT_DEVINS(pDevIns);
     1098    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: enmTag=%u pszFormat=%p:{%s}\n",
     1099             pDevIns->pReg->szName, pDevIns->iInstance, enmTag, pszFormat, pszFormat));
     1100
     1101    char *psz = MMR3HeapAPrintfV(pDevIns->Internal.s.pVMR3, enmTag, pszFormat, va);
     1102
     1103    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: returns %p:{%s}\n",
     1104             pDevIns->pReg->szName, pDevIns->iInstance, psz, psz));
     1105    return psz;
     1106}
     1107
     1108
    10941109/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
    10951110static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
    … …  
    11011116
    11021117    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
     1118}
     1119
     1120
     1121/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSize} */
     1122static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSize(PPDMDEVINS pDevIns)
     1123{
     1124    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     1125    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     1126
     1127    uint64_t cb = MMR3PhysGetRamSize(pDevIns->Internal.s.pVMR3);
     1128
     1129    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d: returns %RU64\n",
     1130             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     1131    return cb;
     1132}
     1133
     1134
     1135/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeBelow4GB} */
     1136static DECLCALLBACK(uint32_t) pdmR3DevHlp_MMPhysGetRamSizeBelow4GB(PPDMDEVINS pDevIns)
     1137{
     1138    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     1139    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     1140
     1141    uint32_t cb = MMR3PhysGetRamSizeBelow4GB(pDevIns->Internal.s.pVMR3);
     1142
     1143    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d: returns %RU32\n",
     1144             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     1145    return cb;
     1146}
     1147
     1148
     1149/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeAbove4GB} */
     1150static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSizeAbove4GB(PPDMDEVINS pDevIns)
     1151{
     1152    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     1153    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     1154
     1155    uint64_t cb = MMR3PhysGetRamSizeAbove4GB(pDevIns->Internal.s.pVMR3);
     1156
     1157    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d: returns %RU64\n",
     1158             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     1159    return cb;
    11031160}
    11041161
    … …  
    44784535    pdmR3DevHlp_MMHeapAlloc,
    44794536    pdmR3DevHlp_MMHeapAllocZ,
     4537    pdmR3DevHlp_MMHeapAPrintfV,
    44804538    pdmR3DevHlp_MMHeapFree,
     4539    pdmR3DevHlp_MMPhysGetRamSize,
     4540    pdmR3DevHlp_MMPhysGetRamSizeBelow4GB,
     4541    pdmR3DevHlp_MMPhysGetRamSizeAbove4GB,
    44814542    pdmR3DevHlp_VMState,
    44824543    pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
    … …  
    48424903    pdmR3DevHlp_MMHeapAlloc,
    48434904    pdmR3DevHlp_MMHeapAllocZ,
     4905    pdmR3DevHlp_MMHeapAPrintfV,
    48444906    pdmR3DevHlp_MMHeapFree,
     4907    pdmR3DevHlp_MMPhysGetRamSize,
     4908    pdmR3DevHlp_MMPhysGetRamSizeBelow4GB,
     4909    pdmR3DevHlp_MMPhysGetRamSizeAbove4GB,
    48454910    pdmR3DevHlp_VMState,
    48464911    pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
    … …  
    53635428    pdmR3DevHlp_MMHeapAlloc,
    53645429    pdmR3DevHlp_MMHeapAllocZ,
     5430    pdmR3DevHlp_MMHeapAPrintfV,
    53655431    pdmR3DevHlp_MMHeapFree,
     5432    pdmR3DevHlp_MMPhysGetRamSize,
     5433    pdmR3DevHlp_MMPhysGetRamSizeBelow4GB,
     5434    pdmR3DevHlp_MMPhysGetRamSizeAbove4GB,
    53665435    pdmR3DevHlp_VMState,
    53675436    pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,

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

    r91860 r91897  
    13741374    LogFlow(("pdmR3DrvHlp_SSMDeregister: caller='%s'/%d: returns %Rrc\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc));
    13751375    return rc;
     1376}
     1377
     1378
     1379/** @interface_method_impl{PDMDRVHLPR3,pfnMMHeapFree} */
     1380static DECLCALLBACK(void) pdmR3DrvHlp_MMHeapFree(PPDMDRVINS pDrvIns, void *pv)
     1381{
     1382    PDMDRV_ASSERT_DRVINS(pDrvIns);
     1383    LogFlow(("pdmR3DrvHlp_MMHeapFree: caller='%s'/%d: pv=%p\n",
     1384             pDrvIns->pReg->szName, pDrvIns->iInstance, pv));
     1385
     1386    MMR3HeapFree(pv);
     1387
     1388    LogFlow(("pdmR3DrvHlp_MMHeapFree: caller='%s'/%d: returns\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
    13761389}
    13771390
    … …  
    21652178    CFGMR3AreValuesValid,
    21662179    CFGMR3ValidateConfig,
     2180    pdmR3DrvHlp_MMHeapFree,
    21672181    pdmR3DrvHlp_DBGFInfoRegister,
    21682182    pdmR3DrvHlp_DBGFInfoRegisterArgv,

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

    r91879 r91897  
    17481748
    17491749
     1750/** @interface_method_impl{PDMUSBHLP,pfnMMHeapFree} */
     1751static DECLCALLBACK(void) pdmR3UsbHlp_MMHeapFree(PPDMUSBINS pUsbIns, void *pv)
     1752{
     1753    PDMUSB_ASSERT_USBINS(pUsbIns);
     1754    LogFlow(("pdmR3UsbHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, pv));
     1755
     1756    MMR3HeapFree(pv);
     1757
     1758    LogFlow(("pdmR3UsbHlp_MMHeapFree: caller='%s'/%d: returns\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
     1759}
     1760
     1761
    17501762/** @interface_method_impl{PDMUSBHLP,pfnPDMQueueCreate} */
    17511763static DECLCALLBACK(int) pdmR3UsbHlp_PDMQueueCreate(PPDMUSBINS pUsbIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
    … …  
    21802192    pdmR3UsbHlp_MMHeapAlloc,
    21812193    pdmR3UsbHlp_MMHeapAllocZ,
     2194    pdmR3UsbHlp_MMHeapFree,
    21822195    pdmR3UsbHlp_PDMQueueCreate,
    21832196    pdmR3UsbHlp_SSMRegister,
Note: See TracChangeset for help on using the changeset viewer.

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