VirtualBox

Changeset 6529 in vbox


Ignore:
Timestamp:
Jan 28, 2008 2:58:18 PM (17 years ago)
Author:
vboxsync
Message:

mmr3 -> mmR3.

Location:
trunk/src/VBox/VMM
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/MM.cpp

    r5999 r6529  
    143143    if (!pVM->mm.s.pHeap)
    144144    {
    145         int rc = mmr3HeapCreate(pVM, &pVM->mm.s.pHeap);
     145        int rc = mmR3HeapCreate(pVM, &pVM->mm.s.pHeap);
    146146        if (!VBOX_SUCCESS(rc))
    147147            return rc;
    … …  
    151151     * Init the page pool.
    152152     */
    153     int rc = mmr3PagePoolInit(pVM);
     153    int rc = mmR3PagePoolInit(pVM);
    154154    if (VBOX_SUCCESS(rc))
    155155    {
    … …  
    157157         * Init the hypervisor related stuff.
    158158         */
    159         rc = mmr3HyperInit(pVM);
     159        rc = mmR3HyperInit(pVM);
    160160        if (VBOX_SUCCESS(rc))
    161161        {
    … …  
    288288     * Destroy the page pool. (first as it used the hyper heap)
    289289     */
    290     mmr3PagePoolTerm(pVM);
     290    mmR3PagePoolTerm(pVM);
    291291
    292292    /*
    … …  
    320320    if (!fKeepTheHeap)
    321321    {
    322         mmr3HeapDestroy(pVM->mm.s.pHeap);
     322        mmR3HeapDestroy(pVM->mm.s.pHeap);
    323323        pVM->mm.s.pHeap = NULL;
    324324    }
    … …  
    339339/**
    340340 * Reset notification.
    341  * 
    342  * MM will reload shadow ROMs into RAM at this point and make 
     341 *
     342 * MM will reload shadow ROMs into RAM at this point and make
    343343 * the ROM writable.
    344  * 
     344 *
    345345 * @param   pVM             The VM handle.
    346346 */
    … …  
    430430 * @param   fSilentFailure  Don't raise an error when unsuccessful. Upper layer with deal with it.
    431431 */
    432 int mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure)
     432int mmR3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure)
    433433{
    434434    Assert(RT_ALIGN_P(pv, PAGE_SIZE) == pv);
    … …  
    500500 * @param   fFlags      See the fFlags argument of PGR3Map().
    501501 */
    502 int mmr3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags)
     502int mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags)
    503503{
    504504    /*

  • trunk/src/VBox/VMM/MMHeap.cpp

    r5999 r6529  
    3737*   Internal Functions                                                         *
    3838*******************************************************************************/
    39 static void * mmr3HeapAlloc(PMMHEAP pHeap, MMTAG enmTag, size_t cbSize, bool fZero);
     39static void *mmR3HeapAlloc(PMMHEAP pHeap, MMTAG enmTag, size_t cbSize, bool fZero);
    4040
    4141
    … …  
    4848 * @param   ppHeap  Where to store the heap pointer.
    4949 */
    50 int mmr3HeapCreate(PVM pVM, PMMHEAP *ppHeap)
     50int mmR3HeapCreate(PVM pVM, PMMHEAP *ppHeap)
    5151{
    5252    PMMHEAP pHeap = (PMMHEAP)RTMemAllocZ(sizeof(MMHEAP) + sizeof(MMHEAPSTAT));
    … …  
    8989 * @param   pHeap   Heap handle.
    9090 */
    91 void mmr3HeapDestroy(PMMHEAP pHeap)
     91void mmR3HeapDestroy(PMMHEAP pHeap)
    9292{
    9393    /*
    … …  
    137137    if (!pVM->mm.s.pHeap)
    138138    {
    139         int rc = mmr3HeapCreate(pVM, &pVM->mm.s.pHeap);
     139        int rc = mmR3HeapCreate(pVM, &pVM->mm.s.pHeap);
    140140        if (VBOX_FAILURE(rc))
    141141            return NULL;
    142142    }
    143     return mmr3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, false);
     143    return mmR3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, false);
    144144}
    145145
    … …  
    161161    if (!pVM->mm.s.pHeap)
    162162    {
    163         int rc = mmr3HeapCreate(pVM, &pVM->mm.s.pHeap);
     163        int rc = mmR3HeapCreate(pVM, &pVM->mm.s.pHeap);
    164164        if (VBOX_FAILURE(rc))
    165165            return rc;
    166166    }
    167     void *pv = mmr3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, false);
     167    void *pv = mmR3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, false);
    168168    if (pv)
    169169    {
    … …  
    190190    if (!pVM->mm.s.pHeap)
    191191    {
    192         int rc = mmr3HeapCreate(pVM, &pVM->mm.s.pHeap);
     192        int rc = mmR3HeapCreate(pVM, &pVM->mm.s.pHeap);
    193193        if (VBOX_FAILURE(rc))
    194194            return NULL;
    195195    }
    196     return mmr3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, true);
     196    return mmR3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, true);
    197197}
    198198
    … …  
    214214    if (!pVM->mm.s.pHeap)
    215215    {
    216         int rc = mmr3HeapCreate(pVM, &pVM->mm.s.pHeap);
     216        int rc = mmR3HeapCreate(pVM, &pVM->mm.s.pHeap);
    217217        if (VBOX_FAILURE(rc))
    218218            return rc;
    219219    }
    220     void *pv = mmr3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, true);
     220    void *pv = mmR3HeapAlloc(pVM->mm.s.pHeap, enmTag, cbSize, true);
    221221    if (pv)
    222222    {
    … …  
    239239 * @param   fZero       Whether or not to zero the memory block.
    240240 */
    241 void * mmr3HeapAlloc(PMMHEAP pHeap, MMTAG enmTag, size_t cbSize, bool fZero)
     241void * mmR3HeapAlloc(PMMHEAP pHeap, MMTAG enmTag, size_t cbSize, bool fZero)
    242242{
    243243#ifdef MMR3HEAP_WITH_STATISTICS

  • trunk/src/VBox/VMM/MMHyper.cpp

    r5999 r6529  
    5555 * @returns VBox status.
    5656 */
    57 int mmr3HyperInit(PVM pVM)
    58 {
    59     LogFlow(("mmr3HyperInit:\n"));
     57int mmR3HyperInit(PVM pVM)
     58{
     59    LogFlow(("mmR3HyperInit:\n"));
    6060
    6161    /*
    … …  
    113113                DBGFR3InfoRegisterInternal(pVM, "hma", "Show the layout of the Hypervisor Memory Area.", mmR3HyperInfoHma);
    114114
    115                 LogFlow(("mmr3HyperInit: returns VINF_SUCCESS\n"));
     115                LogFlow(("mmR3HyperInit: returns VINF_SUCCESS\n"));
    116116                return VINF_SUCCESS;
    117117            }
    … …  
    120120    }
    121121
    122     LogFlow(("mmr3HyperInit: returns %Vrc\n", rc));
     122    LogFlow(("mmR3HyperInit: returns %Vrc\n", rc));
    123123    return rc;
    124124}
    … …  
    159159        {
    160160            case MMLOOKUPHYPERTYPE_LOCKED:
    161                 rc = mmr3MapLocked(pVM, pLookup->u.Locked.pLockedMem, GCPtr, 0, cPages, 0);
     161                rc = mmR3MapLocked(pVM, pLookup->u.Locked.pLockedMem, GCPtr, 0, cPages, 0);
    162162                break;
    163163
    … …  
    432432         */
    433433        PMMLOCKEDMEM    pLockedMem;
    434         rc = mmr3LockMem(pVM, pvHCPage, cb, fFree ? MM_LOCKED_TYPE_HYPER : MM_LOCKED_TYPE_HYPER_NOFREE, &pLockedMem, false /* fSilentFailure */);
     434        rc = mmR3LockMem(pVM, pvHCPage, cb, fFree ? MM_LOCKED_TYPE_HYPER : MM_LOCKED_TYPE_HYPER_NOFREE, &pLockedMem, false /* fSilentFailure */);
    435435        if (VBOX_SUCCESS(rc))
    436436        {
    437437            /* map the stuff into guest address space. */
    438438            if (pVM->mm.s.fPGMInitialized)
    439                 rc = mmr3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
     439                rc = mmR3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
    440440            if (VBOX_SUCCESS(rc))
    441441            {
    … …  
    473473MMR3DECL(int) MMR3HyperMapPages(PVM pVM, void *pvR3, RTR0PTR pvR0, size_t cPages, PCSUPPAGE paPages, const char *pszDesc, PRTGCPTR pGCPtr)
    474474{
    475     LogFlow(("MMR3HyperMapPages: pvR3=%p pvR0=%p cPages=%zu paPages=%p pszDesc=%p:{%s} pGCPtr=%p\n", 
     475    LogFlow(("MMR3HyperMapPages: pvR3=%p pvR0=%p cPages=%zu paPages=%p pszDesc=%p:{%s} pGCPtr=%p\n",
    476476             pvR3, pvR0, cPages, paPages, pszDesc, pszDesc, pGCPtr));
    477477
    … …  
    514514            /* map the stuff into guest address space. */
    515515            if (pVM->mm.s.fPGMInitialized)
    516                 rc = mmr3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
     516                rc = mmR3MapLocked(pVM, pLockedMem, GCPtr, 0, ~(size_t)0, 0);
    517517            if (VBOX_SUCCESS(rc))
    518518            {
    … …  
    938938                                sizeof(RTHCPTR) * 2,
    939939                                pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER_NOFREE  ? "nofree"
    940                                 : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER       ? "autofree" 
     940                                : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER       ? "autofree"
    941941                                : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_HYPER_PAGES ? "pages"
    942942                                : pLookup->u.Locked.pLockedMem->eType == MM_LOCKED_TYPE_PHYS        ? "gstphys"

  • trunk/src/VBox/VMM/MMInternal.h

    r5999 r6529  
    504504/**
    505505 * A registered Rom range.
    506  * 
     506 *
    507507 * This is used to track ROM registrations both for debug reasons
    508508 * and for resetting shadow ROM at reset.
    509  * 
     509 *
    510510 * This is allocated of the MMR3Heap and thus only accessibel from ring-3.
    511511 */
    … …  
    680680
    681681
    682 int  mmr3PagePoolInit(PVM pVM);
    683 void mmr3PagePoolTerm(PVM pVM);
    684 
    685 int  mmr3HeapCreate(PVM pVM, PMMHEAP *ppHeap);
    686 void mmr3HeapDestroy(PMMHEAP pHeap);
    687 
    688 int  mmr3HyperInit(PVM pVM);
     682int  mmR3PagePoolInit(PVM pVM);
     683void mmR3PagePoolTerm(PVM pVM);
     684
     685int  mmR3HeapCreate(PVM pVM, PMMHEAP *ppHeap);
     686void mmR3HeapDestroy(PMMHEAP pHeap);
     687
     688int  mmR3HyperInit(PVM pVM);
    689689int  mmR3HyperInitPaging(PVM pVM);
    690690
    691 int  mmr3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure);
    692 int  mmr3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
     691int  mmR3LockMem(PVM pVM, void *pv, size_t cb, MMLOCKEDTYPE eType, PMMLOCKEDMEM *ppLockedMem, bool fSilentFailure);
     692int  mmR3MapLocked(PVM pVM, PMMLOCKEDMEM pLockedMem, RTGCPTR Addr, unsigned iPage, size_t cPages, unsigned fFlags);
    693693
    694694const char *mmR3GetTagName(MMTAG enmTag);

  • trunk/src/VBox/VMM/MMPagePool.cpp

    r6298 r6529  
    4242*******************************************************************************/
    4343#ifdef IN_RING3
    44 static void *   mmr3PagePoolAlloc(PMMPAGEPOOL pPool);
    45 static void     mmr3PagePoolFree(PMMPAGEPOOL pPool, void *pv);
     44static void *   mmR3PagePoolAlloc(PMMPAGEPOOL pPool);
     45static void     mmR3PagePoolFree(PMMPAGEPOOL pPool, void *pv);
    4646#endif
    4747
    … …  
    5454 * @thread  The Emulation Thread.
    5555 */
    56 int mmr3PagePoolInit(PVM pVM)
     56int mmR3PagePoolInit(PVM pVM)
    5757{
    5858    AssertMsg(!pVM->mm.s.pPagePool, ("Already initialized!\n"));
    … …  
    9999 * @thread  The Emulation Thread.
    100100 */
    101 void mmr3PagePoolTerm(PVM pVM)
     101void mmR3PagePoolTerm(PVM pVM)
    102102{
    103103    if (pVM->mm.s.pPagePool)
    … …  
    152152 * @thread  The Emulation Thread.
    153153 */
    154 DECLINLINE(void *) mmr3PagePoolAlloc(PMMPAGEPOOL pPool)
     154DECLINLINE(void *) mmR3PagePoolAlloc(PMMPAGEPOOL pPool)
    155155{
    156156    VM_ASSERT_EMT(pPool->pVM);
    … …  
    219219    unsigned        cPages = !pPool->fLow ? 128 : 32;
    220220    PMMPAGESUBPOOL  pSub;
    221     int rc = MMHyperAlloc(pPool->pVM, 
     221    int rc = MMHyperAlloc(pPool->pVM,
    222222                          RT_OFFSETOF(MMPAGESUBPOOL, auBitmap[cPages / (sizeof(pSub->auBitmap[0] * 8))])
    223223                          + (sizeof(SUPPAGE) + sizeof(MMPPLOOKUPHCPHYS)) * cPages
    … …  
    313313    if (pPool->fLow)
    314314        VMSetError(pPool->pVM, rc, RT_SRC_POS,
    315                    N_("Failed to expand page pool for memory below 4GB. current size: %d pages"), 
     315                   N_("Failed to expand page pool for memory below 4GB. current size: %d pages"),
    316316                   pPool->cPages);
    317317    AssertMsgFailed(("Failed to expand pool%s. rc=%Vrc poolsize=%d\n",
    … …  
    326326 * @param   pPool   Pointer to the page pool.
    327327 * @param   pv      Pointer to the page to free.
    328  *                  I.e. pointer returned by mmr3PagePoolAlloc().
    329  * @thread  The Emulation Thread.
    330  */
    331 DECLINLINE(void) mmr3PagePoolFree(PMMPAGEPOOL pPool, void *pv)
     328 *                  I.e. pointer returned by mmR3PagePoolAlloc().
     329 * @thread  The Emulation Thread.
     330 */
     331DECLINLINE(void) mmR3PagePoolFree(PMMPAGEPOOL pPool, void *pv)
    332332{
    333333    VM_ASSERT_EMT(pPool->pVM);
    … …  
    388388MMR3DECL(void *) MMR3PageAlloc(PVM pVM)
    389389{
    390     return mmr3PagePoolAlloc(pVM->mm.s.pPagePool);
     390    return mmR3PagePoolAlloc(pVM->mm.s.pPagePool);
    391391}
    392392
    … …  
    407407{
    408408    /** @todo optimize this, it's the most common case now. */
    409     void *pv = mmr3PagePoolAlloc(pVM->mm.s.pPagePool);
     409    void *pv = mmR3PagePoolAlloc(pVM->mm.s.pPagePool);
    410410    if (pv)
    411411        return mmPagePoolPtr2Phys(pVM->mm.s.pPagePool, pv);
    … …  
    424424MMR3DECL(void) MMR3PageFree(PVM pVM, void *pvPage)
    425425{
    426     mmr3PagePoolFree(pVM->mm.s.pPagePool, pvPage);
     426    mmR3PagePoolFree(pVM->mm.s.pPagePool, pvPage);
    427427}
    428428
    … …  
    438438MMR3DECL(void *) MMR3PageAllocLow(PVM pVM)
    439439{
    440     return mmr3PagePoolAlloc(pVM->mm.s.pPagePoolLow);
     440    return mmR3PagePoolAlloc(pVM->mm.s.pPagePoolLow);
    441441}
    442442
    … …  
    451451MMR3DECL(void) MMR3PageFreeLow(PVM pVM, void *pvPage)
    452452{
    453     mmr3PagePoolFree(pVM->mm.s.pPagePoolLow, pvPage);
     453    mmR3PagePoolFree(pVM->mm.s.pPagePoolLow, pvPage);
    454454}
    455455
    … …  
    470470        pvPage = mmPagePoolPhys2Ptr(pVM->mm.s.pPagePoolLow, HCPhysPage);
    471471    if (pvPage)
    472         mmr3PagePoolFree(pVM->mm.s.pPagePool, pvPage);
     472        mmR3PagePoolFree(pVM->mm.s.pPagePool, pvPage);
    473473    else
    474474        AssertMsgFailed(("Invalid address HCPhysPT=%#x\n", HCPhysPage));
    … …  
    491491    if (!pVM->mm.s.pvDummyPage)
    492492    {
    493         pVM->mm.s.pvDummyPage = mmr3PagePoolAlloc(pVM->mm.s.pPagePool);
     493        pVM->mm.s.pvDummyPage = mmR3PagePoolAlloc(pVM->mm.s.pPagePool);
    494494        AssertRelease(pVM->mm.s.pvDummyPage);
    495495        pVM->mm.s.HCPhysDummyPage = mmPagePoolPtr2Phys(pVM->mm.s.pPagePool, pVM->mm.s.pvDummyPage);

  • trunk/src/VBox/VMM/MMPhys.cpp

    r5999 r6529  
    144144         */
    145145        PMMLOCKEDMEM    pLockedMem;
    146         rc = mmr3LockMem(pVM, pvRam, cb, MM_LOCKED_TYPE_PHYS, &pLockedMem, enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK /* fSilentFailure */);
     146        rc = mmR3LockMem(pVM, pvRam, cb, MM_LOCKED_TYPE_PHYS, &pLockedMem, enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK /* fSilentFailure */);
    147147        if (VBOX_SUCCESS(rc))
    148148        {
    … …  
    278278 *                              This must be cbRange bytes big.
    279279 *                              It will be copied and doesn't have to stick around.
    280  *                              It will be copied and doesn't have to stick around if fShadow is clear. 
     280 *                              It will be copied and doesn't have to stick around if fShadow is clear.
    281281 * @param   fShadow             Whether to emulate ROM shadowing. This involves leaving
    282282 *                              the ROM writable for a while during the POST and refreshing
    … …  
    287287 *          manually from the device yet. At present I doubt we need such features...
    288288 */
    289 MMR3DECL(int) MMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const void *pvBinary, 
     289MMR3DECL(int) MMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const void *pvBinary,
    290290                                  bool fShadow, const char *pszDesc)
    291291{
    … …  
    357357    {
    358358        /*
    359          * To prevent the shadow page table mappings from being RW in raw-mode, we 
     359         * To prevent the shadow page table mappings from being RW in raw-mode, we
    360360         * must currently employ a little hack. We register an write access handler
    361361         * and thereby ensures a RO mapping of the pages. This is NOT very nice,
    … …  
    487487
    488488
    489 /** 
     489/**
    490490 * Called by MMR3Reset to reset the shadow ROM.
    491  * 
    492  * Resetting involves reloading the ROM into RAM and make it 
     491 *
     492 * Resetting involves reloading the ROM into RAM and make it
    493493 * wriable again (as it was made read only at the end of the POST).
    494  * 
     494 *
    495495 * @param   pVM         The VM handle.
    496496 */
    … …  
    518518/**
    519519 * Write-protects a shadow ROM range.
    520  * 
     520 *
    521521 * This is called late in the POST for shadow ROM ranges.
    522  * 
     522 *
    523523 * @returns VBox status code.
    524524 * @param   pVM         The VM handle.
    525  * @param   GCPhys      Start of the registered shadow ROM range 
     525 * @param   GCPhys      Start of the registered shadow ROM range
    526526 * @param   cbRange     The length of the registered shadow ROM range.
    527527 *                      This can be NULL (not sure about the BIOS interface yet).
    … …  
    530530{
    531531    for (PMMROMRANGE pCur = pVM->mm.s.pRomHead; pCur; pCur = pCur->pNext)
    532         if (    pCur->GCPhys == GCPhys 
    533             &&  (   pCur->cbRange == cbRange 
     532        if (    pCur->GCPhys == GCPhys
     533            &&  (   pCur->cbRange == cbRange
    534534                 || !cbRange))
    535535        {
    … …  
    546546                rc = PGMR3PhysSetFlags(pVM, GCPhys, cbRange, 0, ~MM_RAM_FLAGS_MMIO2); /* ROM + MMIO2 -> ROM */
    547547                AssertRCReturn(rc, rc);
    548                 /* Don't bother with the MM page flags here because I don't think they are 
     548                /* Don't bother with the MM page flags here because I don't think they are
    549549                   really used beyond conflict checking at ROM, RAM, Reservation, etc. */
    550550

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

    r5999 r6529  
    149149static int mmHyperFree(PMMHYPERHEAP pHeap, PMMHYPERCHUNK pChunk);
    150150#ifdef MMHYPER_HEAP_STRICT
    151 static void mmr3HyperHeapCheck(PMMHYPERHEAP pHeap);
     151static void mmR3HyperHeapCheck(PMMHYPERHEAP pHeap);
    152152#endif
    153153
    … …  
    299299    Log3(("mmHyperAllocChunk: Enter cb=%#x uAlignment=%#x\n", cb, uAlignment));
    300300#ifdef MMHYPER_HEAP_STRICT
    301     mmr3HyperHeapCheck(pHeap);
     301    mmR3HyperHeapCheck(pHeap);
    302302#endif
    303303
    … …  
    510510
    511511#ifdef MMHYPER_HEAP_STRICT
    512     mmr3HyperHeapCheck(pHeap);
     512    mmR3HyperHeapCheck(pHeap);
    513513#endif
    514514    return pRet;
    … …  
    531531
    532532#ifdef MMHYPER_HEAP_STRICT
    533     mmr3HyperHeapCheck(pHeap);
     533    mmR3HyperHeapCheck(pHeap);
    534534#endif
    535535
    … …  
    615615
    616616#ifdef MMHYPER_HEAP_STRICT
    617     mmr3HyperHeapCheck(pHeap);
     617    mmR3HyperHeapCheck(pHeap);
    618618#endif
    619619    return pvRet;
    … …  
    859859
    860860#ifdef MMHYPER_HEAP_STRICT
    861     mmr3HyperHeapCheck(pHeap);
     861    mmR3HyperHeapCheck(pHeap);
    862862#endif
    863863
    … …  
    10091009
    10101010#ifdef MMHYPER_HEAP_STRICT
    1011     mmr3HyperHeapCheck(pHeap);
     1011    mmR3HyperHeapCheck(pHeap);
    10121012#endif
    10131013    return VINF_SUCCESS;
    … …  
    10191019 * Internal consitency check.
    10201020 */
    1021 static void mmr3HyperHeapCheck(PMMHYPERHEAP pHeap)
     1021static void mmR3HyperHeapCheck(PMMHYPERHEAP pHeap)
    10221022{
    10231023    PMMHYPERCHUNKFREE pPrev = NULL;
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