VirtualBox

Changeset 20700 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Jun 19, 2009 8:31:03 AM (16 years ago)
Author:
vboxsync
Message:

Protect IOM registration changes with the IOM lock.

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

Legend:

Unmodified
Added
Removed

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

    r20687 r20700  
    228228static void iomR3FlushCache(PVM pVM)
    229229{
     230    iomLock(pVM);
    230231    /*
    231232     * Caching of port and statistics (saves some time in rep outs/ins instruction emulation)
    … …  
    251252    pVM->iom.s.pMMIORangeLastRC  = NIL_RTRCPTR;
    252253    pVM->iom.s.pMMIOStatsLastRC  = NIL_RTRCPTR;
     254
     255    iomUnlock(pVM);
    253256}
    254257
    … …  
    395398PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc)
    396399{
     400    Assert(IOMIsLockOwner(pVM));
    397401    /* check if it already exists. */
    398402    PIOMIOPORTSTATS pPort = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.pTreesR3->IOPortStatTree, Port);
    … …  
    447451PIOMMMIOSTATS iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc)
    448452{
     453    Assert(IOMIsLockOwner(pVM));
    449454#ifdef DEBUG_sandervl
    450455    AssertGCPhys32(GCPhys);
    … …  
    564569         * Try Insert it.
    565570         */
     571        iomLock(pVM);
    566572        if (RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR3, &pRange->Core))
    567573        {
    … …  
    570576                iomR3IOPortStatsCreate(pVM, PortStart + iPort, pszDesc);
    571577            #endif
     578            iomUnlock(pVM);
    572579            return VINF_SUCCESS;
    573580        }
     581        iomUnlock(pVM);
    574582
    575583        /* conflict. */
    … …  
    627635    }
    628636
     637    iomLock(pVM);
     638
    629639    /*
    630640     * Validate that there are ring-3 ranges for the ports.
    … …  
    637647        {
    638648            AssertMsgFailed(("No R3! Port=#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
     649            iomUnlock(pVM);
    639650            return VERR_IOM_NO_HC_IOPORT_RANGE;
    640651        }
    … …  
    647658        {
    648659            AssertMsgFailed(("Not owner! Port=%#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
     660            iomUnlock(pVM);
    649661            return VERR_IOM_NOT_IOPORT_RANGE_OWNER;
    650662        }
    … …  
    679691         */
    680692        if (RTAvlroIOPortInsert(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeRC, &pRange->Core))
     693        {
     694            iomUnlock(pVM);
    681695            return VINF_SUCCESS;
     696        }
    682697
    683698        /* conflict. */
    … …  
    686701        rc = VERR_IOM_IOPORT_RANGE_CONFLICT;
    687702    }
    688 
     703    iomUnlock(pVM);
    689704    return rc;
    690705}
    … …  
    735750    }
    736751
     752    iomLock(pVM);
    737753    /*
    738754     * Validate that there are ring-3 ranges for the ports.
    … …  
    745761        {
    746762            AssertMsgFailed(("No R3! Port=#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
     763            iomUnlock(pVM);
    747764            return VERR_IOM_NO_HC_IOPORT_RANGE;
    748765        }
    … …  
    755772        {
    756773            AssertMsgFailed(("Not owner! Port=%#x %#x-%#x! (%s)\n", Port, PortStart, (unsigned)PortStart + cPorts - 1, pszDesc));
     774            iomUnlock(pVM);
    757775            return VERR_IOM_NOT_IOPORT_RANGE_OWNER;
    758776        }
    … …  
    787805         */
    788806        if (RTAvlroIOPortInsert(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeR0, &pRange->Core))
     807        {
     808            iomUnlock(pVM);
    789809            return VINF_SUCCESS;
     810        }
    790811
    791812        /* conflict. */
    … …  
    794815        rc = VERR_IOM_IOPORT_RANGE_CONFLICT;
    795816    }
    796 
     817    iomUnlock(pVM);
    797818    return rc;
    798819}
    … …  
    831852        return VERR_IOM_INVALID_IOPORT_RANGE;
    832853    }
     854
     855    iomLock(pVM);
    833856
    834857    /* Flush the IO port lookup cache */
    … …  
    851874                AssertMsgFailed(("Removal of ports in range %#x-%#x rejected because not owner of %#x-%#x (%s)\n",
    852875                                 PortStart, PortLast, pRange->Core.Key, pRange->Core.KeyLast, pRange->pszDesc));
     876                iomUnlock(pVM);
    853877                return VERR_IOM_NOT_IOPORT_RANGE_OWNER;
    854878            }
    … …  
    909933                  */
    910934                Assert(pRange->Core.KeyLast > PortLast && pRange->Core.Key < Port);
    911                  /* create tail. */
    912                  PIOMIOPORTRANGERC pRangeNew;
    913                  int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    914                  if (RT_FAILURE(rc))
    915                      return rc;
    916 
    917                  *pRangeNew = *pRange;
    918                  pRangeNew->Core.Key     = PortLast;
    919                  pRangeNew->Port         = PortLast;
    920                  pRangeNew->cPorts       = pRangeNew->Core.KeyLast - PortLast + 1;
    921 
    922                  /* adjust head */
    923                  pRange->Core.KeyLast  = Port - 1;
    924                  pRange->cPorts        = Port - pRange->Port;
    925 
    926                  /* insert */
    927                  if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeRC, &pRangeNew->Core))
    928                  {
    929                      AssertMsgFailed(("This cannot happen!\n"));
    930                      MMHyperFree(pVM, pRangeNew);
    931                      rc = VERR_INTERNAL_ERROR;
    932                  }
    933                  break;
     935                /* create tail. */
     936                PIOMIOPORTRANGERC pRangeNew;
     937                int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
     938                if (RT_FAILURE(rc))
     939                {
     940                    iomUnlock(pVM);
     941                    return rc;
     942                }
     943                *pRangeNew = *pRange;
     944                pRangeNew->Core.Key     = PortLast;
     945                pRangeNew->Port         = PortLast;
     946                pRangeNew->cPorts       = pRangeNew->Core.KeyLast - PortLast + 1;
     947
     948                /* adjust head */
     949                pRange->Core.KeyLast  = Port - 1;
     950                pRange->cPorts        = Port - pRange->Port;
     951
     952                /* insert */
     953                if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeRC, &pRangeNew->Core))
     954                {
     955                    AssertMsgFailed(("This cannot happen!\n"));
     956                    MMHyperFree(pVM, pRangeNew);
     957                    rc = VERR_INTERNAL_ERROR;
     958                }
     959                break;
    934960            }
    935961        }
    … …  
    9891015                  */
    9901016                Assert(pRange->Core.KeyLast > PortLast && pRange->Core.Key < Port);
    991                  /* create tail. */
    992                  PIOMIOPORTRANGER0 pRangeNew;
    993                  int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    994                  if (RT_FAILURE(rc))
    995                      return rc;
    996 
    997                  *pRangeNew = *pRange;
    998                  pRangeNew->Core.Key     = PortLast;
    999                  pRangeNew->Port         = PortLast;
    1000                  pRangeNew->cPorts       = pRangeNew->Core.KeyLast - PortLast + 1;
    1001 
    1002                  /* adjust head */
    1003                  pRange->Core.KeyLast  = Port - 1;
    1004                  pRange->cPorts        = Port - pRange->Port;
    1005 
    1006                  /* insert */
    1007                  if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR0, &pRangeNew->Core))
    1008                  {
    1009                      AssertMsgFailed(("This cannot happen!\n"));
    1010                      MMHyperFree(pVM, pRangeNew);
    1011                      rc = VERR_INTERNAL_ERROR;
    1012                  }
    1013                  break;
     1017                /* create tail. */
     1018                PIOMIOPORTRANGER0 pRangeNew;
     1019                int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
     1020                if (RT_FAILURE(rc))
     1021                {
     1022                    iomUnlock(pVM);
     1023                    return rc;
     1024                }
     1025                *pRangeNew = *pRange;
     1026                pRangeNew->Core.Key     = PortLast;
     1027                pRangeNew->Port         = PortLast;
     1028                pRangeNew->cPorts       = pRangeNew->Core.KeyLast - PortLast + 1;
     1029
     1030                /* adjust head */
     1031                pRange->Core.KeyLast  = Port - 1;
     1032                pRange->cPorts        = Port - pRange->Port;
     1033
     1034                /* insert */
     1035                if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR0, &pRangeNew->Core))
     1036                {
     1037                    AssertMsgFailed(("This cannot happen!\n"));
     1038                    MMHyperFree(pVM, pRangeNew);
     1039                    rc = VERR_INTERNAL_ERROR;
     1040                }
     1041                break;
    10141042            }
    10151043        }
    … …  
    10711099                int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    10721100                if (RT_FAILURE(rc))
     1101                {
     1102                    iomUnlock(pVM);
    10731103                    return rc;
    1074 
     1104                }
    10751105                *pRangeNew = *pRange;
    10761106                pRangeNew->Core.Key     = PortLast;
    … …  
    10971127
    10981128    /* done */
     1129    iomUnlock(pVM);
    10991130    return rc;
    11001131}
    … …  
    14461477        if (RT_SUCCESS(rc))
    14471478        {
     1479            iomLock(pVM);
    14481480            if (RTAvlroGCPhysInsert(&pVM->iom.s.pTreesR3->MMIOTree, &pRange->Core))
     1481            {
     1482                iomUnlock(pVM);
    14491483                return VINF_SUCCESS;
     1484            }
     1485            iomUnlock(pVM);
    14501486
    14511487            /* bail out */
    … …  
    15981634    }
    15991635
     1636    iomLock(pVM);
     1637
    16001638    /*
    16011639     * Check ownership and such for the entire area.
    … …  
    16061644        PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
    16071645        if (!pRange)
     1646        {
     1647            iomUnlock(pVM);
    16081648            return VERR_IOM_MMIO_RANGE_NOT_FOUND;
     1649        }
    16091650        AssertMsgReturn(pRange->pDevInsR3 == pDevIns,
    16101651                        ("Not owner! GCPhys=%RGp %RGp LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pRange->pszDesc),
    … …  
    16181659        GCPhys = pRange->Core.KeyLast + 1;
    16191660    }
     1661    iomUnlock(pVM);
    16201662
    16211663    /*
    … …  
    16251667    while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
    16261668    {
     1669        iomLock(pVM);
    16271670        PIOMMMIORANGE pRange = (PIOMMMIORANGE)RTAvlroGCPhysRemove(&pVM->iom.s.pTreesR3->MMIOTree, GCPhys);
    16281671        Assert(pRange);
    16291672        Assert(pRange->Core.Key == GCPhys && pRange->Core.KeyLast <= GCPhysLast);
     1673        iomUnlock(pVM);
    16301674
    16311675        /* remove it from PGM */

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

    r20530 r20700  
    529529DECLINLINE(PIOMMMIOSTATS) iomMMIOGetStats(PIOM pIOM, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
    530530{
     531    Assert(IOMIsLockOwner(IOM2VM(pIOM)));
    531532    /* For large ranges, we'll put everything on the first byte. */
    532533    if (pRange->cb > PAGE_SIZE)
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