VirtualBox

Changeset 10202

Show
Ignore:
Timestamp:
07/04/08 09:25:27 (2 months ago)
Author:
vboxsync
Message:

removed VBOX_WITH_PDM_LOCK

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/Config.kmk

    r10200 r10202  
    771771endif 
    772772## @todo eliminate these guys. 
    773 ifdef VBOX_WITH_PDM_LOCK 
    774  DEFS += VBOX_WITH_PDM_LOCK 
    775 endif 
    776773ifdef VBOX_WITH_INTERNAL_NETWORKING 
    777774DEFS += VBOX_WITH_INTERNAL_NETWORKING 
  • trunk/include/VBox/pdmdev.h

    r9898 r10202  
    532532    DECLGCCALLBACKMEMBER(void,  pfnIoApicSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel)); 
    533533 
    534 #ifdef VBOX_WITH_PDM_LOCK 
    535534    /** 
    536535     * Acquires the PDM lock. 
     
    549548     */ 
    550549    DECLGCCALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    551 #endif 
     550 
    552551    /** Just a safety precaution. */ 
    553552    uint32_t                    u32TheEnd; 
     
    590589    DECLR0CALLBACKMEMBER(void,  pfnIoApicSetIrq,(PPDMDEVINS pDevIns, int iIrq, int iLevel)); 
    591590 
    592 #ifdef VBOX_WITH_PDM_LOCK 
    593591    /** 
    594592     * Acquires the PDM lock. 
     
    607605     */ 
    608606    DECLR0CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    609 #endif 
    610607 
    611608    /** Just a safety precaution. */ 
     
    682679    DECLR3CALLBACKMEMBER(PCPDMPCIHLPR0, pfnGetR0Helpers,(PPDMDEVINS pDevIns)); 
    683680 
    684 #ifdef VBOX_WITH_PDM_LOCK 
    685681    /** 
    686682     * Acquires the PDM lock. 
     
    699695     */ 
    700696    DECLR3CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    701 #endif 
    702697 
    703698    /** Just a safety precaution. */ 
     
    776771    DECLGCCALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns)); 
    777772 
    778 #ifdef VBOX_WITH_PDM_LOCK 
    779773    /** 
    780774     * Acquires the PDM lock. 
     
    793787     */ 
    794788    DECLGCCALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    795 #endif 
     789 
    796790    /** Just a safety precaution. */ 
    797791    uint32_t                u32TheEnd; 
     
    829823    DECLR0CALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns)); 
    830824 
    831 #ifdef VBOX_WITH_PDM_LOCK 
    832825    /** 
    833826     * Acquires the PDM lock. 
     
    846839     */ 
    847840    DECLR0CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    848 #endif 
    849841 
    850842    /** Just a safety precaution. */ 
     
    882874    DECLR3CALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns)); 
    883875 
    884 #ifdef VBOX_WITH_PDM_LOCK 
    885876    /** 
    886877     * Acquires the PDM lock. 
     
    899890     */ 
    900891    DECLR3CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    901 #endif 
    902892 
    903893    /** 
     
    10701060    DECLGCCALLBACKMEMBER(void, pfnChangeFeature,(PPDMDEVINS pDevIns, bool fEnabled)); 
    10711061 
    1072 #ifdef VBOX_WITH_PDM_LOCK 
    10731062    /** 
    10741063     * Acquires the PDM lock. 
     
    10871076     */ 
    10881077    DECLGCCALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1089 #endif 
     1078 
    10901079    /** Just a safety precaution. */ 
    10911080    uint32_t                u32TheEnd; 
     
    11301119    DECLR0CALLBACKMEMBER(void, pfnChangeFeature,(PPDMDEVINS pDevIns, bool fEnabled)); 
    11311120 
    1132 #ifdef VBOX_WITH_PDM_LOCK 
    11331121    /** 
    11341122     * Acquires the PDM lock. 
     
    11471135     */ 
    11481136    DECLR0CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1149 #endif 
    11501137 
    11511138    /** Just a safety precaution. */ 
     
    11901177    DECLR3CALLBACKMEMBER(void, pfnChangeFeature,(PPDMDEVINS pDevIns, bool fEnabled)); 
    11911178 
    1192 #ifdef VBOX_WITH_PDM_LOCK 
    11931179    /** 
    11941180     * Acquires the PDM lock. 
     
    12071193     */ 
    12081194    DECLR3CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1209 #endif 
    12101195 
    12111196    /** 
     
    12981283                                                  uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode)); 
    12991284 
    1300 #ifdef VBOX_WITH_PDM_LOCK 
    13011285    /** 
    13021286     * Acquires the PDM lock. 
     
    13151299     */ 
    13161300    DECLGCCALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1317 #endif 
    13181301 
    13191302    /** Just a safety precaution. */ 
     
    13541337                                                  uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode)); 
    13551338 
    1356 #ifdef VBOX_WITH_PDM_LOCK 
    13571339    /** 
    13581340     * Acquires the PDM lock. 
     
    13711353     */ 
    13721354    DECLR0CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1373 #endif 
    13741355 
    13751356    /** Just a safety precaution. */ 
     
    14091390                                                  uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode)); 
    14101391 
    1411 #ifdef VBOX_WITH_PDM_LOCK 
    14121392    /** 
    14131393     * Acquires the PDM lock. 
     
    14261406     */ 
    14271407    DECLR3CALLBACKMEMBER(void,  pfnUnlock,(PPDMDEVINS pDevIns)); 
    1428 #endif 
    14291408 
    14301409    /** 
  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r8155 r10202  
    6666/** @def PCI_UNLOCK 
    6767 * Releases the PDM lock. This is a NOP if locking is disabled. */ 
    68 #ifdef VBOX_WITH_PDM_LOCK 
    69 # define PCI_LOCK(pDevIns, rc) \ 
     68#define PCI_LOCK(pDevIns, rc) \ 
    7069    do { \ 
    7170        int rc2 = PDMINS2DATA(pDevIns, PCIBus *)->CTXALLSUFF(pPciHlp)->pfnLock((pDevIns), rc); \ 
     
    7372            return rc2; \ 
    7473    } while (0) 
    75 # define PCI_UNLOCK(pDevIns) \ 
     74#define PCI_UNLOCK(pDevIns) \ 
    7675    PDMINS2DATA(pDevIns, PCIBus *)->CTXALLSUFF(pPciHlp)->pfnUnlock(pDevIns) 
    77 #else /* !VBOX_WITH_PDM_LOCK */ 
    78 # define PCI_LOCK(pThis, rc)   do { } while (0) 
    79 # define PCI_UNLOCK(pThis)     do { } while (0) 
    80 #endif /* !VBOX_WITH_PDM_LOCK */ 
    8176 
    8277 
  • trunk/src/VBox/Devices/PC/DevAPIC.cpp

    r8155 r10202  
    6262/** @def IOAPIC_UNLOCK 
    6363 * Releases the PDM lock. This is a NOP if locking is disabled. */ 
    64 #ifdef VBOX_WITH_PDM_LOCK 
    65 # define APIC_LOCK(pThis, rc) \ 
     64#define APIC_LOCK(pThis, rc) \ 
    6665    do { \ 
    6766        int rc2 = (pThis)->CTXALLSUFF(pApicHlp)->pfnLock((pThis)->CTXSUFF(pDevIns), rc); \ 
     
    6968            return rc2; \ 
    7069    } while (0) 
    71 # define APIC_UNLOCK(pThis) \ 
     70#define APIC_UNLOCK(pThis) \ 
    7271    (pThis)->CTXALLSUFF(pApicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns)) 
    73 # define IOAPIC_LOCK(pThis, rc) \ 
     72#define IOAPIC_LOCK(pThis, rc) \ 
    7473    do { \ 
    7574        int rc2 = (pThis)->CTXALLSUFF(pIoApicHlp)->pfnLock((pThis)->CTXSUFF(pDevIns), rc); \ 
     
    7776            return rc2; \ 
    7877    } while (0) 
    79 # define IOAPIC_UNLOCK(pThis) (pThis)->CTXALLSUFF(pIoApicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns)) 
    80 #else /* !VBOX_WITH_PDM_LOCK */ 
    81 # define APIC_LOCK(pThis, rc)   do { } while (0) 
    82 # define APIC_UNLOCK(pThis)     do { } while (0) 
    83 # define IOAPIC_LOCK(pThis, rc) do { } while (0) 
    84 # define IOAPIC_UNLOCK(pThis)   do { } while (0) 
    85 #endif /* !VBOX_WITH_PDM_LOCK */ 
     78#define IOAPIC_UNLOCK(pThis) (pThis)->CTXALLSUFF(pIoApicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns)) 
    8679 
    8780 
     
    828821{ 
    829822    APICState *s = PDMINS2DATA(pDevIns, APICState *); 
    830 # ifdef VBOX_WITH_PDM_LOCK 
    831823    s->pApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR); 
    832 # endif 
    833824#endif /* VBOX */ 
    834825 
     
    16101601{ 
    16111602    APICState *s = PDMINS2DATA(pDevIns, APICState *); 
    1612 #ifdef VBOX_WITH_PDM_LOCK 
    16131603    s->pApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR); 
    1614 #endif 
    16151604    apic_reset(s); 
    16161605    /* Clear any pending APIC interrupt action flag. */ 
     
    19561945{ 
    19571946    IOAPICState *s = PDMINS2DATA(pDevIns, IOAPICState *); 
    1958 #ifdef VBOX_WITH_PDM_LOCK 
    19591947    s->pIoApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR); 
    1960 #endif 
    19611948    ioapic_reset(s); 
    19621949    IOAPIC_UNLOCK(s); 
  • trunk/src/VBox/Devices/PC/DevPIC.cpp

    r9387 r10202  
    3838/** @def PIC_UNLOCK 
    3939 * Releases the PDM lock. This is a NOP if locking is disabled. */ 
    40 #ifdef VBOX_WITH_PDM_LOCK 
    41 # define PIC_LOCK(pThis, rc) \ 
     40#define PIC_LOCK(pThis, rc) \ 
    4241    do { \ 
    4342        int rc2 = (pThis)->CTXALLSUFF(pPicHlp)->pfnLock((pThis)->CTXSUFF(pDevIns), rc); \ 
     
    4544            return rc2; \ 
    4645    } while (0) 
    47 # define PIC_UNLOCK(pThis) \ 
     46#define PIC_UNLOCK(pThis) \ 
    4847    (pThis)->CTXALLSUFF(pPicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns)) 
    49 #else /* !VBOX_WITH_PDM_LOCK */ 
    50 # define PIC_LOCK(pThis, rc)   do { } while (0) 
    51 # define PIC_UNLOCK(pThis)     do { } while (0) 
    52 #endif /* !VBOX_WITH_PDM_LOCK */ 
    5348 
    5449 
     
    890885    unsigned    i; 
    891886    LogFlow(("picReset:\n")); 
    892 #ifdef VBOX_WITH_PDM_LOCK 
    893887    pData->pPicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR); 
    894 #endif 
    895888 
    896889    for (i = 0; i < ELEMENTS(pData->aPics); i++) 
  • trunk/src/VBox/VMM/PDM.cpp

    r9212 r10202  
    194194    if (VBOX_SUCCESS(rc)) 
    195195    { 
    196 #ifdef VBOX_WITH_PDM_LOCK 
    197196        rc = PDMR3CritSectInit(pVM, &pVM->pdm.s.CritSect, "PDM"); 
    198197        if (VBOX_SUCCESS(rc)) 
    199 #endif 
    200198            rc = pdmR3LdrInitU(pVM->pUVM); 
    201199        if (VBOX_SUCCESS(rc)) 
     
    453451    pdmR3LdrTermU(pVM->pUVM); 
    454452 
    455 #ifdef VBOX_WITH_PDM_LOCK 
    456453    /* 
    457454     * Destroy the PDM lock. 
    458455     */ 
    459456    PDMR3CritSectDelete(&pVM->pdm.s.CritSect); 
    460 #endif 
    461457 
    462458    LogFlow(("PDMR3Term: returns %Vrc\n", VINF_SUCCESS)); 
     
    11891185PDMR3DECL(int) PDMR3LockCall(PVM pVM) 
    11901186{ 
    1191 #ifdef VBOX_WITH_PDM_LOCK 
    11921187    return PDMR3CritSectEnterEx(&pVM->pdm.s.CritSect, true /* fHostCall */); 
    1193 #else 
    1194     return VINF_SUCCESS; 
    1195 #endif 
    1196 
    1197  
     1188
     1189 
  • trunk/src/VBox/VMM/PDMDevice.cpp

    r9293 r10202  
    220220static DECLCALLBACK(void) pdmR3PicHlp_SetInterruptFF(PPDMDEVINS pDevIns); 
    221221static DECLCALLBACK(void) pdmR3PicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    222 #ifdef VBOX_WITH_PDM_LOCK 
    223222static DECLCALLBACK(int) pdmR3PicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    224223static DECLCALLBACK(void) pdmR3PicHlp_Unlock(PPDMDEVINS pDevIns); 
    225 #endif 
    226224static DECLCALLBACK(PCPDMPICHLPGC) pdmR3PicHlp_GetGCHelpers(PPDMDEVINS pDevIns); 
    227225static DECLCALLBACK(PCPDMPICHLPR0) pdmR3PicHlp_GetR0Helpers(PPDMDEVINS pDevIns); 
     
    235233static DECLCALLBACK(void) pdmR3ApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    236234static DECLCALLBACK(void) pdmR3ApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled); 
    237 #ifdef VBOX_WITH_PDM_LOCK 
    238235static DECLCALLBACK(int) pdmR3ApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    239236static DECLCALLBACK(void) pdmR3ApicHlp_Unlock(PPDMDEVINS pDevIns); 
    240 #endif 
    241237static DECLCALLBACK(PCPDMAPICHLPGC) pdmR3ApicHlp_GetGCHelpers(PPDMDEVINS pDevIns); 
    242238static DECLCALLBACK(PCPDMAPICHLPR0) pdmR3ApicHlp_GetR0Helpers(PPDMDEVINS pDevIns); 
     
    249245static DECLCALLBACK(void) pdmR3IoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode, 
    250246                                                        uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode); 
    251 #ifdef VBOX_WITH_PDM_LOCK 
    252247static DECLCALLBACK(int) pdmR3IoApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    253248static DECLCALLBACK(void) pdmR3IoApicHlp_Unlock(PPDMDEVINS pDevIns); 
    254 #endif 
    255249static DECLCALLBACK(PCPDMIOAPICHLPGC) pdmR3IoApicHlp_GetGCHelpers(PPDMDEVINS pDevIns); 
    256250static DECLCALLBACK(PCPDMIOAPICHLPR0) pdmR3IoApicHlp_GetR0Helpers(PPDMDEVINS pDevIns); 
     
    264258static DECLCALLBACK(void) pdmR3PciHlp_IoApicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel); 
    265259static DECLCALLBACK(bool) pdmR3PciHlp_IsMMIO2Base(PPDMDEVINS pDevIns, PPDMDEVINS pOwner, RTGCPHYS GCPhys); 
    266 #ifdef VBOX_WITH_PDM_LOCK 
    267260static DECLCALLBACK(int) pdmR3PciHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    268261static DECLCALLBACK(void) pdmR3PciHlp_Unlock(PPDMDEVINS pDevIns); 
    269 #endif 
    270262static DECLCALLBACK(PCPDMPCIHLPGC) pdmR3PciHlp_GetGCHelpers(PPDMDEVINS pDevIns); 
    271263static DECLCALLBACK(PCPDMPCIHLPR0) pdmR3PciHlp_GetR0Helpers(PPDMDEVINS pDevIns); 
     
    494486    pdmR3PicHlp_SetInterruptFF, 
    495487    pdmR3PicHlp_ClearInterruptFF, 
    496 #ifdef VBOX_WITH_PDM_LOCK 
    497488    pdmR3PicHlp_Lock, 
    498489    pdmR3PicHlp_Unlock, 
    499 #endif 
    500490    pdmR3PicHlp_GetGCHelpers, 
    501491    pdmR3PicHlp_GetR0Helpers, 
     
    513503    pdmR3ApicHlp_ClearInterruptFF, 
    514504    pdmR3ApicHlp_ChangeFeature, 
    515 #ifdef VBOX_WITH_PDM_LOCK 
    516505    pdmR3ApicHlp_Lock, 
    517506    pdmR3ApicHlp_Unlock, 
    518 #endif 
    519507    pdmR3ApicHlp_GetGCHelpers, 
    520508    pdmR3ApicHlp_GetR0Helpers, 
     
    530518    PDM_IOAPICHLPR3_VERSION, 
    531519    pdmR3IoApicHlp_ApicBusDeliver, 
    532 #ifdef VBOX_WITH_PDM_LOCK 
    533520    pdmR3IoApicHlp_Lock, 
    534521    pdmR3IoApicHlp_Unlock, 
    535 #endif 
    536522    pdmR3IoApicHlp_GetGCHelpers, 
    537523    pdmR3IoApicHlp_GetR0Helpers, 
     
    551537    pdmR3PciHlp_GetGCHelpers, 
    552538    pdmR3PciHlp_GetR0Helpers, 
    553 #ifdef VBOX_WITH_PDM_LOCK 
    554539    pdmR3PciHlp_Lock, 
    555540    pdmR3PciHlp_Unlock, 
    556 #endif 
    557541    PDM_PCIHLPR3_VERSION, /* the end */ 
    558542}; 
     
    18091793        PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC; /** @todo the bus should be associated with the PCI device not the PDM device. */ 
    18101794        Assert(pBus); 
    1811 #ifdef VBOX_WITH_PDM_LOCK 
    18121795        PVM pVM = pDevIns->Internal.s.pVMHC; 
    18131796        pdmLock(pVM); 
    18141797        pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel); 
    18151798        pdmUnlock(pVM); 
    1816  
    1817 #else /* !VBOX_WITH_PDM_LOCK */ 
    1818         /* 
    1819          * For the convenience of the device we put no thread restriction on this interface. 
    1820          * That means we'll have to check which thread we're in and choose our path. 
    1821          */ 
    1822         if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC)) 
    1823             pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel); 
    1824         else 
    1825         { 
    1826             Log(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: Requesting call in EMT...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1827             PVMREQ pReq; 
    1828             int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMHC, &pReq, RT_INDEFINITE_WAIT, 
    1829                                      (PFNRT)pBus->pfnSetIrqR3, 4, pBus->pDevInsR3, pPciDev, iIrq, iLevel); 
    1830             while (rc == VERR_TIMEOUT) 
    1831                 rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT); 
    1832             AssertReleaseRC(rc); 
    1833             VMR3ReqFree(pReq); 
    1834         } 
    1835 #endif /* !VBOX_WITH_PDM_LOCK */ 
    18361799    } 
    18371800    else 
     
    18451808static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel) 
    18461809{ 
    1847 #ifdef VBOX_WITH_PDM_LOCK 
    18481810    pdmR3DevHlp_PCISetIrq(pDevIns, iIrq, iLevel); 
    1849 #else /* !VBOX_WITH_PDM_LOCK */ 
    1850     PDMDEV_ASSERT_DEVINS(pDevIns); 
    1851     LogFlow(("pdmR3DevHlp_PCISetIrqNoWait: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel)); 
    1852  
    1853     /* 
    1854      * Validate input. 
    1855      */ 
    1856     /** @todo iIrq and iLevel checks. */ 
    1857  
    1858     /* 
    1859      * Must have a PCI device registered! 
    1860      */ 
    1861     PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceHC; 
    1862     if (pPciDev) 
    1863     { 
    1864         PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC; 
    1865         Assert(pBus); 
    1866  
    1867         /* 
    1868          * For the convenience of the device we put no thread restriction on this interface. 
    1869          * That means we'll have to check which thread we're in and choose our path. 
    1870          */ 
    1871         if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC)) 
    1872             pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel); 
    1873         else 
    1874         { 
    1875             Log(("pdmR3DevHlp_PCISetIrqNoWait: caller='%s'/%d: Queueing call in EMT...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1876             int rc = VMR3ReqCallEx(pDevIns->Internal.s.pVMHC, NULL, RT_INDEFINITE_WAIT, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
    1877                                      (PFNRT)pBus->pfnSetIrqR3, 4, pBus->pDevInsR3, pPciDev, iIrq, iLevel); 
    1878             AssertReleaseRC(rc); 
    1879         } 
    1880     } 
    1881     else 
    1882         AssertReleaseMsgFailed(("No PCI device registered!\n")); 
    1883  
    1884     LogFlow(("pdmR3DevHlp_PCISetIrqNoWait: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1885 #endif /* !VBOX_WITH_PDM_LOCK */ 
    18861811} 
    18871812 
     
    18991824 
    19001825    PVM pVM = pDevIns->Internal.s.pVMHC; 
    1901 #ifdef VBOX_WITH_PDM_LOCK 
    19021826    PDMIsaSetIrq(pVM, iIrq, iLevel);    /* (The API takes the lock.) */ 
    1903 #else /* !VBOX_WITH_PDM_LOCK */ 
    1904     if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC)) 
    1905         PDMIsaSetIrq(pVM, iIrq, iLevel); 
    1906     else 
    1907     { 
    1908         Log(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: Requesting call in EMT...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1909         PVMREQ pReq; 
    1910         int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMHC, &pReq, RT_INDEFINITE_WAIT, 
    1911                                  (PFNRT)PDMIsaSetIrq, 3, pVM, iIrq, iLevel); 
    1912         while (rc == VERR_TIMEOUT) 
    1913             rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT); 
    1914         AssertReleaseRC(rc); 
    1915         VMR3ReqFree(pReq); 
    1916     } 
    1917 #endif /* !VBOX_WITH_PDM_LOCK */ 
    19181827 
    19191828    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
     
    19241833static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel) 
    19251834{ 
    1926 #ifdef VBOX_WITH_PDM_LOCK 
    19271835    pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel); 
    1928 #else /* !VBOX_WITH_PDM_LOCK */ 
    1929     PDMDEV_ASSERT_DEVINS(pDevIns); 
    1930     LogFlow(("pdmR3DevHlp_ISASetIrqNoWait: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel)); 
    1931  
    1932     /* 
    1933      * Validate input. 
    1934      */ 
    1935     /** @todo iIrq and iLevel checks. */ 
    1936  
    1937     PVM pVM = pDevIns->Internal.s.pVMHC; 
    1938     /* 
    1939      * For the convenience of the device we put no thread restriction on this interface. 
    1940      * That means we'll have to check which thread we're in and choose our path. 
    1941      */ 
    1942     if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC)) 
    1943         PDMIsaSetIrq(pVM, iIrq, iLevel); 
    1944     else 
    1945     { 
    1946         Log(("pdmR3DevHlp_ISASetIrqNoWait: caller='%s'/%d: Queueing call in EMT...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1947         int rc = VMR3ReqCallEx(pDevIns->Internal.s.pVMHC, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID, 
    1948                                (PFNRT)PDMIsaSetIrq, 3, pVM, iIrq, iLevel); 
    1949         AssertReleaseRC(rc); 
    1950     } 
    1951  
    1952     LogFlow(("pdmR3DevHlp_ISASetIrqNoWait: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance)); 
    1953 #endif /* !VBOX_WITH_PDM_LOCK */ 
    19541836} 
    19551837 
     
    41043986    VM_FF_SET(pVM, VM_FF_INTERRUPT_PIC); 
    41053987    REMR3NotifyInterruptSet(pVM); 
    4106 #ifdef VBOX_WITH_PDM_LOCK 
    41073988    VMR3NotifyFF(pVM, true); 
    4108 #endif 
    41093989} 
    41103990 
     
    41214001 
    41224002 
    4123 #ifdef VBOX_WITH_PDM_LOCK 
    41244003/** @copydoc PDMPICHLPR3::pfnLock */ 
    41254004static DECLCALLBACK(int) pdmR3PicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    41364015    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    41374016} 
    4138 #endif /* VBOX_WITH_PDM_LOCK */ 
    41394017 
    41404018 
     
    41784056    VM_FF_SET(pVM, VM_FF_INTERRUPT_APIC); 
    41794057    REMR3NotifyInterruptSet(pVM); 
    4180 #ifdef VBOX_WITH_PDM_LOCK 
    41814058    VMR3NotifyFF(pVM, true); 
    4182 #endif 
    41834059} 
    41844060 
     
    42074083} 
    42084084 
    4209 #ifdef VBOX_WITH_PDM_LOCK 
    42104085/** @copydoc PDMAPICHLPR3::pfnLock */ 
    42114086static DECLCALLBACK(int) pdmR3ApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    42224097    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    42234098} 
    4224 #endif /* VBOX_WITH_PDM_LOCK */ 
    42254099 
    42264100 
     
    42614135    PDMDEV_ASSERT_DEVINS(pDevIns); 
    42624136    PVM pVM = pDevIns->Internal.s.pVMHC; 
    4263 #ifndef VBOX_WITH_PDM_LOCK 
    4264     VM_ASSERT_EMT(pVM); 
    4265 #endif 
    42664137    LogFlow(("pdmR3IoApicHlp_ApicBusDeliver: caller='%s'/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n", 
    42674138             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode)); 
     
    42714142 
    42724143 
    4273 #ifdef VBOX_WITH_PDM_LOCK 
    42744144/** @copydoc PDMIOAPICHLPR3::pfnLock */ 
    42754145static DECLCALLBACK(int) pdmR3IoApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    42864156    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    42874157} 
    4288 #endif /* VBOX_WITH_PDM_LOCK */ 
    42894158 
    42904159 
     
    43234192{ 
    43244193    PDMDEV_ASSERT_DEVINS(pDevIns); 
    4325 #ifndef VBOX_WITH_PDM_LOCK 
    4326     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC); 
    4327 #endif 
    43284194    Log4(("pdmR3PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel)); 
    43294195    PDMIsaSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel); 
     
    43354201{ 
    43364202    PDMDEV_ASSERT_DEVINS(pDevIns); 
    4337 #ifndef VBOX_WITH_PDM_LOCK 
    4338     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC); 
    4339 #endif 
    43404203    Log4(("pdmR3PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel)); 
    43414204    PDMIoApicSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel); 
     
    43544217 
    43554218 
    4356 #ifdef VBOX_WITH_PDM_LOCK 
    43574219/** @copydoc PDMPCIHLPR3::pfnLock */ 
    43584220static DECLCALLBACK(int) pdmR3PciHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    43694231    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    43704232} 
    4371 #endif /* VBOX_WITH_PDM_LOCK */ 
    43724233 
    43734234 
  • trunk/src/VBox/VMM/PDMInternal.h

    r9387 r10202  
    850850    /** @} */ 
    851851 
    852 #ifdef VBOX_WITH_PDM_LOCK 
    853852    /** The PDM lock. 
    854853     * This is used to protect everything that deals with interrupts, i.e. 
    855854     * the PIC, APIC, IOAPIC and PCI devices pluss some PDM functions. */ 
    856855    PDMCRITSECT                     CritSect; 
    857 #endif 
    858  
    859856 
    860857    /** Number of times a critical section leave requesed needed to be queued for ring-3 execution. */ 
     
    940937#endif /* IN_RING3 */ 
    941938 
    942 #ifdef VBOX_WITH_PDM_LOCK 
    943939void        pdmLock(PVM pVM); 
    944940int         pdmLockEx(PVM pVM, int rc); 
    945941void        pdmUnlock(PVM pVM); 
    946 #else 
    947 # define pdmLock(pVM)       do {} while (0) 
    948 # define pdmLockEx(pVM, rc) (VINF_SUCCESS) 
    949 # define pdmUnlock(pVM)     do {} while (0) 
    950 #endif 
    951942 
    952943/** @} */ 
  • trunk/src/VBox/VMM/VMMAll/PDMAll.cpp

    r8155 r10202  
    8383    } 
    8484 
    85 #ifndef VBOX_WITH_PDM_LOCK /** @todo Figure out exactly why we can get here without anything being set. (REM) */ 
    86     /* Shouldn't get here! Noone should call us without cause. */ 
    87     Assert(VM_FF_ISPENDING(pVM, VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC)); 
    88 #endif 
     85    /** @todo Figure out exactly why we can get here without anything being set. (REM) */ 
     86 
    8987    pdmUnlock(pVM); 
    9088    return VERR_NO_DATA; 
     
    232230 
    233231 
    234 #ifdef VBOX_WITH_PDM_LOCK 
    235232/** 
    236233 * Locks PDM. 
     
    249246# ifdef IN_GC 
    250247        rc = VMMGCCallHost(pVM, VMMCALLHOST_PDM_LOCK, 0); 
    251 #else 
     248# else 
    252249        rc = VMMR0CallHost(pVM, VMMCALLHOST_PDM_LOCK, 0); 
    253 #endif 
     250# endif 
    254251    } 
    255252#endif 
     
    281278    PDMCritSectLeave(&pVM->pdm.s.CritSect); 
    282279} 
    283 #endif /* VBOX_WITH_PDM_LOCK */ 
    284  
     280 
  • trunk/src/VBox/VMM/VMMGC/PDMGCDevice.cpp

    r9231 r10202  
    9191static DECLCALLBACK(void) pdmGCPicHlp_SetInterruptFF(PPDMDEVINS pDevIns); 
    9292static DECLCALLBACK(void) pdmGCPicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    93 #ifdef VBOX_WITH_PDM_LOCK 
    9493static DECLCALLBACK(int) pdmGCPicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    9594static DECLCALLBACK(void) pdmGCPicHlp_Unlock(PPDMDEVINS pDevIns); 
    96 #endif 
    9795/** @} */ 
    9896 
     
    104102static DECLCALLBACK(void) pdmGCApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    105103static DECLCALLBACK(void) pdmGCApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled); 
    106 #ifdef VBOX_WITH_PDM_LOCK 
    107104static DECLCALLBACK(int) pdmGCApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    108105static DECLCALLBACK(void) pdmGCApicHlp_Unlock(PPDMDEVINS pDevIns); 
    109 #endif 
    110106/** @} */ 
    111107 
     
    116112static DECLCALLBACK(void) pdmGCIoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode, 
    117113                                                        uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode); 
    118 #ifdef VBOX_WITH_PDM_LOCK 
    119114static DECLCALLBACK(int) pdmGCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    120115static DECLCALLBACK(void) pdmGCIoApicHlp_Unlock(PPDMDEVINS pDevIns); 
    121 #endif 
    122116/** @} */ 
    123117 
     
    128122static DECLCALLBACK(void) pdmGCPciHlp_IsaSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel); 
    129123static DECLCALLBACK(void) pdmGCPciHlp_IoApicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel); 
    130 #ifdef VBOX_WITH_PDM_LOCK 
    131124static DECLCALLBACK(int) pdmGCPciHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    132125static DECLCALLBACK(void) pdmGCPciHlp_Unlock(PPDMDEVINS pDevIns); 
    133 #endif 
    134126/** @} */ 
    135127 
     
    167159    pdmGCPicHlp_SetInterruptFF, 
    168160    pdmGCPicHlp_ClearInterruptFF, 
    169 #ifdef VBOX_WITH_PDM_LOCK 
    170161    pdmGCPicHlp_Lock, 
    171162    pdmGCPicHlp_Unlock, 
    172 #endif 
    173163    PDM_PICHLPGC_VERSION 
    174164}; 
     
    184174    pdmGCApicHlp_ClearInterruptFF, 
    185175    pdmGCApicHlp_ChangeFeature, 
    186 #ifdef VBOX_WITH_PDM_LOCK 
    187176    pdmGCApicHlp_Lock, 
    188177    pdmGCApicHlp_Unlock, 
    189 #endif 
    190178    PDM_APICHLPGC_VERSION 
    191179}; 
     
    199187    PDM_IOAPICHLPGC_VERSION, 
    200188    pdmGCIoApicHlp_ApicBusDeliver, 
    201 #ifdef VBOX_WITH_PDM_LOCK 
    202189    pdmGCIoApicHlp_Lock, 
    203190    pdmGCIoApicHlp_Unlock, 
    204 #endif 
    205191    PDM_IOAPICHLPGC_VERSION 
    206192}; 
     
    215201    pdmGCPciHlp_IsaSetIrq, 
    216202    pdmGCPciHlp_IoApicSetIrq, 
    217 #ifdef VBOX_WITH_PDM_LOCK 
    218203    pdmGCPciHlp_Lock, 
    219204    pdmGCPciHlp_Unlock, 
    220 #endif 
    221205    PDM_PCIHLPGC_VERSION, /* the end */ 
    222206}; 
     
    388372 
    389373 
    390 #ifdef VBOX_WITH_PDM_LOCK 
    391374/** @copydoc PDMPICHLPGC::pfnLock */ 
    392375static DECLCALLBACK(int) pdmGCPicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    403386    pdmUnlock(pDevIns->Internal.s.pVMGC); 
    404387} 
    405 #endif /* VBOX_WITH_PDM_LOCK */ 
    406388 
    407389 
     
    440422 
    441423 
    442 #ifdef VBOX_WITH_PDM_LOCK 
    443424/** @copydoc PDMAPICHLPGC::pfnLock */ 
    444425static DECLCALLBACK(int) pdmGCApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    455436    pdmUnlock(pDevIns->Internal.s.pVMGC); 
    456437} 
    457 #endif /* VBOX_WITH_PDM_LOCK */ 
    458438 
    459439 
     
    473453 
    474454 
    475 #ifdef VBOX_WITH_PDM_LOCK 
    476455/** @copydoc PDMIOAPICHLPGC::pfnLock */ 
    477456static DECLCALLBACK(int) pdmGCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    488467    pdmUnlock(pDevIns->Internal.s.pVMGC); 
    489468} 
    490 #endif /* VBOX_WITH_PDM_LOCK */ 
    491469 
    492470 
     
    511489 
    512490 
    513 #ifdef VBOX_WITH_PDM_LOCK 
    514491/** @copydoc PDMPCIHLPGC::pfnLock */ 
    515492static DECLCALLBACK(int) pdmGCPciHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    526503    pdmUnlock(pDevIns->Internal.s.pVMGC); 
    527504} 
    528 #endif /* VBOX_WITH_PDM_LOCK */ 
    529505 
    530506 
  • trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

    r8155 r10202  
    9191static DECLCALLBACK(void) pdmR0PicHlp_SetInterruptFF(PPDMDEVINS pDevIns); 
    9292static DECLCALLBACK(void) pdmR0PicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    93 #ifdef VBOX_WITH_PDM_LOCK 
    9493static DECLCALLBACK(int) pdmR0PicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    9594static DECLCALLBACK(void) pdmR0PicHlp_Unlock(PPDMDEVINS pDevIns); 
    96 #endif 
    9795/** @} */ 
    9896 
     
    104102static DECLCALLBACK(void) pdmR0ApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns); 
    105103static DECLCALLBACK(void) pdmR0ApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled); 
    106 #ifdef VBOX_WITH_PDM_LOCK 
    107104static DECLCALLBACK(int) pdmR0ApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    108105static DECLCALLBACK(void) pdmR0ApicHlp_Unlock(PPDMDEVINS pDevIns); 
    109 #endif 
    110106/** @} */ 
    111107 
     
    116112static DECLCALLBACK(void) pdmR0IoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode, 
    117113                                                        uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode); 
    118 #ifdef VBOX_WITH_PDM_LOCK 
    119114static DECLCALLBACK(int) pdmR0IoApicHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    120115static DECLCALLBACK(void) pdmR0IoApicHlp_Unlock(PPDMDEVINS pDevIns); 
    121 #endif 
    122116/** @} */ 
    123117 
     
    128122static DECLCALLBACK(void) pdmR0PciHlp_IsaSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel); 
    129123static DECLCALLBACK(void) pdmR0PciHlp_IoApicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel); 
    130 #ifdef VBOX_WITH_PDM_LOCK 
    131124static DECLCALLBACK(int) pdmR0PciHlp_Lock(PPDMDEVINS pDevIns, int rc); 
    132125static DECLCALLBACK(void) pdmR0PciHlp_Unlock(PPDMDEVINS pDevIns); 
    133 #endif 
    134126/** @} */ 
    135127 
     
    167159    pdmR0PicHlp_SetInterruptFF, 
    168160    pdmR0PicHlp_ClearInterruptFF, 
    169 #ifdef VBOX_WITH_PDM_LOCK 
    170161    pdmR0PicHlp_Lock, 
    171162    pdmR0PicHlp_Unlock, 
    172 #endif 
    173163    PDM_PICHLPR0_VERSION 
    174164}; 
     
    184174    pdmR0ApicHlp_ClearInterruptFF, 
    185175    pdmR0ApicHlp_ChangeFeature, 
    186 #ifdef VBOX_WITH_PDM_LOCK 
    187176    pdmR0ApicHlp_Lock, 
    188177    pdmR0ApicHlp_Unlock, 
    189 #endif 
    190178    PDM_APICHLPR0_VERSION 
    191179}; 
     
    199187    PDM_IOAPICHLPR0_VERSION, 
    200188    pdmR0IoApicHlp_ApicBusDeliver, 
    201 #ifdef VBOX_WITH_PDM_LOCK 
    202189    pdmR0IoApicHlp_Lock, 
    203190    pdmR0IoApicHlp_Unlock, 
    204 #endif 
    205191    PDM_IOAPICHLPR0_VERSION 
    206192}; 
     
    215201    pdmR0PciHlp_IsaSetIrq, 
    216202    pdmR0PciHlp_IoApicSetIrq, 
    217 #ifdef VBOX_WITH_PDM_LOCK 
    218203    pdmR0PciHlp_Lock, 
    219204    pdmR0PciHlp_Unlock, 
    220 #endif 
    221205    PDM_PCIHLPR0_VERSION, /* the end */ 
    222206}; 
     
    392376 
    393377 
    394 #ifdef VBOX_WITH_PDM_LOCK 
    395378/** @copydoc PDMPICHLPR0::pfnLock */ 
    396379static DECLCALLBACK(int) pdmR0PicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    407390    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    408391} 
    409 #endif /* VBOX_WITH_PDM_LOCK */ 
    410392 
    411393 
     
    444426 
    445427 
    446 #ifdef VBOX_WITH_PDM_LOCK 
    447428/** @copydoc PDMAPICHLPR0::pfnLock */ 
    448429static DECLCALLBACK(int) pdmR0ApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    459440    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    460441} 
    461 #endif /* VBOX_WITH_PDM_LOCK */ 
    462442 
    463443 
     
    478458 
    479459 
    480 #ifdef VBOX_WITH_PDM_LOCK 
    481460/** @copydoc PDMIOAPICHLPR0::pfnLock */ 
    482461static DECLCALLBACK(int) pdmR0IoApicHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    493472    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    494473} 
    495 #endif /* VBOX_WITH_PDM_LOCK */ 
    496474 
    497475 
     
    517495 
    518496 
    519 #ifdef VBOX_WITH_PDM_LOCK 
    520497/** @copydoc PDMPCIHLPR0::pfnLock */ 
    521498static DECLCALLBACK(int) pdmR0PciHlp_Lock(PPDMDEVINS pDevIns, int rc) 
     
    532509    pdmUnlock(pDevIns->Internal.s.pVMHC); 
    533510} 
    534 #endif /* VBOX_WITH_PDM_LOCK */ 
    535511 
    536512 
  • trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

    r9397 r10202  
    306306    GEN_CHECK_OFF(PDM, aDrvInsPollers); 
    307307    GEN_CHECK_OFF(PDM, pTimerPollers); 
    308 #ifdef VBOX_WITH_PDM_LOCK 
    309308    GEN_CHECK_OFF(PDM, CritSect); 
    310 #endif 
    311309    GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves); 
    312310    GEN_CHECK_SIZE(PDMDEVINSINT); 

© 2008 Sun Microsystems, Inc.
ContactPrivacy policy