VirtualBox

Changeset 12566 in vbox for trunk/src


Ignore:
Timestamp:
Sep 18, 2008 12:42:54 PM (16 years ago)
Author:
vboxsync
Message:

Backed out 36722, 36764 & 36770; no need for per-cpu mmio registations anymore.

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

Legend:

Unmodified
Added
Removed

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

    r12554 r12566  
    3434#include <iprt/mp.h>
    3535
    36 ////#define VBOX_WITH_HWACCM_DEBUG_REGISTER_SUPPORT
     36#define VBOX_WITH_HWACCM_DEBUG_REGISTER_SUPPORT
    3737
    3838#if HC_ARCH_BITS == 64

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

    r12561 r12566  
    6767#include <VBox/log.h>
    6868#include <VBox/err.h>
    69 
    70 
    71 /*******************************************************************************
    72 *   Structures and Typedefs                                                    *
    73 *******************************************************************************/
    74 /**
    75  * pvUser argument of the iomr3RelocateMMIOCallback callback.
    76  */
    77 typedef struct IOMMMIOCALLBACKARGS
    78 {
    79     PVM                     pVM;
    80     RTGCINTPTR              offDelta;
    81 } IOMMMIOCALLBACKARGS;
    82 typedef IOMMMIOCALLBACKARGS *PIOMMMIOCALLBACKARGS;
    8369
    8470
    … …  
    239225     */
    240226    pVM->iom.s.pTreesGC = MMHyperHC2GC(pVM, pVM->iom.s.pTreesHC);
    241 
    242     IOMMMIOCALLBACKARGS Args;
    243     Args.pVM      = pVM;
    244     Args.offDelta = offDelta;
    245 
    246227    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesHC->IOPortTreeGC, true, iomr3RelocateIOPortCallback, &offDelta);
    247     RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesHC->MMIOTree, true, iomr3RelocateMMIOCallback, &Args);
     228    RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesHC->MMIOTree, true, iomr3RelocateMMIOCallback, &offDelta);
    248229
    249230    if (pVM->iom.s.pfnMMIOHandlerGC)
    … …  
    307288static DECLCALLBACK(int) iomr3RelocateMMIOCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser)
    308289{
    309     PIOMMMIORANGE        pRange     = (PIOMMMIORANGE)pNode;
    310     PIOMMMIOCALLBACKARGS pArgs      = (PIOMMMIOCALLBACKARGS)pvUser;
    311     PVM                  pVM        = pArgs->pVM;
    312     RTGCINTPTR           offDelta   = pArgs->offDelta;
    313 
    314     for (uint32_t i = 0; i < pVM->cCPUs; i++)
    315     {
    316         if (pRange->a[i].pDevInsGC)
    317             pRange->a[i].pDevInsGC  += offDelta;
    318         if (pRange->a[i].pvUserGC > _64K)
    319             pRange->a[i].pvUserGC   += offDelta;
    320     }
     290    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pNode;
     291    RTGCINTPTR    offDelta = *(PRTGCINTPTR)pvUser;
     292
     293    if (pRange->pDevInsGC)
     294        pRange->pDevInsGC           += offDelta;
    321295    if (pRange->pfnWriteCallbackGC)
    322296        pRange->pfnWriteCallbackGC  += offDelta;
    … …  
    325299    if (pRange->pfnFillCallbackGC)
    326300        pRange->pfnFillCallbackGC   += offDelta;
     301    if (pRange->pvUserGC > _64K)
     302        pRange->pvUserGC            += offDelta;
    327303
    328304    return 0;
    … …  
    14121388 * @param   pVM                 VM handle.
    14131389 * @param   pDevIns             PDM device instance owning the MMIO range.
    1414  * @param   enmCtx              CPU id or IOMMMIOCTX_GLOBAL if it's a global registration (applies to all CPUs)
    14151390 * @param   GCPhysStart         First physical address in the range.
    14161391 * @param   cbRange             The size of the range (in bytes).
    … …  
    14211396 * @param   pszDesc             Pointer to description string. This must not be freed.
    14221397 */
    1423 IOMR3DECL(int)  IOMR3MMIORegisterR3(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
     1398IOMR3DECL(int)  IOMR3MMIORegisterR3(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
    14241399                                    R3PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, R3PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    14251400                                    R3PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
    14261401{
    1427     LogFlow(("IOMR3MMIORegisterR3: pDevIns=%p CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
    1428              pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
     1402    LogFlow(("IOMR3MMIORegisterR3: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
     1403             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
    14291404    int rc;
    14301405
    … …  
    14371412        return VERR_IOM_INVALID_MMIO_RANGE;
    14381413    }
    1439 
    1440     AssertReturn(enmCtx == IOMMMIOCTX_GLOBAL || (unsigned)enmCtx < pVM->cCPUs, VERR_INVALID_PARAMETER);
    14411414
    14421415    /*
    … …  
    14551428     */
    14561429    PIOMMMIORANGE pRange;
    1457     if (    enmCtx == IOMMMIOCTX_CPU0
    1458         ||  enmCtx == IOMMMIOCTX_GLOBAL)
    1459     {
    1460         unsigned cb = enmCtx == IOMMMIOCTX_GLOBAL
    1461                     ? RT_OFFSETOF(IOMMMIORANGE, a[pVM->cCPUs])
    1462                     : RT_OFFSETOF(IOMMMIORANGE, a[1]);
    1463         rc = MMHyperAlloc(pVM, cb, 0, MM_TAG_IOM, (void **)&pRange);
    1464         if (VBOX_SUCCESS(rc))
     1430    rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
     1431    if (VBOX_SUCCESS(rc))
     1432    {
     1433        pRange->Core.Key            = GCPhysStart;
     1434        pRange->Core.KeyLast        = GCPhysStart + (cbRange - 1);
     1435        pRange->GCPhys              = GCPhysStart;
     1436        pRange->cb                  = cbRange;
     1437        pRange->pszDesc             = pszDesc;
     1438
     1439        pRange->pvUserR3            = pvUser;
     1440        pRange->pDevInsR3           = pDevIns;
     1441        pRange->pfnReadCallbackR3   = pfnReadCallback;
     1442        pRange->pfnWriteCallbackR3  = pfnWriteCallback;
     1443        pRange->pfnFillCallbackR3   = pfnFillCallback;
     1444
     1445        //pRange->pvUserR0            = NIL_RTR0PTR;
     1446        //pRange->pDevInsR0           = NIL_RTR0PTR;
     1447        //pRange->pfnReadCallbackR0   = NIL_RTR0PTR;
     1448        //pRange->pfnWriteCallbackR0  = NIL_RTR0PTR;
     1449        //pRange->pfnFillCallbackR0   = NIL_RTR0PTR;
     1450
     1451        //pRange->pvUserGC            = NIL_RTGCPTR;
     1452        //pRange->pDevInsGC           = NIL_RTGCPTR;
     1453        //pRange->pfnReadCallbackGC   = NIL_RTGCPTR;
     1454        //pRange->pfnWriteCallbackGC  = NIL_RTGCPTR;
     1455        //pRange->pfnFillCallbackGC   = NIL_RTGCPTR;
     1456
     1457        /*
     1458         * Try register it with PGM and then insert it into the tree.
     1459         */
     1460        rc = PGMR3PhysMMIORegister(pVM, GCPhysStart, cbRange,
     1461                                   IOMR3MMIOHandler, pRange,
     1462                                   pVM->iom.s.pfnMMIOHandlerR0, MMHyperR3ToR0(pVM, pRange),
     1463                                   pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToRC(pVM, pRange), pszDesc);
     1464        if (RT_SUCCESS(rc))
    14651465        {
    1466             pRange->Core.Key            = GCPhysStart;
    1467             pRange->Core.KeyLast        = GCPhysStart + (cbRange - 1);
    1468             pRange->GCPhys              = GCPhysStart;
    1469             pRange->cb                  = cbRange;
    1470             pRange->pszDesc             = pszDesc;
    1471             pRange->enmCtx              = enmCtx;
    1472 
    1473             pRange->a[0].pvUserR3       = pvUser;
    1474             pRange->a[0].pDevInsR3      = pDevIns;
    1475             pRange->pfnReadCallbackR3   = pfnReadCallback;
    1476             pRange->pfnWriteCallbackR3  = pfnWriteCallback;
    1477             pRange->pfnFillCallbackR3   = pfnFillCallback;
    1478 
    1479             //pRange->a[0].pvUserR0       = NIL_RTR0PTR;
    1480             //pRange->a[0].pDevInsR0      = NIL_RTR0PTR;
    1481             //pRange->pfnReadCallbackR0   = NIL_RTR0PTR;
    1482             //pRange->pfnWriteCallbackR0  = NIL_RTR0PTR;
    1483             //pRange->pfnFillCallbackR0   = NIL_RTR0PTR;
    1484 
    1485             //pRange->a[0].pvUserGC       = NIL_RTGCPTR;
    1486             //pRange->a[0].pDevInsGC      = NIL_RTGCPTR;
    1487             //pRange->pfnReadCallbackGC   = NIL_RTGCPTR;
    1488             //pRange->pfnWriteCallbackGC  = NIL_RTGCPTR;
    1489             //pRange->pfnFillCallbackGC   = NIL_RTGCPTR;
    1490 
    1491             /*
    1492              * Try register it with PGM and then insert it into the tree.
    1493              */
    1494             rc = PGMR3PhysMMIORegister(pVM, GCPhysStart, cbRange,
    1495                                        IOMR3MMIOHandler, pRange,
    1496                                        pVM->iom.s.pfnMMIOHandlerR0, MMHyperR3ToR0(pVM, pRange),
    1497                                        pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToRC(pVM, pRange), pszDesc);
    1498             if (RT_SUCCESS(rc))
    1499             {
    1500                 if (RTAvlroGCPhysInsert(&pVM->iom.s.pTreesHC->MMIOTree, &pRange->Core))
    1501                     return VINF_SUCCESS;
    1502 
    1503                 DBGFR3Info(pVM, "mmio", NULL, NULL);
    1504                 AssertMsgFailed(("This cannot happen!\n"));
    1505                 rc = VERR_INTERNAL_ERROR;
    1506             }
    1507             MMHyperFree(pVM, pRange);
     1466            if (RTAvlroGCPhysInsert(&pVM->iom.s.pTreesHC->MMIOTree, &pRange->Core))
     1467                return VINF_SUCCESS;
     1468
     1469            DBGFR3Info(pVM, "mmio", NULL, NULL);
     1470            AssertMsgFailed(("This cannot happen!\n"));
     1471            rc = VERR_INTERNAL_ERROR;
    15081472        }
    1509     }
    1510     else
    1511     {
    1512         /*
    1513          * Local MMIO registration for CPU > 0.
    1514          */
    1515         /** @todo SMP - this is incomplete and won't work. */
    1516         pRange = iomMMIOGetRange(&pVM->iom.s, GCPhysStart);
    1517         if (!pRange)
    1518         {
    1519             /* allocate new range like above... */
    1520             AssertReturn(pRange, VERR_IOM_MMIO_RANGE_NOT_FOUND);
    1521         }
    1522         else
    1523         {
    1524             /* add ourselves to the range we found *if* the handlers and stuff matches. */
    1525             AssertReturn(pRange->GCPhys == GCPhysStart, VERR_IOM_INVALID_MMIO_RANGE);
    1526             AssertReturn(pRange->cb == cbRange, VERR_IOM_INVALID_MMIO_RANGE);
    1527             AssertReturn(pRange->enmCtx == IOMMMIOCTX_CPU0, VERR_IOM_INVALID_MMIO_RANGE);
    1528 
    1529             pRange->a[enmCtx].pvUserR3  = pvUser;
    1530             pRange->a[enmCtx].pDevInsR3 = pDevIns;
    1531         }
    1532 
    1533         rc = VINF_SUCCESS;
     1473        MMHyperFree(pVM, pRange);
    15341474    }
    15351475
    … …  
    15491489 * @param   pVM                 VM handle.
    15501490 * @param   pDevIns             PDM device instance owning the MMIO range.
    1551  * @param   enmCtx              CPU id or IOMMMIOCTX_GLOBAL if it's a global registration (applies to all CPUs)
    15521491 * @param   GCPhysStart         First physical address in the range.
    15531492 * @param   cbRange             The size of the range (in bytes).
    … …  
    15571496 * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
    15581497 */
    1559 IOMR3DECL(int)  IOMR3MMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
     1498IOMR3DECL(int)  IOMR3MMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    15601499                                    RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, RCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    15611500                                    RCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback)
    15621501{
    1563     LogFlow(("IOMR3MMIORegisterGC: pDevIns=%p CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
    1564              pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback));
     1502    LogFlow(("IOMR3MMIORegisterGC: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
     1503             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback));
    15651504
    15661505    /*
    … …  
    15731512    }
    15741513
    1575     AssertReturn(enmCtx == IOMMMIOCTX_GLOBAL || (unsigned)enmCtx < pVM->cCPUs, VERR_INVALID_PARAMETER);
    1576 
    15771514    /*
    15781515     * Find the MMIO range and check that the input matches.
    … …  
    15801517    PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhysStart);
    15811518    AssertReturn(pRange, VERR_IOM_MMIO_RANGE_NOT_FOUND);
    1582     AssertReturn(enmCtx != IOMMMIOCTX_GLOBAL || pRange->a[0].pDevInsR3 == pDevIns, VERR_IOM_NOT_MMIO_RANGE_OWNER);
     1519    AssertReturn(pRange->pDevInsR3 == pDevIns, VERR_IOM_NOT_MMIO_RANGE_OWNER);
    15831520    AssertReturn(pRange->GCPhys == GCPhysStart, VERR_IOM_INVALID_MMIO_RANGE);
    15841521    AssertReturn(pRange->cb == cbRange, VERR_IOM_INVALID_MMIO_RANGE);
    1585     AssertReturn(pRange->enmCtx == IOMMMIOCTX_CPU0 || pRange->enmCtx == IOMMMIOCTX_GLOBAL, VERR_IOM_INVALID_MMIO_RANGE);
    1586 
    1587     if (enmCtx == IOMMMIOCTX_GLOBAL)
    1588         enmCtx = IOMMMIOCTX_CPU0;
    1589 
    1590     pRange->a[enmCtx].pvUserGC  = pvUser;
    1591     pRange->pfnReadCallbackGC   = pfnReadCallback;
    1592     pRange->pfnWriteCallbackGC  = pfnWriteCallback;
    1593     pRange->pfnFillCallbackGC   = pfnFillCallback;
    1594     pRange->a[enmCtx].pDevInsGC = MMHyperCCToRC(pVM, pDevIns);
     1522
     1523    pRange->pvUserGC          = pvUser;
     1524    pRange->pfnReadCallbackGC = pfnReadCallback;
     1525    pRange->pfnWriteCallbackGC= pfnWriteCallback;
     1526    pRange->pfnFillCallbackGC = pfnFillCallback;
     1527    pRange->pDevInsGC         = MMHyperCCToRC(pVM, pDevIns);
    15951528
    15961529    return VINF_SUCCESS;
    … …  
    16091542 * @param   pVM                 VM handle.
    16101543 * @param   pDevIns             PDM device instance owning the MMIO range.
    1611  * @param   enmCtx              CPU id or IOMMMIOCTX_GLOBAL if it's a global registration (applies to all CPUs)
    16121544 * @param   GCPhysStart         First physical address in the range.
    16131545 * @param   cbRange             The size of the range (in bytes).
    … …  
    16171549 * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
    16181550 */
    1619 IOMR3DECL(int)  IOMR3MMIORegisterR0(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
     1551IOMR3DECL(int)  IOMR3MMIORegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
    16201552                                    R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback,
    16211553                                    R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    16221554                                    R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback)
    16231555{
    1624     LogFlow(("IOMR3MMIORegisterR0: pDevIns=%p CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
    1625              pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback));
     1556    LogFlow(("IOMR3MMIORegisterR0: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
     1557             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback));
    16261558
    16271559    /*
    … …  
    16341566    }
    16351567
    1636     AssertReturn(enmCtx == IOMMMIOCTX_GLOBAL || (unsigned)enmCtx < pVM->cCPUs, VERR_INVALID_PARAMETER);
    1637 
    16381568    /*
    16391569     * Find the MMIO range and check that the input matches.
    … …  
    16411571    PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhysStart);
    16421572    AssertReturn(pRange, VERR_IOM_MMIO_RANGE_NOT_FOUND);
    1643     AssertReturn(enmCtx != IOMMMIOCTX_GLOBAL || pRange->a[0].pDevInsR3 == pDevIns, VERR_IOM_NOT_MMIO_RANGE_OWNER);
     1573    AssertReturn(pRange->pDevInsR3 == pDevIns, VERR_IOM_NOT_MMIO_RANGE_OWNER);
    16441574    AssertReturn(pRange->GCPhys == GCPhysStart, VERR_IOM_INVALID_MMIO_RANGE);
    16451575    AssertReturn(pRange->cb == cbRange, VERR_IOM_INVALID_MMIO_RANGE);
    1646     AssertReturn(pRange->enmCtx == IOMMMIOCTX_CPU0 || pRange->enmCtx == IOMMMIOCTX_GLOBAL, VERR_IOM_INVALID_MMIO_RANGE);
    1647 
    1648     if (enmCtx == IOMMMIOCTX_GLOBAL)
    1649         enmCtx = IOMMMIOCTX_CPU0;
    1650 
    1651     pRange->a[enmCtx].pvUserR0  = pvUser;
    1652     pRange->pfnReadCallbackR0   = pfnReadCallback;
    1653     pRange->pfnWriteCallbackR0  = pfnWriteCallback;
    1654     pRange->pfnFillCallbackR0   = pfnFillCallback;
    1655     pRange->a[enmCtx].pDevInsR0 = MMHyperCCToR0(pVM, pDevIns);
     1576
     1577    pRange->pvUserR0          = pvUser;
     1578    pRange->pfnReadCallbackR0 = pfnReadCallback;
     1579    pRange->pfnWriteCallbackR0= pfnWriteCallback;
     1580    pRange->pfnFillCallbackR0 = pfnFillCallback;
     1581    pRange->pDevInsR0         = MMHyperCCToR0(pVM, pDevIns);
    16561582
    16571583    return VINF_SUCCESS;
    … …  
    16681594 * @param   pVM                 The virtual machine.
    16691595 * @param   pDevIns             Device instance which the MMIO region is registered.
    1670  * @param   enmCtx              CPU id or IOMMMIOCTX_GLOBAL if it's a global registration (applies to all CPUs)
    16711596 * @param   GCPhysStart         First physical address (GC) in the range.
    16721597 * @param   cbRange             Number of bytes to deregister.
    … …  
    16751600 *          all the checks you might expect it to do.
    16761601 */
    1677 IOMR3DECL(int)  IOMR3MMIODeregister(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange)
    1678 {
    1679     LogFlow(("IOMR3MMIODeregister: pDevIns=%p CPU=%d GCPhysStart=%VGp cbRange=%#x\n", pDevIns, enmCtx, GCPhysStart, cbRange));
     1602IOMR3DECL(int)  IOMR3MMIODeregister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
     1603{
     1604    LogFlow(("IOMR3MMIODeregister: pDevIns=%p GCPhysStart=%VGp cbRange=%#x\n", pDevIns, GCPhysStart, cbRange));
    16801605
    16811606    /*
    … …  
    16881613        return VERR_IOM_INVALID_MMIO_RANGE;
    16891614    }
    1690 
    1691     /** @todo SMP. */
    1692     /* Ignore local registrations. This assumes all instances will get unregistered! */
    1693     if (    enmCtx != IOMMMIOCTX_GLOBAL
    1694         &&  enmCtx != IOMMMIOCTX_CPU0)
    1695         return VINF_SUCCESS;
    16961615
    16971616    /*
    … …  
    17041623        if (!pRange)
    17051624            return VERR_IOM_MMIO_RANGE_NOT_FOUND;
    1706         AssertMsgReturn(pRange->a[0].pDevInsR3 == pDevIns,
     1625        AssertMsgReturn(pRange->pDevInsR3 == pDevIns,
    17071626                        ("Not owner! GCPhys=%VGp %VGp LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pRange->pszDesc),
    17081627                        VERR_IOM_NOT_MMIO_RANGE_OWNER);
    … …  
    17551674                    pRange->Core.Key,
    17561675                    pRange->Core.KeyLast,
    1757                     pRange->a[0].pDevInsR3,
     1676                    pRange->pDevInsR3,
    17581677                    pRange->pfnReadCallbackR3,
    17591678                    pRange->pfnWriteCallbackR3,
    17601679                    pRange->pfnFillCallbackR3,
    1761                     pRange->a[0].pvUserR3,
     1680                    pRange->pvUserR3,
    17621681                    pRange->pszDesc);
    17631682    pHlp->pfnPrintf(pHlp,
    17641683                    "%*s %VHv %VHv %VHv %VHv %VHv\n",
    17651684                    sizeof(RTGCPHYS) * 2 * 2 + 1, "R0",
    1766                     pRange->a[0].pDevInsR0,
     1685                    pRange->pDevInsR0,
    17671686                    pRange->pfnReadCallbackR0,
    17681687                    pRange->pfnWriteCallbackR0,
    17691688                    pRange->pfnFillCallbackR0,
    1770                     pRange->a[0].pvUserR0);
     1689                    pRange->pvUserR0);
    17711690    pHlp->pfnPrintf(pHlp,
    17721691                    "%*s %VRv %VRv %VRv %VRv %VRv\n",
    17731692                    sizeof(RTGCPHYS) * 2 * 2 + 1, "GC",
    1774                     pRange->a[0].pDevInsGC,
     1693                    pRange->pDevInsGC,
    17751694                    pRange->pfnReadCallbackGC,
    17761695                    pRange->pfnWriteCallbackGC,
    17771696                    pRange->pfnFillCallbackGC,
    1778                     pRange->a[0].pvUserGC);
     1697                    pRange->pvUserGC);
    17791698    return 0;
    17801699}

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

    r12561 r12566  
    5353    /** Size of the range. */
    5454    uint32_t                    cb;
    55     /** MMIO registration context.
    56      * Used as a boolean with the values IOMMMIOCTX_GLOBAL or !IOMMMIOCTX_GLOBAL
    57      * for determing which entry in IOMMMIORANGE::a to access. */
    58     IOMMMIOCTX                  enmCtx;
    59 
     55    uint32_t                    u32Alignment; /**< Alignment padding. */
     56
     57    /** Pointer to user argument. */
     58    RTR3PTR                     pvUserR3;
     59    /** Pointer to device instance. */
     60    PPDMDEVINSR3                pDevInsR3;
    6061    /** Pointer to write callback function. */
    6162    R3PTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackR3;
    … …  
    6566    R3PTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackR3;
    6667
     68    /** Pointer to user argument. */
     69    RTR0PTR                     pvUserR0;
     70    /** Pointer to device instance. */
     71    PPDMDEVINSR0                pDevInsR0;
    6772    /** Pointer to write callback function. */
    6873    R0PTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackR0;
    … …  
    7277    R0PTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackR0;
    7378
     79    /** Pointer to user argument. */
     80    RCPTRTYPE(void *)           pvUserGC;
     81    /** Pointer to device instance. */
     82    PPDMDEVINSRC                pDevInsGC;
    7483    /** Pointer to write callback function. */
    7584    RCPTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackGC;
    … …  
    8392    /** Description / Name. For easing debugging. */
    8493    R3PTRTYPE(const char *)     pszDesc;
    85 
    86     /** Array of per CPU context data.
    87      * When enmCtx is IOMMMIOCTX_GLOBAL the first entry will be used.
    88      * When enmCtx is not IOMMMIOCTX_GLOBAL entries will be allocated for all CPUs
    89      * and the range will be reference counted.
    90      * @todo reference counting the range in directly or indirectly (document it
    91      *       here).
    92      */
    93     struct IOMMMIORANGECTX
    94     {
    95         /** Pointer to user argument. */
    96         RTR3PTR                     pvUserR3;
    97         /** Pointer to device instance. */
    98         PPDMDEVINSR3                pDevInsR3;
    99         /** Pointer to user argument. */
    100         RTR0PTR                     pvUserR0;
    101         /** Pointer to device instance. */
    102         PPDMDEVINSR0                pDevInsR0;
    103         /** Pointer to user argument. */
    104         RCPTRTYPE(void *)           pvUserGC;
    105         /** Pointer to device instance. */
    106         PPDMDEVINSRC                pDevInsGC;
    107     } a[1];
    10894} IOMMMIORANGE;
    10995/** Pointer to a MMIO range descriptor, R3 version. */

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

    r12561 r12566  
    9090static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTR0PTR pvUser, const char *pszOut, const char *pszIn, const char *pszOutStr, const char *pszInStr, const char *pszDesc);
    9191static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts);
    92 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
     92static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
    9393                                         PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
    9494                                         const char *pszDesc);
    95 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterGC(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
     95static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterGC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    9696                                           const char *pszWrite, const char *pszRead, const char *pszFill,
    9797                                           const char *pszDesc);
    98 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
     98static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
    9999                                           const char *pszWrite, const char *pszRead, const char *pszFill,
    100100                                           const char *pszDesc);
    101 static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange);
     101static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange);
    102102static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, const void *pvBinary, bool fShadow, const char *pszDesc);
    103103static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
    … …  
    13561356
    13571357/** @copydoc PDMDEVHLP::pfnMMIORegister */
    1358 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
     1358static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
    13591359                                                  PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
    13601360                                                  const char *pszDesc)
    … …  
    13621362    PDMDEV_ASSERT_DEVINS(pDevIns);
    13631363    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
    1364     LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
    1365              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmCtx, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
    1366 
    1367     int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMHC, pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
     1364    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
     1365             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
     1366
     1367    int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
    13681368
    13691369    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
    … …  
    13731373
    13741374/** @copydoc PDMDEVHLP::pfnMMIORegisterGC */
    1375 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterGC(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
     1375static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterGC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    13761376                                                    const char *pszWrite, const char *pszRead, const char *pszFill,
    13771377                                                    const char *pszDesc)
    … …  
    13791379    PDMDEV_ASSERT_DEVINS(pDevIns);
    13801380    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
    1381     LogFlow(("pdmR3DevHlp_MMIORegisterGC: caller='%s'/%d: CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    1382              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmCtx, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     1381    LogFlow(("pdmR3DevHlp_MMIORegisterGC: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
     1382             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    13831383
    13841384    /*
    … …  
    14021402            rc3 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszFill, &GCPtrFill);
    14031403        if (VBOX_SUCCESS(rc) && VBOX_SUCCESS(rc2) && VBOX_SUCCESS(rc3))
    1404             rc = IOMR3MMIORegisterGC(pDevIns->Internal.s.pVMHC, pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
     1404            rc = IOMR3MMIORegisterGC(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
    14051405        else
    14061406        {
    … …  
    14251425
    14261426/** @copydoc PDMDEVHLP::pfnMMIORegisterR0 */
    1427 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
     1427static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
    14281428                                                    const char *pszWrite, const char *pszRead, const char *pszFill,
    14291429                                                    const char *pszDesc)
    … …  
    14311431    PDMDEV_ASSERT_DEVINS(pDevIns);
    14321432    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
    1433     LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: CPU=%d GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    1434              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmCtx, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     1433    LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
     1434             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    14351435
    14361436    /*
    … …  
    14541454            rc3 = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszFill, &pfnR0PtrFill);
    14551455        if (VBOX_SUCCESS(rc) && VBOX_SUCCESS(rc2) && VBOX_SUCCESS(rc3))
    1456             rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMHC, pDevIns, enmCtx, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
     1456            rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
    14571457        else
    14581458        {
    … …  
    14781478
    14791479/** @copydoc PDMDEVHLP::pfnMMIODeregister */
    1480 static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, IOMMMIOCTX enmCtx, RTGCPHYS GCPhysStart, RTUINT cbRange)
     1480static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
    14811481{
    14821482    PDMDEV_ASSERT_DEVINS(pDevIns);
    14831483    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
    1484     LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: CPU=%d GCPhysStart=%VGp cbRange=%#x\n",
    1485              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmCtx, GCPhysStart, cbRange));
    1486 
    1487     int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMHC, pDevIns, enmCtx, GCPhysStart, cbRange);
     1484    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x\n",
     1485             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
     1486
     1487    int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange);
    14881488
    14891489    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
    … …  
    27242724
    27252725    /*
    2726      * Only one APIC device registration allowed. (even in the MP case)
     2726     * Only one APIC device. (malc: only in UP case actually)
    27272727     */
    27282728    PVM pVM = pDevIns->Internal.s.pVMHC;

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

    r12561 r12566  
    8484#endif
    8585
    86     unsigned idCPU = (pRange->enmCtx == IOMMMIOCTX_GLOBAL) ? 0 : pVM->idCPU;
    87     Assert(pRange->a[idCPU].CTXALLSUFF(pDevIns)); /** @todo SMP */
    88 
    8986    int rc;
    9087    if (RT_LIKELY(pRange->CTXALLSUFF(pfnWriteCallback)))
    91         rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
     88        rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
    9289    else
    9390        rc = VINF_SUCCESS;
    … …  
    107104#endif
    108105
    109     unsigned idCPU = (pRange->enmCtx == IOMMMIOCTX_GLOBAL) ? 0 : pVM->idCPU;
    110     Assert(pRange->a[idCPU].CTXALLSUFF(pDevIns)); /** @todo SMP */
    111 
    112106    int rc;
    113107    if (RT_LIKELY(pRange->CTXALLSUFF(pfnReadCallback)))
    114         rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), GCPhysFault, pvData, cb);
     108        rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhysFault, pvData, cb);
    115109    else
    116110    {
    … …  
    589583    if (pRange->CTXALLSUFF(pfnFillCallback))
    590584    {
    591         unsigned idCPU = (pRange->enmCtx == IOMMMIOCTX_GLOBAL) ? 0 : pVM->idCPU;
    592         Assert(pRange->a[idCPU].CTXALLSUFF(pDevIns));  /** @todo SMP */
    593 
    594585        /*
    595586         * Use the fill callback.
    … …  
    599590        {
    600591            /* addr++ variant. */
    601             rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), Phys, u32Data, cb, cTransfers);
     592            rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), Phys, u32Data, cb, cTransfers);
    602593            if (rc == VINF_SUCCESS)
    603594            {
    … …  
    611602        {
    612603            /* addr-- variant. */
    613             rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
     604            rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
    614605            if (rc == VINF_SUCCESS)
    615606            {
    … …  
    12771268         * Perform the read and deal with the result.
    12781269         */
    1279         unsigned idCPU = (pRange->enmCtx == IOMMMIOCTX_GLOBAL) ? 0 : pVM->idCPU;
    1280         Assert(pRange->a[idCPU].CTXALLSUFF(pDevIns)); /** @todo SMP */
    1281 
    12821270#ifdef VBOX_WITH_STATISTICS
    12831271        if (pStats)
    12841272            STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfRead), a);
    12851273#endif
    1286         int rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), GCPhys, pu32Value, cbValue);
     1274        int rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhys, pu32Value, cbValue);
    12871275#ifdef VBOX_WITH_STATISTICS
    12881276        if (pStats)
    … …  
    13871375    if (pRange->CTXALLSUFF(pfnWriteCallback))
    13881376    {
    1389         unsigned idCPU = (pRange->enmCtx == IOMMMIOCTX_GLOBAL) ? 0 : pVM->idCPU;
    1390         Assert(pRange->a[idCPU].CTXALLSUFF(pDevIns)); /** @todo SMP */
    1391 
    13921377#ifdef VBOX_WITH_STATISTICS
    13931378        if (pStats)
    13941379            STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfWrite), a);
    13951380#endif
    1396         int rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->a[idCPU].CTXALLSUFF(pDevIns), pRange->a[idCPU].CTXALLSUFF(pvUser), GCPhys, &u32Value, cbValue);
     1381        int rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhys, &u32Value, cbValue);
    13971382#ifdef VBOX_WITH_STATISTICS
    13981383        if (pStats)

  • trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

    r12561 r12566  
    139139    GEN_CHECK_OFF(IOMMMIORANGE, cb);
    140140    GEN_CHECK_OFF(IOMMMIORANGE, pszDesc);
    141     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pvUserR3);
    142     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pDevInsR3);
     141    GEN_CHECK_OFF(IOMMMIORANGE, pvUserR3);
     142    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR3);
    143143    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR3);
    144144    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR3);
    145145    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR3);
    146     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pvUserR0);
    147     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pDevInsR0);
     146    GEN_CHECK_OFF(IOMMMIORANGE, pvUserR0);
     147    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR0);
    148148    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR0);
    149149    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR0);
    150150    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR0);
    151     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pvUserGC);
    152     GEN_CHECK_OFF(IOMMMIORANGE, a[0].pDevInsGC);
     151    GEN_CHECK_OFF(IOMMMIORANGE, pvUserGC);
     152    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsGC);
    153153    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackGC);
    154154    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackGC);
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