Changeset 11269 in vbox for trunk/src/VBox/Devices/Storage

Timestamp:

Aug 8, 2008 4:24:48 PM (16 years ago)

Author:

vboxsync

Message:

Devices: pData -> pThis.

Location:

trunk/src/VBox/Devices/Storage

Files:

• DevATA.cpp (modified) (49 diffs)
• DrvBlock.cpp (modified) (55 diffs)
• DrvMediaISO.cpp (modified) (8 diffs)
• DrvRawImage.cpp (modified) (12 diffs)
• DrvVD.cpp (modified) (36 diffs)
• VBoxHDD.cpp (modified) (17 diffs)

trunk/src/VBox/Devices/Storage/DevATA.cpp

@@ -3032 +3032 @@
  * @returns true on success.
  * @returns false when the thread is still processing.
- * @param   pData       Pointer to the controller data.
+ * @param   pThis       Pointer to the controller data.
  * @param   cMillies    How long to wait (total).
  */
@@ -4372 +4372 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int rc;
 
@@ -4406 +4406 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int rc;
 
@@ -4452 +4452 @@
 static DECLCALLBACK(int) ataBMDMAIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
 {
-    PCIATAState *pData = PCIDEV_2_PCIATASTATE(pPciDev);
+    PCIATAState *pThis = PCIDEV_2_PCIATASTATE(pPciDev);
     int         rc = VINF_SUCCESS;
     Assert(enmType == PCI_ADDRESS_SPACE_IO);
@@ -4459 +4459 @@
 
     /* Register the port range. */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
     {
         int rc2 = PDMDevHlpIOPortRegister(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
@@ -4467 +4467 @@
             rc = rc2;
 
-        if (pData->fGCEnabled)
+        if (pThis->fGCEnabled)
         {
             rc2 = PDMDevHlpIOPortRegisterGC(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
@@ -4475 +4475 @@
                 rc = rc2;
         }
-        if (pData->fR0Enabled)
+        if (pThis->fR0Enabled)
         {
             rc2 = PDMDevHlpIOPortRegisterR0(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress + i * 8, 8,
@@ -4496 +4496 @@
 static DECLCALLBACK(void)  ataReset(PPDMDEVINS pDevIns)
 {
-    PCIATAState *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        pData->aCts[i].iSelectedIf = 0;
-        pData->aCts[i].iAIOIf = 0;
-        pData->aCts[i].BmDma.u8Cmd = 0;
+    PCIATAState *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        pThis->aCts[i].iSelectedIf = 0;
+        pThis->aCts[i].iAIOIf = 0;
+        pThis->aCts[i].BmDma.u8Cmd = 0;
         /* Report that both drives present on the bus are in DMA mode. This
          * pretends that there is a BIOS that has set it up. Normal reset
          * default is 0x00. */
-        pData->aCts[i].BmDma.u8Status =   (pData->aCts[i].aIfs[0].pDrvBase != NULL ? BM_STATUS_D0DMA : 0)
-                                        | (pData->aCts[i].aIfs[1].pDrvBase != NULL ? BM_STATUS_D1DMA : 0);
-        pData->aCts[i].BmDma.pvAddr = 0;
-
-        pData->aCts[i].fReset = true;
-        pData->aCts[i].fRedo = false;
-        pData->aCts[i].fRedoIdle = false;
-        ataAsyncIOClearRequests(&pData->aCts[i]);
+        pThis->aCts[i].BmDma.u8Status =   (pThis->aCts[i].aIfs[0].pDrvBase != NULL ? BM_STATUS_D0DMA : 0)
+                                        | (pThis->aCts[i].aIfs[1].pDrvBase != NULL ? BM_STATUS_D1DMA : 0);
+        pThis->aCts[i].BmDma.pvAddr = 0;
+
+        pThis->aCts[i].fReset = true;
+        pThis->aCts[i].fRedo = false;
+        pThis->aCts[i].fRedoIdle = false;
+        ataAsyncIOClearRequests(&pThis->aCts[i]);
         Log2(("%s: Ctl#%d: message to async I/O thread, reset controller\n", __FUNCTION__, i));
-        ataAsyncIOPutRequest(&pData->aCts[i], &ataResetARequest);
-        ataAsyncIOPutRequest(&pData->aCts[i], &ataResetCRequest);
-        if (!ataWaitForAsyncIOIsIdle(&pData->aCts[i], 30000))
+        ataAsyncIOPutRequest(&pThis->aCts[i], &ataResetARequest);
+        ataAsyncIOPutRequest(&pThis->aCts[i], &ataResetCRequest);
+        if (!ataWaitForAsyncIOIsIdle(&pThis->aCts[i], 30000))
             AssertReleaseMsgFailed(("Async I/O thread busy after reset\n"));
 
-        for (uint32_t j = 0; j < RT_ELEMENTS(pData->aCts[i].aIfs); j++)
-            ataResetDevice(&pData->aCts[i].aIfs[j]);
+        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
+            ataResetDevice(&pThis->aCts[i].aIfs[j]);
     }
 }
@@ -4538 +4538 @@
 static DECLCALLBACK(void *) ataStatus_QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    PCIATAState *pData = PDMIBASE_2_PCIATASTATE(pInterface);
+    PCIATAState *pThis = PDMIBASE_2_PCIATASTATE(pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         case PDMINTERFACE_LED_PORTS:
-            return &pData->ILeds;
+            return &pThis->ILeds;
         default:
             return NULL;
@@ -4563 +4563 @@
 static DECLCALLBACK(int) ataStatus_QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
 {
-    PCIATAState *pData = PDMILEDPORTS_2_PCIATASTATE(pInterface);
+    PCIATAState *pThis = PDMILEDPORTS_2_PCIATASTATE(pInterface);
     if (iLUN >= 0 && iLUN <= 4)
     {
         switch (iLUN)
         {
-            case 0: *ppLed = &pData->aCts[0].aIfs[0].Led; break;
-            case 1: *ppLed = &pData->aCts[0].aIfs[1].Led; break;
-            case 2: *ppLed = &pData->aCts[1].aIfs[0].Led; break;
-            case 3: *ppLed = &pData->aCts[1].aIfs[1].Led; break;
+            case 0: *ppLed = &pThis->aCts[0].aIfs[0].Led; break;
+            case 1: *ppLed = &pThis->aCts[0].aIfs[1].Led; break;
+            case 2: *ppLed = &pThis->aCts[1].aIfs[0].Led; break;
+            case 3: *ppLed = &pThis->aCts[1].aIfs[1].Led; break;
         }
         Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
@@ -4618 +4618 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int            rc = VINF_SUCCESS;
 
@@ -4650 +4650 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int            rc = VINF_SUCCESS;
 
@@ -4687 +4687 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int            rc = VINF_SUCCESS;
 
@@ -4744 +4744 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int            rc;
 
@@ -4801 +4801 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int rc;
 
@@ -4825 +4825 @@
 {
     uint32_t       i = (uint32_t)(uintptr_t)pvUser;
-    PCIATAState   *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-    PATACONTROLLER pCtl = &pData->aCts[i];
+    PCIATAState   *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PATACONTROLLER pCtl = &pThis->aCts[i];
     int            rc;
 
@@ -4850 +4850 @@
  * @returns true on success.
  * @returns false when one or more threads is still processing.
- * @param   pData       Pointer to the instance data.
+ * @param   pThis       Pointer to the instance data.
  * @param   cMillies    How long to wait (total).
  */
 static bool ataWaitForAllAsyncIOIsIdle(PPDMDEVINS pDevIns, unsigned cMillies)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
     bool            fVMLocked;
     uint64_t        u64Start;
@@ -4879 +4879 @@
         /* Check all async I/O threads. */
         fAllIdle = true;
-        for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-        {
-            pCtl = &pData->aCts[i];
+        for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+        {
+            pCtl = &pThis->aCts[i];
             fAllIdle &= ataAsyncIOIsIdle(pCtl, false);
             if (!fAllIdle)
@@ -4918 +4918 @@
 static DECLCALLBACK(void) ataRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    PCIATAState *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        pData->aCts[i].pDevInsRC += offDelta;
-        pData->aCts[i].aIfs[0].pDevInsRC += offDelta;
-        pData->aCts[i].aIfs[0].pControllerRC += offDelta;
-        ataRelocBuffer(pDevIns, &pData->aCts[i].aIfs[0]);
-        pData->aCts[i].aIfs[1].pDevInsRC += offDelta;
-        pData->aCts[i].aIfs[1].pControllerRC += offDelta;
-        ataRelocBuffer(pDevIns, &pData->aCts[i].aIfs[1]);
+    PCIATAState *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        pThis->aCts[i].pDevInsRC += offDelta;
+        pThis->aCts[i].aIfs[0].pDevInsRC += offDelta;
+        pThis->aCts[i].aIfs[0].pControllerRC += offDelta;
+        ataRelocBuffer(pDevIns, &pThis->aCts[i].aIfs[0]);
+        pThis->aCts[i].aIfs[1].pDevInsRC += offDelta;
+        pThis->aCts[i].aIfs[1].pControllerRC += offDelta;
+        ataRelocBuffer(pDevIns, &pThis->aCts[i].aIfs[1]);
     }
 }
@@ -4943 +4943 @@
 static DECLCALLBACK(int) ataDestruct(PPDMDEVINS pDevIns)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
     int             rc;
 
@@ -4951 +4951 @@
      * Terminate all async helper threads
      */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        if (pData->aCts[i].AsyncIOThread != NIL_RTTHREAD)
-        {
-            ASMAtomicXchgU32(&pData->aCts[i].fShutdown, true);
-            rc = RTSemEventSignal(pData->aCts[i].AsyncIOSem);
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        if (pThis->aCts[i].AsyncIOThread != NIL_RTTHREAD)
+        {
+            ASMAtomicXchgU32(&pThis->aCts[i].fShutdown, true);
+            rc = RTSemEventSignal(pThis->aCts[i].AsyncIOSem);
             AssertRC(rc);
         }
@@ -4967 +4967 @@
     if (ataWaitForAllAsyncIOIsIdle(pDevIns, 20000))
     {
-        for (unsigned i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-        {
-            rc = RTThreadWait(pData->aCts[i].AsyncIOThread, 30000 /* 30 s*/, NULL);
+        for (unsigned i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+        {
+            rc = RTThreadWait(pThis->aCts[i].AsyncIOThread, 30000 /* 30 s*/, NULL);
             AssertMsg(RT_SUCCESS(rc) || rc == VERR_INVALID_HANDLE, ("rc=%Rrc i=%d\n", rc, i));
         }
@@ -4979 +4979 @@
      * Now the request mutexes are no longer needed. Free resources.
      */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        if (pData->aCts[i].AsyncIORequestMutex != NIL_RTSEMEVENT)
-        {
-            RTSemMutexDestroy(pData->aCts[i].AsyncIORequestMutex);
-            pData->aCts[i].AsyncIORequestMutex = NIL_RTSEMEVENT;
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        if (pThis->aCts[i].AsyncIORequestMutex != NIL_RTSEMEVENT)
+        {
+            RTSemMutexDestroy(pThis->aCts[i].AsyncIORequestMutex);
+            pThis->aCts[i].AsyncIORequestMutex = NIL_RTSEMEVENT;
         }
     }
@@ -5233 +5233 @@
 static DECLCALLBACK(void) ataResume(PPDMDEVINS pDevIns)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
     int             rc;
 
     Log(("%s:\n", __FUNCTION__));
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        if (pData->aCts[i].fRedo && pData->aCts[i].fRedoIdle)
-        {
-            rc = RTSemEventSignal(pData->aCts[i].SuspendIOSem);
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        if (pThis->aCts[i].fRedo && pThis->aCts[i].fRedoIdle)
+        {
+            rc = RTSemEventSignal(pThis->aCts[i].SuspendIOSem);
             AssertRC(rc);
         }
@@ -5273 +5273 @@
 static DECLCALLBACK(int) ataSaveLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
 
     /* sanity - the suspend notification will wait on the async stuff. */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        Assert(ataAsyncIOIsIdle(&pData->aCts[i], false));
-        if (!ataAsyncIOIsIdle(&pData->aCts[i], false))
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        Assert(ataAsyncIOIsIdle(&pThis->aCts[i], false));
+        if (!ataAsyncIOIsIdle(&pThis->aCts[i], false))
             return VERR_SSM_IDE_ASYNC_TIMEOUT;
     }
@@ -5295 +5295 @@
 static DECLCALLBACK(int) ataSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
-
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        SSMR3PutU8(pSSMHandle, pData->aCts[i].iSelectedIf);
-        SSMR3PutU8(pSSMHandle, pData->aCts[i].iAIOIf);
-        SSMR3PutU8(pSSMHandle, pData->aCts[i].uAsyncIOState);
-        SSMR3PutBool(pSSMHandle, pData->aCts[i].fChainedTransfer);
-        SSMR3PutBool(pSSMHandle, pData->aCts[i].fReset);
-        SSMR3PutBool(pSSMHandle, pData->aCts[i].fRedo);
-        SSMR3PutBool(pSSMHandle, pData->aCts[i].fRedoIdle);
-        SSMR3PutBool(pSSMHandle, pData->aCts[i].fRedoDMALastDesc);
-        SSMR3PutMem(pSSMHandle, &pData->aCts[i].BmDma, sizeof(pData->aCts[i].BmDma));
-        SSMR3PutGCPhys32(pSSMHandle, pData->aCts[i].pFirstDMADesc);
-        SSMR3PutGCPhys32(pSSMHandle, pData->aCts[i].pLastDMADesc);
-        SSMR3PutGCPhys32(pSSMHandle, pData->aCts[i].pRedoDMABuffer);
-        SSMR3PutU32(pSSMHandle, pData->aCts[i].cbRedoDMABuffer);
-
-        for (uint32_t j = 0; j < RT_ELEMENTS(pData->aCts[i].aIfs); j++)
-        {
-            SSMR3PutBool(pSSMHandle, pData->aCts[i].aIfs[j].fLBA48);
-            SSMR3PutBool(pSSMHandle, pData->aCts[i].aIfs[j].fATAPI);
-            SSMR3PutBool(pSSMHandle, pData->aCts[i].aIfs[j].fIrqPending);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].cMultSectors);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].PCHSGeometry.cCylinders);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].PCHSGeometry.cHeads);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].PCHSGeometry.cSectors);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].cSectorsPerIRQ);
-            SSMR3PutU64(pSSMHandle, pData->aCts[i].aIfs[j].cTotalSectors);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegFeature);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegFeatureHOB);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegError);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegNSector);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegNSectorHOB);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegSector);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegSectorHOB);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegLCyl);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegLCylHOB);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegHCyl);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegHCylHOB);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegSelect);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegStatus);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegCommand);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATARegDevCtl);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATATransferMode);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uTxDir);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].iBeginTransfer);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].iSourceSink);
-            SSMR3PutBool(pSSMHandle, pData->aCts[i].aIfs[j].fDMA);
-            SSMR3PutBool(pSSMHandle, pData->aCts[i].aIfs[j].fATAPITransfer);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].cbTotalTransfer);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].cbElementaryTransfer);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].iIOBufferCur);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].iIOBufferEnd);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].iIOBufferPIODataStart);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].iIOBufferPIODataEnd);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].iATAPILBA);
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].cbATAPISector);
-            SSMR3PutMem(pSSMHandle, &pData->aCts[i].aIfs[j].aATAPICmd, sizeof(pData->aCts[i].aIfs[j].aATAPICmd));
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATAPISenseKey);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].uATAPIASC);
-            SSMR3PutU8(pSSMHandle, pData->aCts[i].aIfs[j].cNotifiedMediaChange);
-            SSMR3PutMem(pSSMHandle, &pData->aCts[i].aIfs[j].Led, sizeof(pData->aCts[i].aIfs[j].Led));
-            SSMR3PutU32(pSSMHandle, pData->aCts[i].aIfs[j].cbIOBuffer);
-            if (pData->aCts[i].aIfs[j].cbIOBuffer)
-                SSMR3PutMem(pSSMHandle, pData->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer), pData->aCts[i].aIfs[j].cbIOBuffer);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
+
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        SSMR3PutU8(pSSMHandle, pThis->aCts[i].iSelectedIf);
+        SSMR3PutU8(pSSMHandle, pThis->aCts[i].iAIOIf);
+        SSMR3PutU8(pSSMHandle, pThis->aCts[i].uAsyncIOState);
+        SSMR3PutBool(pSSMHandle, pThis->aCts[i].fChainedTransfer);
+        SSMR3PutBool(pSSMHandle, pThis->aCts[i].fReset);
+        SSMR3PutBool(pSSMHandle, pThis->aCts[i].fRedo);
+        SSMR3PutBool(pSSMHandle, pThis->aCts[i].fRedoIdle);
+        SSMR3PutBool(pSSMHandle, pThis->aCts[i].fRedoDMALastDesc);
+        SSMR3PutMem(pSSMHandle, &pThis->aCts[i].BmDma, sizeof(pThis->aCts[i].BmDma));
+        SSMR3PutGCPhys32(pSSMHandle, pThis->aCts[i].pFirstDMADesc);
+        SSMR3PutGCPhys32(pSSMHandle, pThis->aCts[i].pLastDMADesc);
+        SSMR3PutGCPhys32(pSSMHandle, pThis->aCts[i].pRedoDMABuffer);
+        SSMR3PutU32(pSSMHandle, pThis->aCts[i].cbRedoDMABuffer);
+
+        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
+        {
+            SSMR3PutBool(pSSMHandle, pThis->aCts[i].aIfs[j].fLBA48);
+            SSMR3PutBool(pSSMHandle, pThis->aCts[i].aIfs[j].fATAPI);
+            SSMR3PutBool(pSSMHandle, pThis->aCts[i].aIfs[j].fIrqPending);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].cMultSectors);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].PCHSGeometry.cCylinders);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].PCHSGeometry.cHeads);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].PCHSGeometry.cSectors);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].cSectorsPerIRQ);
+            SSMR3PutU64(pSSMHandle, pThis->aCts[i].aIfs[j].cTotalSectors);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegFeature);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegFeatureHOB);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegError);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegNSector);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegNSectorHOB);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegSector);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegSectorHOB);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegLCyl);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegLCylHOB);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegHCyl);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegHCylHOB);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegSelect);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegStatus);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegCommand);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATARegDevCtl);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATATransferMode);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uTxDir);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].iBeginTransfer);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].iSourceSink);
+            SSMR3PutBool(pSSMHandle, pThis->aCts[i].aIfs[j].fDMA);
+            SSMR3PutBool(pSSMHandle, pThis->aCts[i].aIfs[j].fATAPITransfer);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].cbTotalTransfer);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].cbElementaryTransfer);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].iIOBufferCur);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].iIOBufferEnd);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].iIOBufferPIODataStart);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].iIOBufferPIODataEnd);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].iATAPILBA);
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].cbATAPISector);
+            SSMR3PutMem(pSSMHandle, &pThis->aCts[i].aIfs[j].aATAPICmd, sizeof(pThis->aCts[i].aIfs[j].aATAPICmd));
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATAPISenseKey);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].uATAPIASC);
+            SSMR3PutU8(pSSMHandle, pThis->aCts[i].aIfs[j].cNotifiedMediaChange);
+            SSMR3PutMem(pSSMHandle, &pThis->aCts[i].aIfs[j].Led, sizeof(pThis->aCts[i].aIfs[j].Led));
+            SSMR3PutU32(pSSMHandle, pThis->aCts[i].aIfs[j].cbIOBuffer);
+            if (pThis->aCts[i].aIfs[j].cbIOBuffer)
+                SSMR3PutMem(pSSMHandle, pThis->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer), pThis->aCts[i].aIfs[j].cbIOBuffer);
             else
-                Assert(pData->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer) == NULL);
-        }
-    }
-    SSMR3PutBool(pSSMHandle, pData->fPIIX4);
+                Assert(pThis->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer) == NULL);
+        }
+    }
+    SSMR3PutBool(pSSMHandle, pThis->fPIIX4);
 
     return SSMR3PutU32(pSSMHandle, ~0); /* sanity/terminator */
@@ -5381 +5381 @@
 static DECLCALLBACK(int) ataLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
     int             rc;
     uint32_t        u32;
@@ -5394 +5394 @@
      * Restore valid parts of the PCIATAState structure
      */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
     {
         /* integrity check */
-        if (!ataAsyncIOIsIdle(&pData->aCts[i], false))
+        if (!ataAsyncIOIsIdle(&pThis->aCts[i], false))
         {
             AssertMsgFailed(("Async I/O for controller %d is active\n", i));
@@ -5404 +5404 @@
         }
 
-        SSMR3GetU8(pSSMHandle, &pData->aCts[i].iSelectedIf);
-        SSMR3GetU8(pSSMHandle, &pData->aCts[i].iAIOIf);
-        SSMR3GetU8(pSSMHandle, &pData->aCts[i].uAsyncIOState);
-        SSMR3GetBool(pSSMHandle, &pData->aCts[i].fChainedTransfer);
-        SSMR3GetBool(pSSMHandle, (bool *)&pData->aCts[i].fReset);
-        SSMR3GetBool(pSSMHandle, (bool *)&pData->aCts[i].fRedo);
-        SSMR3GetBool(pSSMHandle, (bool *)&pData->aCts[i].fRedoIdle);
-        SSMR3GetBool(pSSMHandle, (bool *)&pData->aCts[i].fRedoDMALastDesc);
-        SSMR3GetMem(pSSMHandle, &pData->aCts[i].BmDma, sizeof(pData->aCts[i].BmDma));
-        SSMR3GetGCPhys32(pSSMHandle, &pData->aCts[i].pFirstDMADesc);
-        SSMR3GetGCPhys32(pSSMHandle, &pData->aCts[i].pLastDMADesc);
-        SSMR3GetGCPhys32(pSSMHandle, &pData->aCts[i].pRedoDMABuffer);
-        SSMR3GetU32(pSSMHandle, &pData->aCts[i].cbRedoDMABuffer);
-
-        for (uint32_t j = 0; j < RT_ELEMENTS(pData->aCts[i].aIfs); j++)
-        {
-            SSMR3GetBool(pSSMHandle, &pData->aCts[i].aIfs[j].fLBA48);
-            SSMR3GetBool(pSSMHandle, &pData->aCts[i].aIfs[j].fATAPI);
-            SSMR3GetBool(pSSMHandle, &pData->aCts[i].aIfs[j].fIrqPending);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].cMultSectors);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].PCHSGeometry.cCylinders);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].PCHSGeometry.cHeads);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].PCHSGeometry.cSectors);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].cSectorsPerIRQ);
-            SSMR3GetU64(pSSMHandle, &pData->aCts[i].aIfs[j].cTotalSectors);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegFeature);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegFeatureHOB);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegError);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegNSector);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegNSectorHOB);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegSector);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegSectorHOB);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegLCyl);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegLCylHOB);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegHCyl);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegHCylHOB);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegSelect);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegStatus);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegCommand);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATARegDevCtl);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATATransferMode);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uTxDir);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].iBeginTransfer);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].iSourceSink);
-            SSMR3GetBool(pSSMHandle, &pData->aCts[i].aIfs[j].fDMA);
-            SSMR3GetBool(pSSMHandle, &pData->aCts[i].aIfs[j].fATAPITransfer);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].cbTotalTransfer);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].cbElementaryTransfer);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].iIOBufferCur);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].iIOBufferEnd);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].iIOBufferPIODataStart);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].iIOBufferPIODataEnd);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].iATAPILBA);
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].cbATAPISector);
-            SSMR3GetMem(pSSMHandle, &pData->aCts[i].aIfs[j].aATAPICmd, sizeof(pData->aCts[i].aIfs[j].aATAPICmd));
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATAPISenseKey);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].uATAPIASC);
-            SSMR3GetU8(pSSMHandle, &pData->aCts[i].aIfs[j].cNotifiedMediaChange);
-            SSMR3GetMem(pSSMHandle, &pData->aCts[i].aIfs[j].Led, sizeof(pData->aCts[i].aIfs[j].Led));
-            SSMR3GetU32(pSSMHandle, &pData->aCts[i].aIfs[j].cbIOBuffer);
-            if (pData->aCts[i].aIfs[j].cbIOBuffer)
+        SSMR3GetU8(pSSMHandle, &pThis->aCts[i].iSelectedIf);
+        SSMR3GetU8(pSSMHandle, &pThis->aCts[i].iAIOIf);
+        SSMR3GetU8(pSSMHandle, &pThis->aCts[i].uAsyncIOState);
+        SSMR3GetBool(pSSMHandle, &pThis->aCts[i].fChainedTransfer);
+        SSMR3GetBool(pSSMHandle, (bool *)&pThis->aCts[i].fReset);
+        SSMR3GetBool(pSSMHandle, (bool *)&pThis->aCts[i].fRedo);
+        SSMR3GetBool(pSSMHandle, (bool *)&pThis->aCts[i].fRedoIdle);
+        SSMR3GetBool(pSSMHandle, (bool *)&pThis->aCts[i].fRedoDMALastDesc);
+        SSMR3GetMem(pSSMHandle, &pThis->aCts[i].BmDma, sizeof(pThis->aCts[i].BmDma));
+        SSMR3GetGCPhys32(pSSMHandle, &pThis->aCts[i].pFirstDMADesc);
+        SSMR3GetGCPhys32(pSSMHandle, &pThis->aCts[i].pLastDMADesc);
+        SSMR3GetGCPhys32(pSSMHandle, &pThis->aCts[i].pRedoDMABuffer);
+        SSMR3GetU32(pSSMHandle, &pThis->aCts[i].cbRedoDMABuffer);
+
+        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
+        {
+            SSMR3GetBool(pSSMHandle, &pThis->aCts[i].aIfs[j].fLBA48);
+            SSMR3GetBool(pSSMHandle, &pThis->aCts[i].aIfs[j].fATAPI);
+            SSMR3GetBool(pSSMHandle, &pThis->aCts[i].aIfs[j].fIrqPending);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].cMultSectors);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].PCHSGeometry.cCylinders);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].PCHSGeometry.cHeads);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].PCHSGeometry.cSectors);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].cSectorsPerIRQ);
+            SSMR3GetU64(pSSMHandle, &pThis->aCts[i].aIfs[j].cTotalSectors);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegFeature);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegFeatureHOB);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegError);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegNSector);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegNSectorHOB);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegSector);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegSectorHOB);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegLCyl);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegLCylHOB);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegHCyl);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegHCylHOB);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegSelect);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegStatus);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegCommand);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATARegDevCtl);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATATransferMode);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uTxDir);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].iBeginTransfer);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].iSourceSink);
+            SSMR3GetBool(pSSMHandle, &pThis->aCts[i].aIfs[j].fDMA);
+            SSMR3GetBool(pSSMHandle, &pThis->aCts[i].aIfs[j].fATAPITransfer);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].cbTotalTransfer);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].cbElementaryTransfer);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].iIOBufferCur);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].iIOBufferEnd);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].iIOBufferPIODataStart);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].iIOBufferPIODataEnd);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].iATAPILBA);
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].cbATAPISector);
+            SSMR3GetMem(pSSMHandle, &pThis->aCts[i].aIfs[j].aATAPICmd, sizeof(pThis->aCts[i].aIfs[j].aATAPICmd));
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATAPISenseKey);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].uATAPIASC);
+            SSMR3GetU8(pSSMHandle, &pThis->aCts[i].aIfs[j].cNotifiedMediaChange);
+            SSMR3GetMem(pSSMHandle, &pThis->aCts[i].aIfs[j].Led, sizeof(pThis->aCts[i].aIfs[j].Led));
+            SSMR3GetU32(pSSMHandle, &pThis->aCts[i].aIfs[j].cbIOBuffer);
+            if (pThis->aCts[i].aIfs[j].cbIOBuffer)
             {
-                if (pData->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer))
-                    SSMR3GetMem(pSSMHandle, pData->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer), pData->aCts[i].aIfs[j].cbIOBuffer);
+                if (pThis->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer))
+                    SSMR3GetMem(pSSMHandle, pThis->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer), pThis->aCts[i].aIfs[j].cbIOBuffer);
                 else
                 {
@@ -5476 +5476 @@
                     /* skip the buffer if we're loading for the debugger / animator. */
                     uint8_t u8Ignored;
-                    size_t cbLeft = pData->aCts[i].aIfs[j].cbIOBuffer;
+                    size_t cbLeft = pThis->aCts[i].aIfs[j].cbIOBuffer;
                     while (cbLeft-- > 0)
                         SSMR3GetU8(pSSMHandle, &u8Ignored);
@@ -5482 +5482 @@
             }
             else
-                Assert(pData->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer) == NULL);
-        }
-    }
-    SSMR3GetBool(pSSMHandle, &pData->fPIIX4);
+                Assert(pThis->aCts[i].aIfs[j].CTX_SUFF(pbIOBuffer) == NULL);
+        }
+    }
+    SSMR3GetBool(pSSMHandle, &pThis->fPIIX4);
 
     rc = SSMR3GetU32(pSSMHandle, &u32);
@@ -5516 +5516 @@
 static DECLCALLBACK(int)   ataConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    PCIATAState    *pData = PDMINS_2_DATA(pDevIns, PCIATAState *);
+    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
     PPDMIBASE       pBase;
     int             rc;
@@ -5528 +5528 @@
      * Initialize NIL handle values (for the destructor).
      */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        pData->aCts[i].AsyncIOSem = NIL_RTSEMEVENT;
-        pData->aCts[i].SuspendIOSem = NIL_RTSEMEVENT;
-        pData->aCts[i].AsyncIORequestMutex = NIL_RTSEMEVENT;
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        pThis->aCts[i].AsyncIOSem = NIL_RTSEMEVENT;
+        pThis->aCts[i].SuspendIOSem = NIL_RTSEMEVENT;
+        pThis->aCts[i].AsyncIORequestMutex = NIL_RTSEMEVENT;
     }
 
@@ -5561 +5561 @@
     Assert(DelayIRQMillies < 50);
 
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "PIIX4", &pData->fPIIX4, false);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "PIIX4", &pThis->fPIIX4, false);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("PIIX3 configuration error: failed to read PIIX4 as boolean"));
-    Log(("%s: fPIIX4=%d\n", __FUNCTION__, pData->fPIIX4));
+    Log(("%s: fPIIX4=%d\n", __FUNCTION__, pThis->fPIIX4));
 
     /*
@@ -5571 +5571 @@
      */
     /* Status LUN. */
-    pData->IBase.pfnQueryInterface = ataStatus_QueryInterface;
-    pData->ILeds.pfnQueryStatusLed = ataStatus_QueryStatusLed;
+    pThis->IBase.pfnQueryInterface = ataStatus_QueryInterface;
+    pThis->ILeds.pfnQueryStatusLed = ataStatus_QueryStatusLed;
 
     /* PCI configuration space. */
-    PCIDevSetVendorId(&pData->dev, 0x8086); /* Intel */
-    if (pData->fPIIX4)
-    {
-        PCIDevSetDeviceId(&pData->dev, 0x7111); /* PIIX4 IDE */
-        PCIDevSetRevisionId(&pData->dev, 0x01); /* PIIX4E */
-        pData->dev.config[0x48] = 0x00; /* UDMACTL */
-        pData->dev.config[0x4A] = 0x00; /* UDMATIM */
-        pData->dev.config[0x4B] = 0x00;
+    PCIDevSetVendorId(&pThis->dev, 0x8086); /* Intel */
+    if (pThis->fPIIX4)
+    {
+        PCIDevSetDeviceId(&pThis->dev, 0x7111); /* PIIX4 IDE */
+        PCIDevSetRevisionId(&pThis->dev, 0x01); /* PIIX4E */
+        pThis->dev.config[0x48] = 0x00; /* UDMACTL */
+        pThis->dev.config[0x4A] = 0x00; /* UDMATIM */
+        pThis->dev.config[0x4B] = 0x00;
     }
     else
-        PCIDevSetDeviceId(&pData->dev, 0x7010); /* PIIX3 IDE */
-    PCIDevSetCommand(   &pData->dev, PCI_COMMAND_IOACCESS | PCI_COMMAND_MEMACCESS | PCI_COMMAND_BUSMASTER);
-    PCIDevSetClassProg( &pData->dev, 0x8a); /* programming interface = PCI_IDE bus master is supported */
-    PCIDevSetClassSub(  &pData->dev, 0x01); /* class_sub = PCI_IDE */
-    PCIDevSetClassBase( &pData->dev, 0x01); /* class_base = PCI_mass_storage */
-    PCIDevSetHeaderType(&pData->dev, 0x00);
-
-    pData->pDevIns          = pDevIns;
-    pData->fGCEnabled       = fGCEnabled;
-    pData->fR0Enabled       = fR0Enabled;
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        pData->aCts[i].pDevInsR3 = pDevIns;
-        pData->aCts[i].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-        pData->aCts[i].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-        pData->aCts[i].DelayIRQMillies = (uint32_t)DelayIRQMillies;
-        for (uint32_t j = 0; j < RT_ELEMENTS(pData->aCts[i].aIfs); j++)
-        {
-            pData->aCts[i].aIfs[j].iLUN = i * RT_ELEMENTS(pData->aCts) + j;
-            pData->aCts[i].aIfs[j].pDevInsR3 = pDevIns;
-            pData->aCts[i].aIfs[j].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-            pData->aCts[i].aIfs[j].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-            pData->aCts[i].aIfs[j].pControllerR3 = &pData->aCts[i];
-            pData->aCts[i].aIfs[j].pControllerR0 = MMHyperR3ToR0(PDMDevHlpGetVM(pDevIns), &pData->aCts[i]);
-            pData->aCts[i].aIfs[j].pControllerRC = MMHyperR3ToRC(PDMDevHlpGetVM(pDevIns), &pData->aCts[i]);
-            pData->aCts[i].aIfs[j].IBase.pfnQueryInterface = ataQueryInterface;
-            pData->aCts[i].aIfs[j].IMountNotify.pfnMountNotify = ataMountNotify;
-            pData->aCts[i].aIfs[j].IMountNotify.pfnUnmountNotify = ataUnmountNotify;
-            pData->aCts[i].aIfs[j].Led.u32Magic = PDMLED_MAGIC;
-        }
-    }
-
-    Assert(RT_ELEMENTS(pData->aCts) == 2);
-    pData->aCts[0].irq          = 14;
-    pData->aCts[0].IOPortBase1  = 0x1f0;
-    pData->aCts[0].IOPortBase2  = 0x3f6;
-    pData->aCts[1].irq          = 15;
-    pData->aCts[1].IOPortBase1  = 0x170;
-    pData->aCts[1].IOPortBase2  = 0x376;
+        PCIDevSetDeviceId(&pThis->dev, 0x7010); /* PIIX3 IDE */
+    PCIDevSetCommand(   &pThis->dev, PCI_COMMAND_IOACCESS | PCI_COMMAND_MEMACCESS | PCI_COMMAND_BUSMASTER);
+    PCIDevSetClassProg( &pThis->dev, 0x8a); /* programming interface = PCI_IDE bus master is supported */
+    PCIDevSetClassSub(  &pThis->dev, 0x01); /* class_sub = PCI_IDE */
+    PCIDevSetClassBase( &pThis->dev, 0x01); /* class_base = PCI_mass_storage */
+    PCIDevSetHeaderType(&pThis->dev, 0x00);
+
+    pThis->pDevIns          = pDevIns;
+    pThis->fGCEnabled       = fGCEnabled;
+    pThis->fR0Enabled       = fR0Enabled;
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        pThis->aCts[i].pDevInsR3 = pDevIns;
+        pThis->aCts[i].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+        pThis->aCts[i].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+        pThis->aCts[i].DelayIRQMillies = (uint32_t)DelayIRQMillies;
+        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
+        {
+            pThis->aCts[i].aIfs[j].iLUN = i * RT_ELEMENTS(pThis->aCts) + j;
+            pThis->aCts[i].aIfs[j].pDevInsR3 = pDevIns;
+            pThis->aCts[i].aIfs[j].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+            pThis->aCts[i].aIfs[j].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+            pThis->aCts[i].aIfs[j].pControllerR3 = &pThis->aCts[i];
+            pThis->aCts[i].aIfs[j].pControllerR0 = MMHyperR3ToR0(PDMDevHlpGetVM(pDevIns), &pThis->aCts[i]);
+            pThis->aCts[i].aIfs[j].pControllerRC = MMHyperR3ToRC(PDMDevHlpGetVM(pDevIns), &pThis->aCts[i]);
+            pThis->aCts[i].aIfs[j].IBase.pfnQueryInterface = ataQueryInterface;
+            pThis->aCts[i].aIfs[j].IMountNotify.pfnMountNotify = ataMountNotify;
+            pThis->aCts[i].aIfs[j].IMountNotify.pfnUnmountNotify = ataUnmountNotify;
+            pThis->aCts[i].aIfs[j].Led.u32Magic = PDMLED_MAGIC;
+        }
+    }
+
+    Assert(RT_ELEMENTS(pThis->aCts) == 2);
+    pThis->aCts[0].irq          = 14;
+    pThis->aCts[0].IOPortBase1  = 0x1f0;
+    pThis->aCts[0].IOPortBase2  = 0x3f6;
+    pThis->aCts[1].irq          = 15;
+    pThis->aCts[1].IOPortBase1  = 0x170;
+    pThis->aCts[1].IOPortBase2  = 0x376;
 
     /*
@@ -5630 +5630 @@
      *      device the slot next to itself.
      */
-    rc = PDMDevHlpPCIRegister(pDevIns, &pData->dev);
+    rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("PIIX3 cannot register PCI device"));
-    AssertMsg(pData->dev.devfn == 9 || iInstance != 0, ("pData->dev.devfn=%d\n", pData->dev.devfn));
+    AssertMsg(pThis->dev.devfn == 9 || iInstance != 0, ("pThis->dev.devfn=%d\n", pThis->dev.devfn));
     rc = PDMDevHlpPCIIORegionRegister(pDevIns, 4, 0x10, PCI_ADDRESS_SPACE_IO, ataBMDMAIORangeMap);
     if (RT_FAILURE(rc))
@@ -5644 +5644 @@
      * The ports are all hardcoded and enforced by the PIIX3 host bridge controller.
      */
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        rc = PDMDevHlpIOPortRegister(pDevIns, pData->aCts[i].IOPortBase1, 8, (RTHCPTR)i,
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        rc = PDMDevHlpIOPortRegister(pDevIns, pThis->aCts[i].IOPortBase1, 8, (RTHCPTR)i,
                                      ataIOPortWrite1, ataIOPortRead1, ataIOPortWriteStr1, ataIOPortReadStr1, "ATA I/O Base 1");
         if (RT_FAILURE(rc))
@@ -5653 +5653 @@
         if (fGCEnabled)
         {
-            rc = PDMDevHlpIOPortRegisterGC(pDevIns, pData->aCts[i].IOPortBase1, 8, (RTGCPTR)i,
+            rc = PDMDevHlpIOPortRegisterGC(pDevIns, pThis->aCts[i].IOPortBase1, 8, (RTGCPTR)i,
                                            "ataIOPortWrite1", "ataIOPortRead1", "ataIOPortWriteStr1", "ataIOPortReadStr1", "ATA I/O Base 1");
             if (RT_FAILURE(rc))
@@ -5662 +5662 @@
         {
 #if 1
-            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pData->aCts[i].IOPortBase1, 8, (RTR0PTR)i,
+            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pThis->aCts[i].IOPortBase1, 8, (RTR0PTR)i,
                                            "ataIOPortWrite1", "ataIOPortRead1", NULL, NULL, "ATA I/O Base 1");
 #else
-            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pData->aCts[i].IOPortBase1, 8, (RTR0PTR)i,
+            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pThis->aCts[i].IOPortBase1, 8, (RTR0PTR)i,
                                            "ataIOPortWrite1", "ataIOPortRead1", "ataIOPortWriteStr1", "ataIOPortReadStr1", "ATA I/O Base 1");
 #endif
@@ -5672 +5672 @@
         }
 
-        rc = PDMDevHlpIOPortRegister(pDevIns, pData->aCts[i].IOPortBase2, 1, (RTHCPTR)i,
+        rc = PDMDevHlpIOPortRegister(pDevIns, pThis->aCts[i].IOPortBase2, 1, (RTHCPTR)i,
                                      ataIOPortWrite2, ataIOPortRead2, NULL, NULL, "ATA I/O Base 2");
         if (RT_FAILURE(rc))
@@ -5679 +5679 @@
         if (fGCEnabled)
         {
-            rc = PDMDevHlpIOPortRegisterGC(pDevIns, pData->aCts[i].IOPortBase2, 1, (RTGCPTR)i,
+            rc = PDMDevHlpIOPortRegisterGC(pDevIns, pThis->aCts[i].IOPortBase2, 1, (RTGCPTR)i,
                                            "ataIOPortWrite2", "ataIOPortRead2", NULL, NULL, "ATA I/O Base 2");
             if (RT_FAILURE(rc))
@@ -5686 +5686 @@
         if (fR0Enabled)
         {
-            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pData->aCts[i].IOPortBase2, 1, (RTR0PTR)i,
+            rc = PDMDevHlpIOPortRegisterR0(pDevIns, pThis->aCts[i].IOPortBase2, 1, (RTR0PTR)i,
                                            "ataIOPortWrite2", "ataIOPortRead2", NULL, NULL, "ATA I/O Base 2");
             if (RT_FAILURE(rc))
@@ -5692 +5692 @@
         }
 
-        for (uint32_t j = 0; j < RT_ELEMENTS(pData->aCts[i].aIfs); j++)
-        {
-            ATADevState *pIf = &pData->aCts[i].aIfs[j];
+        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
+        {
+            ATADevState *pIf = &pThis->aCts[i].aIfs[j];
             PDMDevHlpSTAMRegisterF(pDevIns, &pIf->StatATADMA,       STAMTYPE_COUNTER,    STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,       "Number of ATA DMA transfers.", "/Devices/ATA%d/Unit%d/DMA", i, j);
             PDMDevHlpSTAMRegisterF(pDevIns, &pIf->StatATAPIO,       STAMTYPE_COUNTER,    STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,       "Number of ATA PIO transfers.", "/Devices/ATA%d/Unit%d/PIO", i, j);
@@ -5715 +5715 @@
         }
 #ifdef VBOX_WITH_STATISTICS /** @todo release too. */
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatAsyncOps,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,   "The number of async operations.",  "/Devices/ATA%d/Async/Operations", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatAsyncOps,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,   "The number of async operations.",  "/Devices/ATA%d/Async/Operations", i);
         /** @todo STAMUNIT_MICROSECS */
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatAsyncMinWait, STAMTYPE_U64_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Minimum wait in microseconds.",    "/Devices/ATA%d/Async/MinWait", i);
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatAsyncMaxWait, STAMTYPE_U64_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Maximum wait in microseconds.",    "/Devices/ATA%d/Async/MaxWait", i);
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatAsyncTimeUS,    STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Total time spent in microseconds.","/Devices/ATA%d/Async/TotalTimeUS", i);
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatAsyncTime,  STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling of async operations.", "/Devices/ATA%d/Async/Time", i);
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aCts[i].StatLockWait,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling of locks.",            "/Devices/ATA%d/Async/LockWait", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatAsyncMinWait, STAMTYPE_U64_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Minimum wait in microseconds.",    "/Devices/ATA%d/Async/MinWait", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatAsyncMaxWait, STAMTYPE_U64_RESET, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Maximum wait in microseconds.",    "/Devices/ATA%d/Async/MaxWait", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatAsyncTimeUS,    STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_NONE,         "Total time spent in microseconds.","/Devices/ATA%d/Async/TotalTimeUS", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatAsyncTime,  STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling of async operations.", "/Devices/ATA%d/Async/Time", i);
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aCts[i].StatLockWait,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling of locks.",            "/Devices/ATA%d/Async/LockWait", i);
 #endif /* VBOX_WITH_STATISTICS */
 
@@ -5727 +5727 @@
         char szName[24];
         RTStrPrintf(szName, sizeof(szName), "ATA%d", i);
-        rc = PDMDevHlpCritSectInit(pDevIns, &pData->aCts[i].lock, szName);
+        rc = PDMDevHlpCritSectInit(pDevIns, &pThis->aCts[i].lock, szName);
         if (RT_FAILURE(rc))
             return PDMDEV_SET_ERROR(pDevIns, rc, N_("PIIX3 cannot initialize critical section"));
@@ -5735 +5735 @@
      * Attach status driver (optional).
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pData->IBase, &pBase, "Status Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
     if (RT_SUCCESS(rc))
-        pData->pLedsConnector = (PDMILEDCONNECTORS *)pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
+        pThis->pLedsConnector = (PDMILEDCONNECTORS *)pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
     else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
     {
@@ -5748 +5748 @@
      */
     uint32_t cbTotalBuffer = 0;
-    for (uint32_t i = 0; i < RT_ELEMENTS(pData->aCts); i++)
-    {
-        PATACONTROLLER pCtl = &pData->aCts[i];
+    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
+    {
+        PATACONTROLLER pCtl = &pThis->aCts[i];
 
         /*
@@ -5770 +5770 @@
         for (uint32_t j = 0; j < RT_ELEMENTS(pCtl->aIfs); j++)
         {
-            static const char *s_apszDescs[RT_ELEMENTS(pData->aCts)][RT_ELEMENTS(pCtl->aIfs)] =
+            static const char *s_apszDescs[RT_ELEMENTS(pThis->aCts)][RT_ELEMENTS(pCtl->aIfs)] =
             {
                 { "Primary Master", "Primary Slave" },
@@ -5814 +5814 @@
 
     rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance,
-                              ATA_SAVED_STATE_VERSION, sizeof(*pData) + cbTotalBuffer,
+                              ATA_SAVED_STATE_VERSION, sizeof(*pThis) + cbTotalBuffer,
                               ataSaveLoadPrep, ataSaveExec, NULL,
                               ataSaveLoadPrep, ataLoadExec, NULL);

trunk/src/VBox/Devices/Storage/DrvBlock.cpp

@@ -127 +127 @@
 static DECLCALLBACK(int) drvblockRead(PPDMIBLOCK pInterface, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -138 +138 @@
     }
 
-    int rc = pData->pDrvMedia->pfnRead(pData->pDrvMedia, off, pvBuf, cbRead);
+    int rc = pThis->pDrvMedia->pfnRead(pThis->pDrvMedia, off, pvBuf, cbRead);
     return rc;
 }
@@ -146 +146 @@
 static DECLCALLBACK(int) drvblockWrite(PPDMIBLOCK pInterface, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -157 +157 @@
     }
 
-    int rc = pData->pDrvMedia->pfnWrite(pData->pDrvMedia, off, pvBuf, cbWrite);
+    int rc = pThis->pDrvMedia->pfnWrite(pThis->pDrvMedia, off, pvBuf, cbWrite);
 #ifdef VBOX_PERIODIC_FLUSH
-    if (pData->cbFlushInterval)
-    {
-        pData->cbDataWritten += cbWrite;
-        if (pData->cbDataWritten > pData->cbFlushInterval)
+    if (pThis->cbFlushInterval)
+    {
+        pThis->cbDataWritten += cbWrite;
+        if (pThis->cbDataWritten > pThis->cbFlushInterval)
         {
-            pData->cbDataWritten = 0;
-            pData->pDrvMedia->pfnFlush(pData->pDrvMedia);
+            pThis->cbDataWritten = 0;
+            pThis->pDrvMedia->pfnFlush(pThis->pDrvMedia);
         }
     }
@@ -177 +177 @@
 static DECLCALLBACK(int) drvblockFlush(PPDMIBLOCK pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -189 +189 @@
 
 #ifdef VBOX_IGNORE_FLUSH
-    if (pData->fIgnoreFlush)
+    if (pThis->fIgnoreFlush)
         return VINF_SUCCESS;
 #endif /* VBOX_IGNORE_FLUSH */
 
-    int rc = pData->pDrvMedia->pfnFlush(pData->pDrvMedia);
+    int rc = pThis->pDrvMedia->pfnFlush(pThis->pDrvMedia);
     if (rc == VERR_NOT_IMPLEMENTED)
         rc = VINF_SUCCESS;
@@ -203 +203 @@
 static DECLCALLBACK(bool) drvblockIsReadOnly(PPDMIBLOCK pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
         return false;
 
-    bool fRc = pData->pDrvMedia->pfnIsReadOnly(pData->pDrvMedia);
+    bool fRc = pThis->pDrvMedia->pfnIsReadOnly(pThis->pDrvMedia);
     return fRc;
 }
@@ -219 +219 @@
 static DECLCALLBACK(uint64_t) drvblockGetSize(PPDMIBLOCK pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
         return 0;
 
-    uint64_t cb = pData->pDrvMedia->pfnGetSize(pData->pDrvMedia);
+    uint64_t cb = pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia);
     LogFlow(("drvblockGetSize: returns %llu\n", cb));
     return cb;
@@ -236 +236 @@
 static DECLCALLBACK(PDMBLOCKTYPE) drvblockGetType(PPDMIBLOCK pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
-    LogFlow(("drvblockGetType: returns %d\n", pData->enmType));
-    return pData->enmType;
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
+    LogFlow(("drvblockGetType: returns %d\n", pThis->enmType));
+    return pThis->enmType;
 }
 
@@ -245 +245 @@
 static DECLCALLBACK(int) drvblockGetUuid(PPDMIBLOCK pInterface, PRTUUID pUuid)
 {
-    PDRVBLOCK pData = PDMIBLOCK_2_DRVBLOCK(pInterface);
+    PDRVBLOCK pThis = PDMIBLOCK_2_DRVBLOCK(pInterface);
 
     /*
      * Copy the uuid.
      */
-    *pUuid = pData->Uuid;
+    *pUuid = pThis->Uuid;
     return VINF_SUCCESS;
 }
@@ -262 +262 @@
 static DECLCALLBACK(int) drvblockAsyncReadStart(PPDMIBLOCKASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbRead, void *pvUser)
 {
-    PDRVBLOCK pData = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMediaAsync)
+    PDRVBLOCK pThis = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMediaAsync)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -273 +273 @@
     }
 
-    int rc = pData->pDrvMediaAsync->pfnStartRead(pData->pDrvMediaAsync, off, pSeg, cSeg, cbRead, pvUser);
+    int rc = pThis->pDrvMediaAsync->pfnStartRead(pThis->pDrvMediaAsync, off, pSeg, cSeg, cbRead, pvUser);
     return rc;
 }
@@ -281 +281 @@
 static DECLCALLBACK(int) drvblockAsyncWriteStart(PPDMIBLOCKASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbWrite, void *pvUser)
 {
-    PDRVBLOCK pData = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMediaAsync)
+    PDRVBLOCK pThis = PDMIBLOCKASYNC_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMediaAsync)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -292 +292 @@
     }
 
-    int rc = pData->pDrvMediaAsync->pfnStartWrite(pData->pDrvMediaAsync, off, pSeg, cSeg, cbWrite, pvUser);
+    int rc = pThis->pDrvMediaAsync->pfnStartWrite(pThis->pDrvMediaAsync, off, pSeg, cSeg, cbWrite, pvUser);
 
     return rc;
@@ -304 +304 @@
 static DECLCALLBACK(int) drvblockAsyncTransferCompleteNotify(PPDMIMEDIAASYNCPORT pInterface, void *pvUser)
 {
-    PDRVBLOCK pData = PDMIMEDIAASYNCPORT_2_DRVBLOCK(pInterface);
-
-    return pData->pDrvBlockAsyncPort->pfnTransferCompleteNotify(pData->pDrvBlockAsyncPort, pvUser);
+    PDRVBLOCK pThis = PDMIMEDIAASYNCPORT_2_DRVBLOCK(pInterface);
+
+    return pThis->pDrvBlockAsyncPort->pfnTransferCompleteNotify(pThis->pDrvBlockAsyncPort, pvUser);
 }
 
@@ -318 +318 @@
 static DECLCALLBACK(int) drvblockGetPCHSGeometry(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry)
 {
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
         return VERR_PDM_MEDIA_NOT_MOUNTED;
 
@@ -329 +329 @@
      * Use configured/cached values if present.
      */
-    if (    pData->PCHSGeometry.cCylinders > 0
-        &&  pData->PCHSGeometry.cHeads > 0
-        &&  pData->PCHSGeometry.cSectors > 0)
-    {
-        *pPCHSGeometry = pData->PCHSGeometry;
-        LogFlow(("%s: returns VINF_SUCCESS {%d,%d,%d}\n", __FUNCTION__, pData->PCHSGeometry.cCylinders, pData->PCHSGeometry.cHeads, pData->PCHSGeometry.cSectors));
+    if (    pThis->PCHSGeometry.cCylinders > 0
+        &&  pThis->PCHSGeometry.cHeads > 0
+        &&  pThis->PCHSGeometry.cSectors > 0)
+    {
+        *pPCHSGeometry = pThis->PCHSGeometry;
+        LogFlow(("%s: returns VINF_SUCCESS {%d,%d,%d}\n", __FUNCTION__, pThis->PCHSGeometry.cCylinders, pThis->PCHSGeometry.cHeads, pThis->PCHSGeometry.cSectors));
         return VINF_SUCCESS;
     }
@@ -341 +341 @@
      * Call media.
      */
-    int rc = pData->pDrvMedia->pfnBiosGetPCHSGeometry(pData->pDrvMedia, &pData->PCHSGeometry);
+    int rc = pThis->pDrvMedia->pfnBiosGetPCHSGeometry(pThis->pDrvMedia, &pThis->PCHSGeometry);
 
     if (RT_SUCCESS(rc))
     {
-        *pPCHSGeometry = pData->PCHSGeometry;
-        LogFlow(("%s: returns %Vrc {%d,%d,%d}\n", __FUNCTION__, rc, pData->PCHSGeometry.cCylinders, pData->PCHSGeometry.cHeads, pData->PCHSGeometry.cSectors));
+        *pPCHSGeometry = pThis->PCHSGeometry;
+        LogFlow(("%s: returns %Vrc {%d,%d,%d}\n", __FUNCTION__, rc, pThis->PCHSGeometry.cCylinders, pThis->PCHSGeometry.cHeads, pThis->PCHSGeometry.cSectors));
     }
     else if (rc == VERR_NOT_IMPLEMENTED)
@@ -361 +361 @@
 {
     LogFlow(("%s: cCylinders=%d cHeads=%d cSectors=%d\n", __FUNCTION__, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -375 +375 @@
      * Call media. Ignore the not implemented return code.
      */
-    int rc = pData->pDrvMedia->pfnBiosSetPCHSGeometry(pData->pDrvMedia, pPCHSGeometry);
+    int rc = pThis->pDrvMedia->pfnBiosSetPCHSGeometry(pThis->pDrvMedia, pPCHSGeometry);
 
     if (    RT_SUCCESS(rc)
         ||  rc == VERR_NOT_IMPLEMENTED)
     {
-        pData->PCHSGeometry = *pPCHSGeometry;
+        pThis->PCHSGeometry = *pPCHSGeometry;
         rc = VINF_SUCCESS;
     }
@@ -390 +390 @@
 static DECLCALLBACK(int) drvblockGetLCHSGeometry(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry)
 {
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
         return VERR_PDM_MEDIA_NOT_MOUNTED;
 
@@ -401 +401 @@
      * Use configured/cached values if present.
      */
-    if (    pData->LCHSGeometry.cCylinders > 0
-        &&  pData->LCHSGeometry.cHeads > 0
-        &&  pData->LCHSGeometry.cSectors > 0)
-    {
-        *pLCHSGeometry = pData->LCHSGeometry;
-        LogFlow(("%s: returns VINF_SUCCESS {%d,%d,%d}\n", __FUNCTION__, pData->LCHSGeometry.cCylinders, pData->LCHSGeometry.cHeads, pData->LCHSGeometry.cSectors));
+    if (    pThis->LCHSGeometry.cCylinders > 0
+        &&  pThis->LCHSGeometry.cHeads > 0
+        &&  pThis->LCHSGeometry.cSectors > 0)
+    {
+        *pLCHSGeometry = pThis->LCHSGeometry;
+        LogFlow(("%s: returns VINF_SUCCESS {%d,%d,%d}\n", __FUNCTION__, pThis->LCHSGeometry.cCylinders, pThis->LCHSGeometry.cHeads, pThis->LCHSGeometry.cSectors));
         return VINF_SUCCESS;
     }
@@ -413 +413 @@
      * Call media.
      */
-    int rc = pData->pDrvMedia->pfnBiosGetLCHSGeometry(pData->pDrvMedia, &pData->LCHSGeometry);
+    int rc = pThis->pDrvMedia->pfnBiosGetLCHSGeometry(pThis->pDrvMedia, &pThis->LCHSGeometry);
 
     if (RT_SUCCESS(rc))
     {
-        *pLCHSGeometry = pData->LCHSGeometry;
-        LogFlow(("%s: returns %Vrc {%d,%d,%d}\n", __FUNCTION__, rc, pData->LCHSGeometry.cCylinders, pData->LCHSGeometry.cHeads, pData->LCHSGeometry.cSectors));
+        *pLCHSGeometry = pThis->LCHSGeometry;
+        LogFlow(("%s: returns %Vrc {%d,%d,%d}\n", __FUNCTION__, rc, pThis->LCHSGeometry.cCylinders, pThis->LCHSGeometry.cHeads, pThis->LCHSGeometry.cSectors));
     }
     else if (rc == VERR_NOT_IMPLEMENTED)
@@ -433 +433 @@
 {
     LogFlow(("%s: cCylinders=%d cHeads=%d cSectors=%d\n", __FUNCTION__, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-
-    /*
-     * Check the state.
-     */
-    if (!pData->pDrvMedia)
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+
+    /*
+     * Check the state.
+     */
+    if (!pThis->pDrvMedia)
     {
         AssertMsgFailed(("Invalid state! Not mounted!\n"));
@@ -447 +447 @@
      * Call media. Ignore the not implemented return code.
      */
-    int rc = pData->pDrvMedia->pfnBiosSetLCHSGeometry(pData->pDrvMedia, pLCHSGeometry);
+    int rc = pThis->pDrvMedia->pfnBiosSetLCHSGeometry(pThis->pDrvMedia, pLCHSGeometry);
 
     if (    RT_SUCCESS(rc)
         ||  rc == VERR_NOT_IMPLEMENTED)
     {
-        pData->LCHSGeometry = *pLCHSGeometry;
+        pThis->LCHSGeometry = *pLCHSGeometry;
         rc = VINF_SUCCESS;
     }
@@ -462 +462 @@
 static DECLCALLBACK(bool) drvblockIsVisible(PPDMIBLOCKBIOS pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-    LogFlow(("drvblockIsVisible: returns %d\n", pData->fBiosVisible));
-    return pData->fBiosVisible;
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+    LogFlow(("drvblockIsVisible: returns %d\n", pThis->fBiosVisible));
+    return pThis->fBiosVisible;
 }
 
@@ -471 +471 @@
 static DECLCALLBACK(PDMBLOCKTYPE) drvblockBiosGetType(PPDMIBLOCKBIOS pInterface)
 {
-    PDRVBLOCK pData = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
-    LogFlow(("drvblockBiosGetType: returns %d\n", pData->enmType));
-    return pData->enmType;
+    PDRVBLOCK pThis = PDMIBLOCKBIOS_2_DRVBLOCK(pInterface);
+    LogFlow(("drvblockBiosGetType: returns %d\n", pThis->enmType));
+    return pThis->enmType;
 }
 
@@ -488 +488 @@
 {
     LogFlow(("drvblockMount: pszFilename=%p:{%s} pszCoreDriver=%p:{%s}\n", pszFilename, pszFilename, pszCoreDriver, pszCoreDriver));
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
 
     /*
      * Validate state.
      */
-    if (pData->pDrvMedia)
+    if (pThis->pDrvMedia)
     {
         AssertMsgFailed(("Already mounted\n"));
@@ -504 +504 @@
     if (pszFilename)
     {
-        int rc = pData->pDrvIns->pDrvHlp->pfnMountPrepare(pData->pDrvIns, pszFilename, pszCoreDriver);
+        int rc = pThis->pDrvIns->pDrvHlp->pfnMountPrepare(pThis->pDrvIns, pszFilename, pszCoreDriver);
         if (RT_FAILURE(rc))
         {
@@ -516 +516 @@
      */
     PPDMIBASE pBase;
-    int rc = pData->pDrvIns->pDrvHlp->pfnAttach(pData->pDrvIns, &pBase);
+    int rc = pThis->pDrvIns->pDrvHlp->pfnAttach(pThis->pDrvIns, &pBase);
     if (RT_FAILURE(rc))
     {
@@ -523 +523 @@
     }
 
-    pData->pDrvMedia = (PPDMIMEDIA)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA);
-    if (pData->pDrvMedia)
+    pThis->pDrvMedia = (PPDMIMEDIA)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA);
+    if (pThis->pDrvMedia)
     {
         /*
          * Initialize state.
          */
-        pData->fLocked = false;
-        pData->PCHSGeometry.cCylinders  = 0;
-        pData->PCHSGeometry.cHeads      = 0;
-        pData->PCHSGeometry.cSectors    = 0;
-        pData->LCHSGeometry.cCylinders  = 0;
-        pData->LCHSGeometry.cHeads      = 0;
-        pData->LCHSGeometry.cSectors    = 0;
+        pThis->fLocked = false;
+        pThis->PCHSGeometry.cCylinders  = 0;
+        pThis->PCHSGeometry.cHeads      = 0;
+        pThis->PCHSGeometry.cSectors    = 0;
+        pThis->LCHSGeometry.cCylinders  = 0;
+        pThis->LCHSGeometry.cHeads      = 0;
+        pThis->LCHSGeometry.cSectors    = 0;
 #ifdef VBOX_PERIODIC_FLUSH
-        pData->cbDataWritten = 0;
+        pThis->cbDataWritten = 0;
 #endif /* VBOX_PERIODIC_FLUSH */
 
@@ -543 +543 @@
          * Notify driver/device above us.
          */
-        if (pData->pDrvMountNotify)
-            pData->pDrvMountNotify->pfnMountNotify(pData->pDrvMountNotify);
+        if (pThis->pDrvMountNotify)
+            pThis->pDrvMountNotify->pfnMountNotify(pThis->pDrvMountNotify);
         Log(("drvblockMount: Success\n"));
         return VINF_SUCCESS;
@@ -555 +555 @@
      */
     AssertMsgFailed(("No media interface!\n"));
-    int rc2 = pData->pDrvIns->pDrvHlp->pfnDetach(pData->pDrvIns);
+    int rc2 = pThis->pDrvIns->pDrvHlp->pfnDetach(pThis->pDrvIns);
     AssertRC(rc2);
-    pData->pDrvMedia = NULL;
+    pThis->pDrvMedia = NULL;
     return rc;
 }
@@ -565 +565 @@
 static DECLCALLBACK(int) drvblockUnmount(PPDMIMOUNT pInterface, bool fForce)
 {
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
 
     /*
      * Validate state.
      */
-    if (!pData->pDrvMedia)
+    if (!pThis->pDrvMedia)
     {
         Log(("drvblockUmount: Not mounted\n"));
         return VERR_PDM_MEDIA_NOT_MOUNTED;
     }
-    if (pData->fLocked && !fForce)
+    if (pThis->fLocked && !fForce)
     {
         Log(("drvblockUmount: Locked\n"));
@@ -582 +582 @@
 
     /* Media is no longer locked even if it was previously. */
-    pData->fLocked = false;
+    pThis->fLocked = false;
 
     /*
      * Detach the media driver and query it's interface.
      */
-    int rc = pData->pDrvIns->pDrvHlp->pfnDetach(pData->pDrvIns);
+    int rc = pThis->pDrvIns->pDrvHlp->pfnDetach(pThis->pDrvIns);
     if (RT_FAILURE(rc))
     {
@@ -593 +593 @@
         return rc;
     }
-    Assert(!pData->pDrvMedia);
+    Assert(!pThis->pDrvMedia);
 
     /*
      * Notify driver/device above us.
      */
-    if (pData->pDrvMountNotify)
-        pData->pDrvMountNotify->pfnUnmountNotify(pData->pDrvMountNotify);
+    if (pThis->pDrvMountNotify)
+        pThis->pDrvMountNotify->pfnUnmountNotify(pThis->pDrvMountNotify);
     Log(("drvblockUnmount: success\n"));
     return VINF_SUCCESS;
@@ -608 +608 @@
 static DECLCALLBACK(bool) drvblockIsMounted(PPDMIMOUNT pInterface)
 {
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
-    return pData->pDrvMedia != NULL;
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    return pThis->pDrvMedia != NULL;
 }
 
@@ -615 +615 @@
 static DECLCALLBACK(int) drvblockLock(PPDMIMOUNT pInterface)
 {
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
-    Log(("drvblockLock: %d -> %d\n", pData->fLocked, true));
-    pData->fLocked = true;
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    Log(("drvblockLock: %d -> %d\n", pThis->fLocked, true));
+    pThis->fLocked = true;
     return VINF_SUCCESS;
 }
@@ -624 +624 @@
 static DECLCALLBACK(int) drvblockUnlock(PPDMIMOUNT pInterface)
 {
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
-    Log(("drvblockUnlock: %d -> %d\n", pData->fLocked, false));
-    pData->fLocked = false;
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    Log(("drvblockUnlock: %d -> %d\n", pThis->fLocked, false));
+    pThis->fLocked = false;
     return VINF_SUCCESS;
 }
@@ -633 +633 @@
 static DECLCALLBACK(bool) drvblockIsLocked(PPDMIMOUNT pInterface)
 {
-    PDRVBLOCK pData = PDMIMOUNT_2_DRVBLOCK(pInterface);
-    return pData->fLocked;
+    PDRVBLOCK pThis = PDMIMOUNT_2_DRVBLOCK(pInterface);
+    return pThis->fLocked;
 }
 
@@ -644 +644 @@
 {
     PPDMDRVINS  pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVBLOCK   pData = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
+    PDRVBLOCK   pThis = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
     switch (enmInterface)
     {
@@ -650 +650 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_BLOCK:
-            return &pData->IBlock;
+            return &pThis->IBlock;
         case PDMINTERFACE_BLOCK_BIOS:
-            return pData->fBiosVisible ? &pData->IBlockBios : NULL;
+            return pThis->fBiosVisible ? &pThis->IBlockBios : NULL;
         case PDMINTERFACE_MOUNT:
-            return pData->fMountable ? &pData->IMount : NULL;
+            return pThis->fMountable ? &pThis->IMount : NULL;
         case PDMINTERFACE_BLOCK_ASYNC:
-            return pData->pDrvMediaAsync ? &pData->IBlockAsync : NULL;
+            return pThis->pDrvMediaAsync ? &pThis->IBlockAsync : NULL;
         case PDMINTERFACE_MEDIA_ASYNC_PORT:
-            return pData->pDrvBlockAsyncPort ? &pData->IMediaAsyncPort : NULL;
+            return pThis->pDrvBlockAsyncPort ? &pThis->IMediaAsyncPort : NULL;
         default:
             return NULL;
@@ -670 +670 @@
 static DECLCALLBACK(void)  drvblockDetach(PPDMDRVINS pDrvIns)
 {
-    PDRVBLOCK pData = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
-    pData->pDrvMedia = NULL;
-    pData->pDrvMediaAsync = NULL;
+    PDRVBLOCK pThis = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
+    pThis->pDrvMedia = NULL;
+    pThis->pDrvMediaAsync = NULL;
 }
 
@@ -683 +683 @@
 static DECLCALLBACK(void)  drvblockReset(PPDMDRVINS pDrvIns)
 {
-    PDRVBLOCK pData = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
-
-    pData->fLocked = false;
+    PDRVBLOCK pThis = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
+
+    pThis->fLocked = false;
 }
 
@@ -700 +700 @@
 static DECLCALLBACK(int) drvblockConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVBLOCK pData = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
+    PDRVBLOCK pThis = PDMINS_2_DATA(pDrvIns, PDRVBLOCK);
     LogFlow(("drvblockConstruct: iInstance=%d\n", pDrvIns->iInstance));
 
@@ -716 +716 @@
      * Initialize most of the data members.
      */
-    pData->pDrvIns                          = pDrvIns;
+    pThis->pDrvIns                          = pDrvIns;
 
     /* IBase. */
@@ -722 +722 @@
 
     /* IBlock. */
-    pData->IBlock.pfnRead                   = drvblockRead;
-    pData->IBlock.pfnWrite                  = drvblockWrite;
-    pData->IBlock.pfnFlush                  = drvblockFlush;
-    pData->IBlock.pfnIsReadOnly             = drvblockIsReadOnly;
-    pData->IBlock.pfnGetSize                = drvblockGetSize;
-    pData->IBlock.pfnGetType                = drvblockGetType;
-    pData->IBlock.pfnGetUuid                = drvblockGetUuid;
+    pThis->IBlock.pfnRead                   = drvblockRead;
+    pThis->IBlock.pfnWrite                  = drvblockWrite;
+    pThis->IBlock.pfnFlush                  = drvblockFlush;
+    pThis->IBlock.pfnIsReadOnly             = drvblockIsReadOnly;
+    pThis->IBlock.pfnGetSize                = drvblockGetSize;
+    pThis->IBlock.pfnGetType                = drvblockGetType;
+    pThis->IBlock.pfnGetUuid                = drvblockGetUuid;
 
     /* IBlockBios. */
-    pData->IBlockBios.pfnGetPCHSGeometry    = drvblockGetPCHSGeometry;
-    pData->IBlockBios.pfnSetPCHSGeometry    = drvblockSetPCHSGeometry;
-    pData->IBlockBios.pfnGetLCHSGeometry    = drvblockGetLCHSGeometry;
-    pData->IBlockBios.pfnSetLCHSGeometry    = drvblockSetLCHSGeometry;
-    pData->IBlockBios.pfnIsVisible          = drvblockIsVisible;
-    pData->IBlockBios.pfnGetType            = drvblockBiosGetType;
+    pThis->IBlockBios.pfnGetPCHSGeometry    = drvblockGetPCHSGeometry;
+    pThis->IBlockBios.pfnSetPCHSGeometry    = drvblockSetPCHSGeometry;
+    pThis->IBlockBios.pfnGetLCHSGeometry    = drvblockGetLCHSGeometry;
+    pThis->IBlockBios.pfnSetLCHSGeometry    = drvblockSetLCHSGeometry;
+    pThis->IBlockBios.pfnIsVisible          = drvblockIsVisible;
+    pThis->IBlockBios.pfnGetType            = drvblockBiosGetType;
 
     /* IMount. */
-    pData->IMount.pfnMount                  = drvblockMount;
-    pData->IMount.pfnUnmount                = drvblockUnmount;
-    pData->IMount.pfnIsMounted              = drvblockIsMounted;
-    pData->IMount.pfnLock                   = drvblockLock;
-    pData->IMount.pfnUnlock                 = drvblockUnlock;
-    pData->IMount.pfnIsLocked               = drvblockIsLocked;
+    pThis->IMount.pfnMount                  = drvblockMount;
+    pThis->IMount.pfnUnmount                = drvblockUnmount;
+    pThis->IMount.pfnIsMounted              = drvblockIsMounted;
+    pThis->IMount.pfnLock                   = drvblockLock;
+    pThis->IMount.pfnUnlock                 = drvblockUnlock;
+    pThis->IMount.pfnIsLocked               = drvblockIsLocked;
 
     /* IBlockAsync. */
-    pData->IBlockAsync.pfnStartRead         = drvblockAsyncReadStart;
-    pData->IBlockAsync.pfnStartWrite        = drvblockAsyncWriteStart;
+    pThis->IBlockAsync.pfnStartRead         = drvblockAsyncReadStart;
+    pThis->IBlockAsync.pfnStartWrite        = drvblockAsyncWriteStart;
 
     /* IMediaAsyncPort. */
-    pData->IMediaAsyncPort.pfnTransferCompleteNotify  = drvblockAsyncTransferCompleteNotify;
+    pThis->IMediaAsyncPort.pfnTransferCompleteNotify  = drvblockAsyncTransferCompleteNotify;
 
     /*
      * Get the IBlockPort & IMountNotify interfaces of the above driver/device.
      */
-    pData->pDrvBlockPort = (PPDMIBLOCKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_BLOCK_PORT);
-    if (!pData->pDrvBlockPort)
+    pThis->pDrvBlockPort = (PPDMIBLOCKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_BLOCK_PORT);
+    if (!pThis->pDrvBlockPort)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
                                 N_("No block port interface above"));
 
     /* Try to get the optional async block port interface above. */
-    pData->pDrvBlockAsyncPort = (PPDMIBLOCKASYNCPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_BLOCK_ASYNC_PORT);
-
-    pData->pDrvMountNotify = (PPDMIMOUNTNOTIFY)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_MOUNT_NOTIFY);
+    pThis->pDrvBlockAsyncPort = (PPDMIBLOCKASYNCPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_BLOCK_ASYNC_PORT);
+
+    pThis->pDrvMountNotify = (PPDMIMOUNTNOTIFY)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_MOUNT_NOTIFY);
 
     /*
@@ -775 +775 @@
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_BLOCK_NO_TYPE, N_("Failed to obtain the type"));
     if (!strcmp(psz, "HardDisk"))
-        pData->enmType = PDMBLOCKTYPE_HARD_DISK;
+        pThis->enmType = PDMBLOCKTYPE_HARD_DISK;
     else if (!strcmp(psz, "DVD"))
-        pData->enmType = PDMBLOCKTYPE_DVD;
+        pThis->enmType = PDMBLOCKTYPE_DVD;
     else if (!strcmp(psz, "CDROM"))
-        pData->enmType = PDMBLOCKTYPE_CDROM;
+        pThis->enmType = PDMBLOCKTYPE_CDROM;
     else if (!strcmp(psz, "Floppy 2.88"))
-        pData->enmType = PDMBLOCKTYPE_FLOPPY_2_88;
+        pThis->enmType = PDMBLOCKTYPE_FLOPPY_2_88;
     else if (!strcmp(psz, "Floppy 1.44"))
-        pData->enmType = PDMBLOCKTYPE_FLOPPY_1_44;
+        pThis->enmType = PDMBLOCKTYPE_FLOPPY_1_44;
     else if (!strcmp(psz, "Floppy 1.20"))
-        pData->enmType = PDMBLOCKTYPE_FLOPPY_1_20;
+        pThis->enmType = PDMBLOCKTYPE_FLOPPY_1_20;
     else if (!strcmp(psz, "Floppy 720"))
-        pData->enmType = PDMBLOCKTYPE_FLOPPY_720;
+        pThis->enmType = PDMBLOCKTYPE_FLOPPY_720;
     else if (!strcmp(psz, "Floppy 360"))
-        pData->enmType = PDMBLOCKTYPE_FLOPPY_360;
+        pThis->enmType = PDMBLOCKTYPE_FLOPPY_360;
     else
     {
@@ -797 +797 @@
         return VERR_PDM_BLOCK_UNKNOWN_TYPE;
     }
-    Log2(("drvblockConstruct: enmType=%d\n", pData->enmType));
+    Log2(("drvblockConstruct: enmType=%d\n", pThis->enmType));
     MMR3HeapFree(psz); psz = NULL;
 
     /* Mountable */
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "Mountable", &pData->fMountable, false);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "Mountable", &pThis->fMountable, false);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"Mountable\" from the config"));
 
     /* Locked */
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "Locked", &pData->fLocked, false);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "Locked", &pThis->fLocked, false);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"Locked\" from the config"));
 
     /* BIOS visible */
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "BIOSVisible", &pData->fBiosVisible, true);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "BIOSVisible", &pThis->fBiosVisible, true);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"BIOSVisible\" from the config"));
@@ -818 +818 @@
 
     /* Cylinders */
-    rc = CFGMR3QueryU32Def(pCfgHandle, "Cylinders", &pData->LCHSGeometry.cCylinders, 0);
+    rc = CFGMR3QueryU32Def(pCfgHandle, "Cylinders", &pThis->LCHSGeometry.cCylinders, 0);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"Cylinders\" from the config"));
 
     /* Heads */
-    rc = CFGMR3QueryU32Def(pCfgHandle, "Heads", &pData->LCHSGeometry.cHeads, 0);
+    rc = CFGMR3QueryU32Def(pCfgHandle, "Heads", &pThis->LCHSGeometry.cHeads, 0);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"Heads\" from the config"));
 
     /* Sectors */
-    rc = CFGMR3QueryU32Def(pCfgHandle, "Sectors", &pData->LCHSGeometry.cSectors, 0);
+    rc = CFGMR3QueryU32Def(pCfgHandle, "Sectors", &pThis->LCHSGeometry.cSectors, 0);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"Sectors\" from the config"));
@@ -835 +835 @@
     rc = CFGMR3QueryStringAlloc(pCfgHandle, "Uuid", &psz);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        RTUuidClear(&pData->Uuid);
+        RTUuidClear(&pThis->Uuid);
     else if (RT_SUCCESS(rc))
     {
-        rc = RTUuidFromStr(&pData->Uuid, psz);
+        rc = RTUuidFromStr(&pThis->Uuid, psz);
         if (RT_FAILURE(rc))
         {
@@ -852 +852 @@
 
 #ifdef VBOX_PERIODIC_FLUSH
-    rc = CFGMR3QueryU32Def(pCfgHandle, "FlushInterval", &pData->cbFlushInterval, 0);
+    rc = CFGMR3QueryU32Def(pCfgHandle, "FlushInterval", &pThis->cbFlushInterval, 0);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"FlushInterval\" from the config"));
@@ -858 +858 @@
 
 #ifdef VBOX_IGNORE_FLUSH
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "IgnoreFlush", &pData->fIgnoreFlush, true);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "IgnoreFlush", &pThis->fIgnoreFlush, true);
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"IgnoreFlush\" from the config"));
@@ -869 +869 @@
     rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBase);
     if (    rc == VERR_PDM_NO_ATTACHED_DRIVER
-        &&  pData->enmType != PDMBLOCKTYPE_HARD_DISK)
+        &&  pThis->enmType != PDMBLOCKTYPE_HARD_DISK)
         return VINF_SUCCESS;
     if (RT_FAILURE(rc))
@@ -876 +876 @@
         return rc;
     }
-    pData->pDrvMedia = (PPDMIMEDIA)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA);
-    if (!pData->pDrvMedia)
+    pThis->pDrvMedia = (PPDMIMEDIA)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA);
+    if (!pThis->pDrvMedia)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW,
                                 N_("No media or async media interface below"));
 
     /* Try to get the optional async interface. */
-    pData->pDrvMediaAsync = (PPDMIMEDIAASYNC)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA_ASYNC);
-
-    if (RTUuidIsNull(&pData->Uuid))
-    {
-        if (pData->enmType == PDMBLOCKTYPE_HARD_DISK)
-            pData->pDrvMedia->pfnGetUuid(pData->pDrvMedia, &pData->Uuid);
+    pThis->pDrvMediaAsync = (PPDMIMEDIAASYNC)pBase->pfnQueryInterface(pBase, PDMINTERFACE_MEDIA_ASYNC);
+
+    if (RTUuidIsNull(&pThis->Uuid))
+    {
+        if (pThis->enmType == PDMBLOCKTYPE_HARD_DISK)
+            pThis->pDrvMedia->pfnGetUuid(pThis->pDrvMedia, &pThis->Uuid);
     }
 

trunk/src/VBox/Devices/Storage/DrvMediaISO.cpp

@@ -99 +99 @@
 static DECLCALLBACK(int) drvMediaISOConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVMEDIAISO pData = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
+    PDRVMEDIAISO pThis = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-    pData->File                         = NIL_RTFILE;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->File                         = NIL_RTFILE;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvMediaISOQueryInterface;
     /* IMedia */
-    pData->IMedia.pfnRead               = drvMediaISORead;
-    pData->IMedia.pfnWrite              = drvMediaISOWrite;
-    pData->IMedia.pfnFlush              = drvMediaISOFlush;
-    pData->IMedia.pfnGetSize            = drvMediaISOGetSize;
-    pData->IMedia.pfnGetUuid            = drvMediaISOGetUuid;
-    pData->IMedia.pfnIsReadOnly         = drvMediaISOIsReadOnly;
-    pData->IMedia.pfnBiosGetPCHSGeometry = drvMediaISOBiosGetPCHSGeometry;
-    pData->IMedia.pfnBiosSetPCHSGeometry = drvMediaISOBiosSetPCHSGeometry;
-    pData->IMedia.pfnBiosGetLCHSGeometry = drvMediaISOBiosGetLCHSGeometry;
-    pData->IMedia.pfnBiosSetLCHSGeometry = drvMediaISOBiosSetLCHSGeometry;
+    pThis->IMedia.pfnRead               = drvMediaISORead;
+    pThis->IMedia.pfnWrite              = drvMediaISOWrite;
+    pThis->IMedia.pfnFlush              = drvMediaISOFlush;
+    pThis->IMedia.pfnGetSize            = drvMediaISOGetSize;
+    pThis->IMedia.pfnGetUuid            = drvMediaISOGetUuid;
+    pThis->IMedia.pfnIsReadOnly         = drvMediaISOIsReadOnly;
+    pThis->IMedia.pfnBiosGetPCHSGeometry = drvMediaISOBiosGetPCHSGeometry;
+    pThis->IMedia.pfnBiosSetPCHSGeometry = drvMediaISOBiosSetPCHSGeometry;
+    pThis->IMedia.pfnBiosGetLCHSGeometry = drvMediaISOBiosGetLCHSGeometry;
+    pThis->IMedia.pfnBiosSetLCHSGeometry = drvMediaISOBiosSetLCHSGeometry;
 
     /*
@@ -134 +134 @@
      * Open the image.
      */
-    rc = RTFileOpen(&pData->File, pszName,
+    rc = RTFileOpen(&pThis->File, pszName,
                     RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
     if (RT_SUCCESS(rc))
     {
         LogFlow(("drvMediaISOConstruct: ISO image '%s' opened successfully.\n", pszName));
-        pData->pszFilename = pszName;
+        pThis->pszFilename = pszName;
     }
     else
@@ -161 +161 @@
 static DECLCALLBACK(void) drvMediaISODestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVMEDIAISO pData = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
-    LogFlow(("drvMediaISODestruct: '%s'\n", pData->pszFilename));
-
-    if (pData->File != NIL_RTFILE)
-    {
-        RTFileClose(pData->File);
-        pData->File = NIL_RTFILE;
-    }
-    if (pData->pszFilename)
-        MMR3HeapFree(pData->pszFilename);
+    PDRVMEDIAISO pThis = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
+    LogFlow(("drvMediaISODestruct: '%s'\n", pThis->pszFilename));
+
+    if (pThis->File != NIL_RTFILE)
+    {
+        RTFileClose(pThis->File);
+        pThis->File = NIL_RTFILE;
+    }
+    if (pThis->pszFilename)
+        MMR3HeapFree(pThis->pszFilename);
 }
 
@@ -177 +177 @@
 static DECLCALLBACK(uint64_t) drvMediaISOGetSize(PPDMIMEDIA pInterface)
 {
-    PDRVMEDIAISO pData = PDMIMEDIA_2_DRVMEDIAISO(pInterface);
-    LogFlow(("drvMediaISOGetSize: '%s'\n", pData->pszFilename));
+    PDRVMEDIAISO pThis = PDMIMEDIA_2_DRVMEDIAISO(pInterface);
+    LogFlow(("drvMediaISOGetSize: '%s'\n", pThis->pszFilename));
 
     uint64_t cbFile;
-    int rc = RTFileGetSize(pData->File, &cbFile);
+    int rc = RTFileGetSize(pThis->File, &cbFile);
     if (RT_SUCCESS(rc))
     {
-        LogFlow(("drvMediaISOGetSize: returns %lld (%s)\n", cbFile, pData->pszFilename));
+        LogFlow(("drvMediaISOGetSize: returns %lld (%s)\n", cbFile, pThis->pszFilename));
         return cbFile;
     }
 
-    AssertMsgFailed(("Error querying ISO file size, rc=%Vrc. (%s)\n", rc, pData->pszFilename));
+    AssertMsgFailed(("Error querying ISO file size, rc=%Vrc. (%s)\n", rc, pThis->pszFilename));
     return 0;
 }
@@ -228 +228 @@
 static DECLCALLBACK(int) drvMediaISORead(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    PDRVMEDIAISO pData = PDMIMEDIA_2_DRVMEDIAISO(pInterface);
-    LogFlow(("drvMediaISORead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n", off, pvBuf, cbRead, pData->pszFilename));
-
-    Assert(pData->File);
+    PDRVMEDIAISO pThis = PDMIMEDIA_2_DRVMEDIAISO(pInterface);
+    LogFlow(("drvMediaISORead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n", off, pvBuf, cbRead, pThis->pszFilename));
+
+    Assert(pThis->File);
     Assert(pvBuf);
 
@@ -237 +237 @@
      * Seek to the position and read.
      */
-    int rc = RTFileSeek(pData->File, off, RTFILE_SEEK_BEGIN, NULL);
+    int rc = RTFileSeek(pThis->File, off, RTFILE_SEEK_BEGIN, NULL);
     if (RT_SUCCESS(rc))
     {
-        rc = RTFileRead(pData->File, pvBuf, cbRead, NULL);
+        rc = RTFileRead(pThis->File, pvBuf, cbRead, NULL);
         if (RT_SUCCESS(rc))
         {
             Log2(("drvMediaISORead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n"
                   "%16.*Vhxd\n",
-                  off, pvBuf, cbRead, pData->pszFilename,
+                  off, pvBuf, cbRead, pThis->pszFilename,
                   cbRead, pvBuf));
         }
         else
             AssertMsgFailed(("RTFileRead(%d, %p, %#x) -> %Vrc (off=%#llx '%s')\n",
-                             pData->File, pvBuf, cbRead, rc, off, pData->pszFilename));
+                             pThis->File, pvBuf, cbRead, rc, off, pThis->pszFilename));
     }
     else
-        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pData->File, off, rc));
+        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pThis->File, off, rc));
     LogFlow(("drvMediaISORead: returns %Vrc\n", rc));
     return rc;
@@ -302 +302 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_DRVINS(pInterface);
-    PDRVMEDIAISO pData = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
+    PDRVMEDIAISO pThis = PDMINS_2_DATA(pDrvIns, PDRVMEDIAISO);
     switch (enmInterface)
     {
@@ -308 +308 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_MEDIA:
-            return &pData->IMedia;
+            return &pThis->IMedia;
         default:
             return NULL;

trunk/src/VBox/Devices/Storage/DrvRawImage.cpp

@@ -102 +102 @@
 static DECLCALLBACK(int) drvRawImageConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVRAWIMAGE pData = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
+    PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-    pData->File                         = NIL_RTFILE;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->File                         = NIL_RTFILE;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvRawImageQueryInterface;
     /* IMedia */
-    pData->IMedia.pfnRead               = drvRawImageRead;
-    pData->IMedia.pfnWrite              = drvRawImageWrite;
-    pData->IMedia.pfnFlush              = drvRawImageFlush;
-    pData->IMedia.pfnGetSize            = drvRawImageGetSize;
-    pData->IMedia.pfnGetUuid            = drvRawImageGetUuid;
-    pData->IMedia.pfnIsReadOnly         = drvRawImageIsReadOnly;
-    pData->IMedia.pfnBiosGetPCHSGeometry = drvRawImageBiosGetPCHSGeometry;
-    pData->IMedia.pfnBiosSetPCHSGeometry = drvRawImageBiosSetPCHSGeometry;
-    pData->IMedia.pfnBiosGetLCHSGeometry = drvRawImageBiosGetLCHSGeometry;
-    pData->IMedia.pfnBiosSetLCHSGeometry = drvRawImageBiosSetLCHSGeometry;
+    pThis->IMedia.pfnRead               = drvRawImageRead;
+    pThis->IMedia.pfnWrite              = drvRawImageWrite;
+    pThis->IMedia.pfnFlush              = drvRawImageFlush;
+    pThis->IMedia.pfnGetSize            = drvRawImageGetSize;
+    pThis->IMedia.pfnGetUuid            = drvRawImageGetUuid;
+    pThis->IMedia.pfnIsReadOnly         = drvRawImageIsReadOnly;
+    pThis->IMedia.pfnBiosGetPCHSGeometry = drvRawImageBiosGetPCHSGeometry;
+    pThis->IMedia.pfnBiosSetPCHSGeometry = drvRawImageBiosSetPCHSGeometry;
+    pThis->IMedia.pfnBiosGetLCHSGeometry = drvRawImageBiosGetLCHSGeometry;
+    pThis->IMedia.pfnBiosSetLCHSGeometry = drvRawImageBiosSetLCHSGeometry;
 
     /*
@@ -140 +140 @@
      * Open the image.
      */
-    rc = RTFileOpen(&pData->File, pszName,
+    rc = RTFileOpen(&pThis->File, pszName,
                     RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     if (RT_SUCCESS(rc))
     {
         LogFlow(("drvRawImageConstruct: Raw image '%s' opened successfully.\n", pszName));
-        pData->pszFilename = pszName;
-        pData->fReadOnly = false;
+        pThis->pszFilename = pszName;
+        pThis->fReadOnly = false;
     }
     else
     {
-        rc = RTFileOpen(&pData->File, pszName,
+        rc = RTFileOpen(&pThis->File, pszName,
                         RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
         if (RT_SUCCESS(rc))
         {
             LogFlow(("drvRawImageConstruct: Raw image '%s' opened successfully.\n", pszName));
-            pData->pszFilename = pszName;
-            pData->fReadOnly = true;
+            pThis->pszFilename = pszName;
+            pThis->fReadOnly = true;
         }
         else
@@ -179 +179 @@
 static DECLCALLBACK(void) drvRawImageDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVRAWIMAGE pData = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
-    LogFlow(("drvRawImageDestruct: '%s'\n", pData->pszFilename));
-
-    if (pData->File != NIL_RTFILE)
-    {
-        RTFileClose(pData->File);
-        pData->File = NIL_RTFILE;
-    }
-    if (pData->pszFilename)
-        MMR3HeapFree(pData->pszFilename);
+    PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
+    LogFlow(("drvRawImageDestruct: '%s'\n", pThis->pszFilename));
+
+    if (pThis->File != NIL_RTFILE)
+    {
+        RTFileClose(pThis->File);
+        pThis->File = NIL_RTFILE;
+    }
+    if (pThis->pszFilename)
+        MMR3HeapFree(pThis->pszFilename);
 }
 
@@ -195 +195 @@
 static DECLCALLBACK(uint64_t) drvRawImageGetSize(PPDMIMEDIA pInterface)
 {
-    PDRVRAWIMAGE pData = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
-    LogFlow(("drvRawImageGetSize: '%s'\n", pData->pszFilename));
+    PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
+    LogFlow(("drvRawImageGetSize: '%s'\n", pThis->pszFilename));
 
     uint64_t cbFile;
-    int rc = RTFileGetSize(pData->File, &cbFile);
+    int rc = RTFileGetSize(pThis->File, &cbFile);
     if (RT_SUCCESS(rc))
     {
-        LogFlow(("drvRawImageGetSize: returns %lld (%s)\n", cbFile, pData->pszFilename));
+        LogFlow(("drvRawImageGetSize: returns %lld (%s)\n", cbFile, pThis->pszFilename));
         return cbFile;
     }
 
-    AssertMsgFailed(("Error querying Raw image file size, rc=%Vrc. (%s)\n", rc, pData->pszFilename));
+    AssertMsgFailed(("Error querying Raw image file size, rc=%Vrc. (%s)\n", rc, pThis->pszFilename));
     return 0;
 }
@@ -246 +246 @@
 static DECLCALLBACK(int) drvRawImageRead(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    PDRVRAWIMAGE pData = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
-    LogFlow(("drvRawImageRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n", off, pvBuf, cbRead, pData->pszFilename));
-
-    Assert(pData->File);
+    PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
+    LogFlow(("drvRawImageRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n", off, pvBuf, cbRead, pThis->pszFilename));
+
+    Assert(pThis->File);
     Assert(pvBuf);
 
@@ -255 +255 @@
      * Seek to the position and read.
      */
-    int rc = RTFileSeek(pData->File, off, RTFILE_SEEK_BEGIN, NULL);
+    int rc = RTFileSeek(pThis->File, off, RTFILE_SEEK_BEGIN, NULL);
     if (RT_SUCCESS(rc))
     {
-        rc = RTFileRead(pData->File, pvBuf, cbRead, NULL);
+        rc = RTFileRead(pThis->File, pvBuf, cbRead, NULL);
         if (RT_SUCCESS(rc))
         {
             Log2(("drvRawImageRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n"
                   "%16.*Vhxd\n",
-                  off, pvBuf, cbRead, pData->pszFilename,
+                  off, pvBuf, cbRead, pThis->pszFilename,
                   cbRead, pvBuf));
         }
         else
             AssertMsgFailed(("RTFileRead(%d, %p, %#x) -> %Vrc (off=%#llx '%s')\n",
-                             pData->File, pvBuf, cbRead, rc, off, pData->pszFilename));
+                             pThis->File, pvBuf, cbRead, rc, off, pThis->pszFilename));
     }
     else
-        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pData->File, off, rc));
+        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pThis->File, off, rc));
     LogFlow(("drvRawImageRead: returns %Vrc\n", rc));
     return rc;
@@ -280 +280 @@
 static DECLCALLBACK(int) drvRawImageWrite(PPDMIMEDIA pInterface, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    PDRVRAWIMAGE pData = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
-    LogFlow(("drvRawImageWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n", off, pvBuf, cbWrite, pData->pszFilename));
-
-    Assert(pData->File);
+    PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
+    LogFlow(("drvRawImageWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n", off, pvBuf, cbWrite, pThis->pszFilename));
+
+    Assert(pThis->File);
     Assert(pvBuf);
 
@@ -289 +289 @@
      * Seek to the position and write.
      */
-    int rc = RTFileSeek(pData->File, off, RTFILE_SEEK_BEGIN, NULL);
+    int rc = RTFileSeek(pThis->File, off, RTFILE_SEEK_BEGIN, NULL);
     if (RT_SUCCESS(rc))
     {
-        rc = RTFileWrite(pData->File, pvBuf, cbWrite, NULL);
+        rc = RTFileWrite(pThis->File, pvBuf, cbWrite, NULL);
         if (RT_SUCCESS(rc))
         {
             Log2(("drvRawImageWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n"
                   "%16.*Vhxd\n",
-                  off, pvBuf, cbWrite, pData->pszFilename,
+                  off, pvBuf, cbWrite, pThis->pszFilename,
                   cbWrite, pvBuf));
         }
         else
             AssertMsgFailed(("RTFileWrite(%d, %p, %#x) -> %Vrc (off=%#llx '%s')\n",
-                             pData->File, pvBuf, cbWrite, rc, off, pData->pszFilename));
+                             pThis->File, pvBuf, cbWrite, rc, off, pThis->pszFilename));
     }
     else
-        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pData->File, off, rc));
+        AssertMsgFailed(("RTFileSeek(%d,%#llx,) -> %Vrc\n", pThis->File, off, rc));
     LogFlow(("drvRawImageWrite: returns %Vrc\n", rc));
     return rc;
@@ -314 +314 @@
 static DECLCALLBACK(int) drvRawImageFlush(PPDMIMEDIA pInterface)
 {
-    PDRVRAWIMAGE pData = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
-    LogFlow(("drvRawImageFlush: (%s)\n", pData->pszFilename));
-
-    Assert(pData->File != NIL_RTFILE);
-    int rc = RTFileFlush(pData->File);
+    PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
+    LogFlow(("drvRawImageFlush: (%s)\n", pThis->pszFilename));
+
+    Assert(pThis->File != NIL_RTFILE);
+    int rc = RTFileFlush(pThis->File);
     LogFlow(("drvRawImageFlush: returns %Vrc\n", rc));
     return rc;
@@ -335 +335 @@
 static DECLCALLBACK(bool) drvRawImageIsReadOnly(PPDMIMEDIA pInterface)
 {
-    PDRVRAWIMAGE pData = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
-    return pData->fReadOnly;
+    PDRVRAWIMAGE pThis = PDMIMEDIA_2_DRVRAWIMAGE(pInterface);
+    return pThis->fReadOnly;
 }
 
@@ -352 +352 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_DRVINS(pInterface);
-    PDRVRAWIMAGE pData = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
+    PDRVRAWIMAGE pThis = PDMINS_2_DATA(pDrvIns, PDRVRAWIMAGE);
     switch (enmInterface)
     {
@@ -358 +358 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_MEDIA:
-            return &pData->IMedia;
+            return &pThis->IMedia;
         default:
             return NULL;

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

@@ -276 +276 @@
     LogFlow(("%s: off=%#llx pvBuf=%p cbRead=%d\n", __FUNCTION__,
              off, pvBuf, cbRead));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDRead(pData->pDisk, off, pvBuf, cbRead);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDRead(pThis->pDisk, off, pvBuf, cbRead);
     if (RT_SUCCESS(rc))
         Log2(("%s: off=%#llx pvBuf=%p cbRead=%d %.*Vhxd\n", __FUNCTION__,
@@ -292 +292 @@
     LogFlow(("%s: off=%#llx pvBuf=%p cbWrite=%d\n", __FUNCTION__,
              off, pvBuf, cbWrite));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
     Log2(("%s: off=%#llx pvBuf=%p cbWrite=%d %.*Vhxd\n", __FUNCTION__,
           off, pvBuf, cbWrite, cbWrite, pvBuf));
-    int rc = VDWrite(pData->pDisk, off, pvBuf, cbWrite);
+    int rc = VDWrite(pThis->pDisk, off, pvBuf, cbWrite);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -304 +304 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDFlush(pData->pDisk);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDFlush(pThis->pDisk);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -314 +314 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    uint64_t cb = VDGetSize(pData->pDisk, VD_LAST_IMAGE);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    uint64_t cb = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
     LogFlow(("%s: returns %#llx (%llu)\n", __FUNCTION__, cb, cb));
     return cb;
@@ -324 +324 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    bool f = VDIsReadOnly(pData->pDisk);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    bool f = VDIsReadOnly(pThis->pDisk);
     LogFlow(("%s: returns %d\n", __FUNCTION__, f));
     return f;
@@ -335 +335 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDGetPCHSGeometry(pData->pDisk, VD_LAST_IMAGE, pPCHSGeometry);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDGetPCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pPCHSGeometry);
     if (RT_FAILURE(rc))
     {
@@ -353 +353 @@
     LogFlow(("%s: CHS=%d/%d/%d\n", __FUNCTION__,
              pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDSetPCHSGeometry(pData->pDisk, VD_LAST_IMAGE, pPCHSGeometry);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDSetPCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pPCHSGeometry);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -364 +364 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDGetLCHSGeometry(pData->pDisk, VD_LAST_IMAGE, pLCHSGeometry);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDGetLCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pLCHSGeometry);
     if (RT_FAILURE(rc))
     {
@@ -382 +382 @@
     LogFlow(("%s: CHS=%d/%d/%d\n", __FUNCTION__,
              pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDSetLCHSGeometry(pData->pDisk, VD_LAST_IMAGE, pLCHSGeometry);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDSetLCHSGeometry(pThis->pDisk, VD_LAST_IMAGE, pLCHSGeometry);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -392 +392 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMIMEDIA_2_VBOXDISK(pInterface);
-    int rc = VDGetUuid(pData->pDisk, 0, pUuid);
+    PVBOXDISK pThis = PDMIMEDIA_2_VBOXDISK(pInterface);
+    int rc = VDGetUuid(pThis->pDisk, 0, pUuid);
     LogFlow(("%s: returns %Vrc ({%Vuuid})\n", __FUNCTION__, rc, pUuid));
     return rc;
@@ -408 +408 @@
      LogFlow(("%s: uOffset=%#llx paSeg=%#p cSeg=%u cbRead=%d\n pvUser=%#p", __FUNCTION__,
              uOffset, paSeg, cSeg, cbRead, pvUser));
-    PVBOXDISK pData = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
-    int rc = VDAsyncRead(pData->pDisk, uOffset, cbRead, paSeg, cSeg, pvUser);
+    PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
+    int rc = VDAsyncRead(pThis->pDisk, uOffset, cbRead, paSeg, cSeg, pvUser);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -420 +420 @@
      LogFlow(("%s: uOffset=%#llx paSeg=%#p cSeg=%u cbWrite=%d\n pvUser=%#p", __FUNCTION__,
              uOffset, paSeg, cSeg, cbWrite, pvUser));
-    PVBOXDISK pData = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
-    int rc = VDAsyncWrite(pData->pDisk, uOffset, cbWrite, paSeg, cSeg, pvUser);
+    PVBOXDISK pThis = PDMIMEDIAASYNC_2_VBOXDISK(pInterface);
+    int rc = VDAsyncWrite(pThis->pDisk, uOffset, cbWrite, paSeg, cSeg, pvUser);
     LogFlow(("%s: returns %Vrc\n", __FUNCTION__, rc));
     return rc;
@@ -432 +432 @@
 static DECLCALLBACK(int) drvvdTasksCompleteNotify(PPDMITRANSPORTASYNCPORT pInterface, void *pvUser)
 {
-    PVBOXDISK pData = PDMITRANSPORTASYNCPORT_2_VBOXDISK(pInterface);
+    PVBOXDISK pThis = PDMITRANSPORTASYNCPORT_2_VBOXDISK(pInterface);
     PDRVVDASYNCTASK pDrvVDAsyncTask = (PDRVVDASYNCTASK)pvUser;
     int rc = VINF_VDI_ASYNC_IO_FINISHED;
@@ -443 +443 @@
     if (rc == VINF_VDI_ASYNC_IO_FINISHED)
     {
-        rc = pData->pDrvMediaAsyncPort->pfnTransferCompleteNotify(pData->pDrvMediaAsyncPort, pDrvVDAsyncTask->pvUserCaller);
+        rc = pThis->pDrvMediaAsyncPort->pfnTransferCompleteNotify(pThis->pDrvMediaAsyncPort, pDrvVDAsyncTask->pvUserCaller);
     }
     else if (rc == VERR_VDI_ASYNC_IO_IN_PROGRESS)
         rc = VINF_SUCCESS;
 
-    rc = RTCacheInsert(pData->pCache, pDrvVDAsyncTask);
+    rc = RTCacheInsert(pThis->pCache, pDrvVDAsyncTask);
     AssertRC(rc);
 
@@ -464 +464 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_DRVINS(pInterface);
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
     switch (enmInterface)
     {
@@ -470 +470 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_MEDIA:
-            return &pData->IMedia;
+            return &pThis->IMedia;
         case PDMINTERFACE_MEDIA_ASYNC:
-            return pData->fAsyncIOSupported ? &pData->IMediaAsync : NULL;
+            return pThis->fAsyncIOSupported ? &pThis->IMediaAsync : NULL;
         case PDMINTERFACE_TRANSPORT_ASYNC_PORT:
-            return &pData->ITransportAsyncPort;
+            return &pThis->ITransportAsyncPort;
         default:
             return NULL;
@@ -500 +500 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
     int rc = VINF_SUCCESS;
     char *pszName = NULL;   /**< The path of the disk image file. */
@@ -511 +511 @@
      */
     pDrvIns->IBase.pfnQueryInterface    = drvvdQueryInterface;
-    pData->pDrvIns                      = pDrvIns;
-    pData->fTempReadOnly                = false;
-    pData->pDisk                        = NULL;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->fTempReadOnly                = false;
+    pThis->pDisk                        = NULL;
 
     /* IMedia */
-    pData->IMedia.pfnRead               = drvvdRead;
-    pData->IMedia.pfnWrite              = drvvdWrite;
-    pData->IMedia.pfnFlush              = drvvdFlush;
-    pData->IMedia.pfnGetSize            = drvvdGetSize;
-    pData->IMedia.pfnIsReadOnly         = drvvdIsReadOnly;
-    pData->IMedia.pfnBiosGetPCHSGeometry = drvvdBiosGetPCHSGeometry;
-    pData->IMedia.pfnBiosSetPCHSGeometry = drvvdBiosSetPCHSGeometry;
-    pData->IMedia.pfnBiosGetLCHSGeometry = drvvdBiosGetLCHSGeometry;
-    pData->IMedia.pfnBiosSetLCHSGeometry = drvvdBiosSetLCHSGeometry;
-    pData->IMedia.pfnGetUuid            = drvvdGetUuid;
+    pThis->IMedia.pfnRead               = drvvdRead;
+    pThis->IMedia.pfnWrite              = drvvdWrite;
+    pThis->IMedia.pfnFlush              = drvvdFlush;
+    pThis->IMedia.pfnGetSize            = drvvdGetSize;
+    pThis->IMedia.pfnIsReadOnly         = drvvdIsReadOnly;
+    pThis->IMedia.pfnBiosGetPCHSGeometry = drvvdBiosGetPCHSGeometry;
+    pThis->IMedia.pfnBiosSetPCHSGeometry = drvvdBiosSetPCHSGeometry;
+    pThis->IMedia.pfnBiosGetLCHSGeometry = drvvdBiosGetLCHSGeometry;
+    pThis->IMedia.pfnBiosSetLCHSGeometry = drvvdBiosSetLCHSGeometry;
+    pThis->IMedia.pfnGetUuid            = drvvdGetUuid;
 
     /* IMediaAsync */
-    pData->IMediaAsync.pfnStartRead       = drvvdStartRead;
-    pData->IMediaAsync.pfnStartWrite      = drvvdStartWrite;
+    pThis->IMediaAsync.pfnStartRead       = drvvdStartRead;
+    pThis->IMediaAsync.pfnStartWrite      = drvvdStartWrite;
 
     /* ITransportAsyncPort */
-    pData->ITransportAsyncPort.pfnTaskCompleteNotify  = drvvdTasksCompleteNotify;
+    pThis->ITransportAsyncPort.pfnTaskCompleteNotify  = drvvdTasksCompleteNotify;
 
     /* Initialize supported VD interfaces. */
-    pData->VDIErrorCallbacks.cbSize       = sizeof(VDINTERFACEERROR);
-    pData->VDIErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
-    pData->VDIErrorCallbacks.pfnError     = drvvdErrorCallback;
-
-    rc = VDInterfaceCreate(&pData->VDIError, "DrvVD_VDIError", VDINTERFACETYPE_ERROR,
-                           &pData->VDIErrorCallbacks, pDrvIns, NULL);
+    pThis->VDIErrorCallbacks.cbSize       = sizeof(VDINTERFACEERROR);
+    pThis->VDIErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
+    pThis->VDIErrorCallbacks.pfnError     = drvvdErrorCallback;
+
+    rc = VDInterfaceCreate(&pThis->VDIError, "DrvVD_VDIError", VDINTERFACETYPE_ERROR,
+                           &pThis->VDIErrorCallbacks, pDrvIns, NULL);
     AssertRC(rc);
 
-    pData->VDIAsyncIOCallbacks.cbSize                  = sizeof(VDINTERFACEASYNCIO);
-    pData->VDIAsyncIOCallbacks.enmInterface            = VDINTERFACETYPE_ASYNCIO;
-    pData->VDIAsyncIOCallbacks.pfnOpen                 = drvvdAsyncIOOpen;
-    pData->VDIAsyncIOCallbacks.pfnClose                = drvvdAsyncIOClose;
-    pData->VDIAsyncIOCallbacks.pfnRead                 = drvvdAsyncIORead;
-    pData->VDIAsyncIOCallbacks.pfnWrite                = drvvdAsyncIOWrite;
-    pData->VDIAsyncIOCallbacks.pfnFlush                = drvvdAsyncIOFlush;
-    pData->VDIAsyncIOCallbacks.pfnPrepareRead          = drvvdAsyncIOPrepareRead;
-    pData->VDIAsyncIOCallbacks.pfnPrepareWrite         = drvvdAsyncIOPrepareWrite;
-    pData->VDIAsyncIOCallbacks.pfnTasksSubmit          = drvvdAsyncIOTasksSubmit;
-
-    rc = VDInterfaceCreate(&pData->VDIAsyncIO, "DrvVD_AsyncIO", VDINTERFACETYPE_ASYNCIO,
-                           &pData->VDIAsyncIOCallbacks, pData, &pData->VDIError);
+    pThis->VDIAsyncIOCallbacks.cbSize                  = sizeof(VDINTERFACEASYNCIO);
+    pThis->VDIAsyncIOCallbacks.enmInterface            = VDINTERFACETYPE_ASYNCIO;
+    pThis->VDIAsyncIOCallbacks.pfnOpen                 = drvvdAsyncIOOpen;
+    pThis->VDIAsyncIOCallbacks.pfnClose                = drvvdAsyncIOClose;
+    pThis->VDIAsyncIOCallbacks.pfnRead                 = drvvdAsyncIORead;
+    pThis->VDIAsyncIOCallbacks.pfnWrite                = drvvdAsyncIOWrite;
+    pThis->VDIAsyncIOCallbacks.pfnFlush                = drvvdAsyncIOFlush;
+    pThis->VDIAsyncIOCallbacks.pfnPrepareRead          = drvvdAsyncIOPrepareRead;
+    pThis->VDIAsyncIOCallbacks.pfnPrepareWrite         = drvvdAsyncIOPrepareWrite;
+    pThis->VDIAsyncIOCallbacks.pfnTasksSubmit          = drvvdAsyncIOTasksSubmit;
+
+    rc = VDInterfaceCreate(&pThis->VDIAsyncIO, "DrvVD_AsyncIO", VDINTERFACETYPE_ASYNCIO,
+                           &pThis->VDIAsyncIOCallbacks, pThis, &pThis->VDIError);
     AssertRC(rc);
 
-    pData->VDIConfigCallbacks.cbSize                = sizeof(VDINTERFACECONFIG);
-    pData->VDIConfigCallbacks.enmInterface          = VDINTERFACETYPE_CONFIG;
-    pData->VDIConfigCallbacks.pfnAreValuesValid     = drvvdCfgAreValuesValid;
-    pData->VDIConfigCallbacks.pfnQueryType          = drvvdCfgQueryType;
-    pData->VDIConfigCallbacks.pfnQuerySize          = drvvdCfgQuerySize;
-    pData->VDIConfigCallbacks.pfnQueryInteger       = drvvdCfgQueryInteger;
-    pData->VDIConfigCallbacks.pfnQueryIntegerDef    = drvvdCfgQueryIntegerDef;
-    pData->VDIConfigCallbacks.pfnQueryString        = drvvdCfgQueryString;
-    pData->VDIConfigCallbacks.pfnQueryStringDef     = drvvdCfgQueryStringDef;
-    pData->VDIConfigCallbacks.pfnQueryBytes         = drvvdCfgQueryBytes;
+    pThis->VDIConfigCallbacks.cbSize                = sizeof(VDINTERFACECONFIG);
+    pThis->VDIConfigCallbacks.enmInterface          = VDINTERFACETYPE_CONFIG;
+    pThis->VDIConfigCallbacks.pfnAreValuesValid     = drvvdCfgAreValuesValid;
+    pThis->VDIConfigCallbacks.pfnQueryType          = drvvdCfgQueryType;
+    pThis->VDIConfigCallbacks.pfnQuerySize          = drvvdCfgQuerySize;
+    pThis->VDIConfigCallbacks.pfnQueryInteger       = drvvdCfgQueryInteger;
+    pThis->VDIConfigCallbacks.pfnQueryIntegerDef    = drvvdCfgQueryIntegerDef;
+    pThis->VDIConfigCallbacks.pfnQueryString        = drvvdCfgQueryString;
+    pThis->VDIConfigCallbacks.pfnQueryStringDef     = drvvdCfgQueryStringDef;
+    pThis->VDIConfigCallbacks.pfnQueryBytes         = drvvdCfgQueryBytes;
 
     /** @todo TEMP! this isn't really correct - this needs to be made per image,
@@ -573 +573 @@
      * At the moment this is harmless, as iSCSI can only be used as a base
      * image, and no other backend uses the private data for these callbacks. */
-    rc = VDInterfaceCreate(&pData->VDIConfig, "DrvVD_Config", VDINTERFACETYPE_CONFIG,
-                           &pData->VDIConfigCallbacks, NULL /**< @todo TEMP */, &pData->VDIAsyncIO);
+    rc = VDInterfaceCreate(&pThis->VDIConfig, "DrvVD_Config", VDINTERFACETYPE_CONFIG,
+                           &pThis->VDIConfigCallbacks, NULL /**< @todo TEMP */, &pThis->VDIAsyncIO);
     AssertRC(rc);
 
     /* Try to attach async media port interface above.*/
-    pData->pDrvMediaAsyncPort = (PPDMIMEDIAASYNCPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_MEDIA_ASYNC_PORT);
+    pThis->pDrvMediaAsyncPort = (PPDMIMEDIAASYNCPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_MEDIA_ASYNC_PORT);
 
     /*
@@ -584 +584 @@
      * async interface.
      */
-    if (pData->pDrvMediaAsyncPort)
+    if (pThis->pDrvMediaAsyncPort)
     {
         /* Try to attach the driver. */
@@ -596 +596 @@
              * Revert to non async I/O.
              */
-            pData->pDrvMediaAsyncPort = NULL;
+            pThis->pDrvMediaAsyncPort = NULL;
         }
         else if (RT_FAILURE(rc))
@@ -605 +605 @@
         {
             /* Success query the async transport interface. */
-            pData->pDrvTransportAsync = (PPDMITRANSPORTASYNC)pBase->pfnQueryInterface(pBase, PDMINTERFACE_TRANSPORT_ASYNC);
-            if (!pData->pDrvTransportAsync)
+            pThis->pDrvTransportAsync = (PPDMITRANSPORTASYNC)pBase->pfnQueryInterface(pBase, PDMINTERFACE_TRANSPORT_ASYNC);
+            if (!pThis->pDrvTransportAsync)
             {
                 /* Whoops. */
@@ -659 +659 @@
     {
         /** @todo TEMP! later the iSCSI config callbacks won't be included here */
-        rc = VDCreate(&pData->VDIConfig, &pData->pDisk);
+        rc = VDCreate(&pThis->VDIConfig, &pThis->pDisk);
         /* Error message is already set correctly. */
     }
@@ -717 +717 @@
         {
             PCFGMNODE pCfg = CFGMR3GetChild(pCurNode, "VDConfig");
-            pData->VDIConfig.pvUser = pCfg; /**< @todo TEMP! */
+            pThis->VDIConfig.pvUser = pCfg; /**< @todo TEMP! */
         }
 
@@ -730 +730 @@
         if (fHonorZeroWrites)
             uOpenFlags |= VD_OPEN_FLAGS_HONOR_ZEROES;
-        if (pData->pDrvMediaAsyncPort)
+        if (pThis->pDrvMediaAsyncPort)
             uOpenFlags |= VD_OPEN_FLAGS_ASYNC_IO;
 
         /** Try to open backend in asyc I/O mode first. */
-        rc = VDOpen(pData->pDisk, pszFormat, pszName, uOpenFlags);
+        rc = VDOpen(pThis->pDisk, pszFormat, pszName, uOpenFlags);
         if (rc == VERR_NOT_SUPPORTED)
         {
             /* Seems async I/O is not supported by the backend, open in normal mode. */
             uOpenFlags &= ~VD_OPEN_FLAGS_ASYNC_IO;
-            rc = VDOpen(pData->pDisk, pszFormat, pszName, uOpenFlags);
+            rc = VDOpen(pThis->pDisk, pszFormat, pszName, uOpenFlags);
         }
 
@@ -745 +745 @@
             Log(("%s: %d - Opened '%s' in %s mode\n", __FUNCTION__,
                  iLevel, pszName,
-                 VDIsReadOnly(pData->pDisk) ? "read-only" : "read-write"));
+                 VDIsReadOnly(pThis->pDisk) ? "read-only" : "read-write"));
         else
         {
@@ -765 +765 @@
     if (RT_FAILURE(rc))
     {
-        if (VALID_PTR(pData->pDisk))
-        {
-            VDDestroy(pData->pDisk);
-            pData->pDisk = NULL;
+        if (VALID_PTR(pThis->pDisk))
+        {
+            VDDestroy(pThis->pDisk);
+            pThis->pDisk = NULL;
         }
         if (VALID_PTR(pszName))
@@ -780 +780 @@
      * it.
      */
-    pData->fAsyncIOSupported = true;
-    for (unsigned i = 0; i < VDGetCount(pData->pDisk); i++)
+    pThis->fAsyncIOSupported = true;
+    for (unsigned i = 0; i < VDGetCount(pThis->pDisk); i++)
     {
         VDBACKENDINFO vdBackendInfo;
 
-        rc = VDBackendInfoSingle(pData->pDisk, i, &vdBackendInfo);
+        rc = VDBackendInfoSingle(pThis->pDisk, i, &vdBackendInfo);
         AssertRC(rc);
 
@@ -794 +794 @@
              * Check if current file is supported with async I/O)
              */
-            rc = VDImageIsAsyncIOSupported(pData->pDisk, i, &pData->fAsyncIOSupported);
+            rc = VDImageIsAsyncIOSupported(pThis->pDisk, i, &pThis->fAsyncIOSupported);
             AssertRC(rc);
 
@@ -802 +802 @@
              * at least one does not support it.
              */
-            if (!pData->fAsyncIOSupported)
+            if (!pThis->fAsyncIOSupported)
                 break;
         }
         else
         {
-            pData->fAsyncIOSupported = false;
+            pThis->fAsyncIOSupported = false;
             break;
         }
@@ -813 +813 @@
 
     /* Create cache if async I/O is supported. */
-    if (pData->fAsyncIOSupported)
-    {
-        rc = RTCacheCreate(&pData->pCache, 0, sizeof(DRVVDASYNCTASK), RTOBJCACHE_PROTECT_INSERT);
+    if (pThis->fAsyncIOSupported)
+    {
+        rc = RTCacheCreate(&pThis->pCache, 0, sizeof(DRVVDASYNCTASK), RTOBJCACHE_PROTECT_INSERT);
         AssertMsg(RT_SUCCESS(rc), ("Failed to create cache rc=%Vrc\n", rc));
     }
@@ -834 +834 @@
 {
     int rc;
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
-    LogFlow(("%s:\n", __FUNCTION__));
-
-    if (pData->pCache)
-    {
-        rc = RTCacheDestroy(pData->pCache);
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    LogFlow(("%s:\n", __FUNCTION__));
+
+    if (pThis->pCache)
+    {
+        rc = RTCacheDestroy(pThis->pCache);
         AssertRC(rc);
     }
@@ -855 +855 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
-    if (!VDIsReadOnly(pData->pDisk))
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    if (!VDIsReadOnly(pThis->pDisk))
     {
         unsigned uOpenFlags;
-        int rc = VDGetOpenFlags(pData->pDisk, VD_LAST_IMAGE, &uOpenFlags);
+        int rc = VDGetOpenFlags(pThis->pDisk, VD_LAST_IMAGE, &uOpenFlags);
         AssertRC(rc);
         uOpenFlags |= VD_OPEN_FLAGS_READONLY;
-        rc = VDSetOpenFlags(pData->pDisk, VD_LAST_IMAGE, uOpenFlags);
+        rc = VDSetOpenFlags(pThis->pDisk, VD_LAST_IMAGE, uOpenFlags);
         AssertRC(rc);
-        pData->fTempReadOnly = true;
+        pThis->fTempReadOnly = true;
     }
 }
@@ -877 +877 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
-    if (pData->fTempReadOnly)
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    if (pThis->fTempReadOnly)
     {
         unsigned uOpenFlags;
-        int rc = VDGetOpenFlags(pData->pDisk, VD_LAST_IMAGE, &uOpenFlags);
+        int rc = VDGetOpenFlags(pThis->pDisk, VD_LAST_IMAGE, &uOpenFlags);
         AssertRC(rc);
         uOpenFlags &= ~VD_OPEN_FLAGS_READONLY;
-        rc = VDSetOpenFlags(pData->pDisk, VD_LAST_IMAGE, uOpenFlags);
+        rc = VDSetOpenFlags(pThis->pDisk, VD_LAST_IMAGE, uOpenFlags);
         AssertRC(rc);
-        pData->fTempReadOnly = false;
+        pThis->fTempReadOnly = false;
     }
 }
@@ -893 +893 @@
 {
     LogFlow(("%s:\n", __FUNCTION__));
-    PVBOXDISK pData = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
+    PVBOXDISK pThis = PDMINS_2_DATA(pDrvIns, PVBOXDISK);
 
     /*
@@ -900 +900 @@
      * async transport driver is destructed.
      */
-    int rc = VDCloseAll(pData->pDisk);
+    int rc = VDCloseAll(pThis->pDisk);
     AssertRC(rc);
 }

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -56 +56 @@
 static DECLCALLBACK(uint64_t) vdiGetSize(PPDMIMEDIA pInterface)
 {
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    uint64_t cb = VDIDiskGetSize(pData);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    uint64_t cb = VDIDiskGetSize(pThis);
     LogFlow(("vdiGetSize: returns %#llx (%llu)\n", cb, cb));
     return cb;
@@ -94 +94 @@
 static DECLCALLBACK(int) vdiBiosGetLCHSGeometry(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry)
 {
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    int rc = VDIDiskGetLCHSGeometry(pData, pLCHSGeometry);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    int rc = VDIDiskGetLCHSGeometry(pThis, pLCHSGeometry);
     if (RT_SUCCESS(rc))
     {
@@ -113 +113 @@
 static DECLCALLBACK(int) vdiBiosSetLCHSGeometry(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry)
 {
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    int rc = VDIDiskSetLCHSGeometry(pData, pLCHSGeometry);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    int rc = VDIDiskSetLCHSGeometry(pThis, pLCHSGeometry);
     LogFlow(("%s: returns %Vrc (%d,%d,%d)\n", __FUNCTION__, rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
     return rc;
@@ -128 +128 @@
 {
     LogFlow(("vdiRead: off=%#llx pvBuf=%p cbRead=%d\n", off, pvBuf, cbRead));
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    int rc = VDIDiskRead(pData, off, pvBuf, cbRead);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    int rc = VDIDiskRead(pThis, off, pvBuf, cbRead);
     if (RT_SUCCESS(rc))
         Log2(("vdiRead: off=%#llx pvBuf=%p cbRead=%d\n"
@@ -147 +147 @@
 {
     LogFlow(("vdiWrite: off=%#llx pvBuf=%p cbWrite=%d\n", off, pvBuf, cbWrite));
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
     Log2(("vdiWrite: off=%#llx pvBuf=%p cbWrite=%d\n"
           "%.*Vhxd\n",
           off, pvBuf, cbWrite, cbWrite, pvBuf));
-    int rc = VDIDiskWrite(pData, off, pvBuf, cbWrite);
+    int rc = VDIDiskWrite(pThis, off, pvBuf, cbWrite);
     LogFlow(("vdiWrite: returns %Vrc\n", rc));
     return rc;
@@ -165 +165 @@
 {
     LogFlow(("vdiFlush:\n"));
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    VDIFlushImage(pData->pLast);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    VDIFlushImage(pThis->pLast);
     int rc = VINF_SUCCESS;
     LogFlow(("vdiFlush: returns %Vrc\n", rc));
@@ -176 +176 @@
 static DECLCALLBACK(int) vdiGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
 {
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    int rc = VDIDiskGetImageUuid(pData, 0, pUuid);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    int rc = VDIDiskGetImageUuid(pThis, 0, pUuid);
     LogFlow(("vdiGetUuid: returns %Vrc ({%Vuuid})\n", rc, pUuid));
     return rc;
@@ -186 +186 @@
 static DECLCALLBACK(bool) vdiIsReadOnly(PPDMIMEDIA pInterface)
 {
-    PVDIDISK pData = PDMIMEDIA_2_VDIDISK(pInterface);
-    LogFlow(("vdiIsReadOnly: returns %d\n", VDIDiskIsReadOnly(pData)));
-    return VDIDiskIsReadOnly(pData);
+    PVDIDISK pThis = PDMIMEDIA_2_VDIDISK(pInterface);
+    LogFlow(("vdiIsReadOnly: returns %d\n", VDIDiskIsReadOnly(pThis)));
+    return VDIDiskIsReadOnly(pThis);
 }
 
@@ -204 +204 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_DRVINS(pInterface);
-    PVDIDISK pData = PDMINS_2_DATA(pDrvIns, PVDIDISK);
+    PVDIDISK pThis = PDMINS_2_DATA(pDrvIns, PVDIDISK);
     switch (enmInterface)
     {
@@ -210 +210 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_MEDIA:
-            return &pData->IMedia;
+            return &pThis->IMedia;
         default:
             return NULL;
@@ -227 +227 @@
     LogFlow(("vdiSuspend:\n"));
 #if 1 //#ifdef DEBUG_dmik
-    PVDIDISK pData = PDMINS_2_DATA(pDrvIns, PVDIDISK);
-    if (!(pData->pLast->fOpen & VDI_OPEN_FLAGS_READONLY))
-    {
-        int rc = vdiChangeImageMode(pData->pLast, false);
+    PVDIDISK pThis = PDMINS_2_DATA(pDrvIns, PVDIDISK);
+    if (!(pThis->pLast->fOpen & VDI_OPEN_FLAGS_READONLY))
+    {
+        int rc = vdiChangeImageMode(pThis->pLast, false);
         AssertRC(rc);
     }
@@ -248 +248 @@
     LogFlow(("vdiSuspend:\n"));
 #if 1 // #ifdef DEBUG_dmik
-    PVDIDISK pData = PDMINS_2_DATA(pDrvIns, PVDIDISK);
-    if (!(pData->pLast->fOpen & VDI_OPEN_FLAGS_READONLY))
-    {
-        int rc = vdiChangeImageMode(pData->pLast, true);
+    PVDIDISK pThis = PDMINS_2_DATA(pDrvIns, PVDIDISK);
+    if (!(pThis->pLast->fOpen & VDI_OPEN_FLAGS_READONLY))
+    {
+        int rc = vdiChangeImageMode(pThis->pLast, true);
         AssertRC(rc);
     }
@@ -269 +269 @@
 {
     LogFlow(("vdiDestruct:\n"));
-    PVDIDISK pData = PDMINS_2_DATA(pDrvIns, PVDIDISK);
-    VDIDiskCloseAllImages(pData);
+    PVDIDISK pThis = PDMINS_2_DATA(pDrvIns, PVDIDISK);
+    VDIDiskCloseAllImages(pThis);
 }
 
@@ -287 +287 @@
 {
     LogFlow(("vdiConstruct:\n"));
-    PVDIDISK pData = PDMINS_2_DATA(pDrvIns, PVDIDISK);
+    PVDIDISK pThis = PDMINS_2_DATA(pDrvIns, PVDIDISK);
     char *pszName;      /**< The path of the disk image file. */
     bool fReadOnly;     /**< True if the media is readonly. */
@@ -296 +296 @@
      */
     pDrvIns->IBase.pfnQueryInterface    = vdiQueryInterface;
-    pData->pDrvIns = pDrvIns;
-
-    vdiInitVDIDisk(pData);
+    pThis->pDrvIns = pDrvIns;
+
+    vdiInitVDIDisk(pThis);
 
     /* IMedia */
-    pData->IMedia.pfnRead               = vdiRead;
-    pData->IMedia.pfnWrite              = vdiWrite;
-    pData->IMedia.pfnFlush              = vdiFlush;
-    pData->IMedia.pfnGetSize            = vdiGetSize;
-    pData->IMedia.pfnGetUuid            = vdiGetUuid;
-    pData->IMedia.pfnIsReadOnly         = vdiIsReadOnly;
-    pData->IMedia.pfnBiosGetPCHSGeometry = vdiBiosGetPCHSGeometry;
-    pData->IMedia.pfnBiosSetPCHSGeometry = vdiBiosSetPCHSGeometry;
-    pData->IMedia.pfnBiosGetLCHSGeometry = vdiBiosGetLCHSGeometry;
-    pData->IMedia.pfnBiosSetLCHSGeometry = vdiBiosSetLCHSGeometry;
+    pThis->IMedia.pfnRead               = vdiRead;
+    pThis->IMedia.pfnWrite              = vdiWrite;
+    pThis->IMedia.pfnFlush              = vdiFlush;
+    pThis->IMedia.pfnGetSize            = vdiGetSize;
+    pThis->IMedia.pfnGetUuid            = vdiGetUuid;
+    pThis->IMedia.pfnIsReadOnly         = vdiIsReadOnly;
+    pThis->IMedia.pfnBiosGetPCHSGeometry = vdiBiosGetPCHSGeometry;
+    pThis->IMedia.pfnBiosSetPCHSGeometry = vdiBiosSetPCHSGeometry;
+    pThis->IMedia.pfnBiosGetLCHSGeometry = vdiBiosGetLCHSGeometry;
+    pThis->IMedia.pfnBiosSetLCHSGeometry = vdiBiosSetLCHSGeometry;
 
     /*
@@ -371 +371 @@
          * Open the image.
          */
-        rc = VDIDiskOpenImage(pData, pszName, fReadOnly ? VDI_OPEN_FLAGS_READONLY
+        rc = VDIDiskOpenImage(pThis, pszName, fReadOnly ? VDI_OPEN_FLAGS_READONLY
                                                         : VDI_OPEN_FLAGS_NORMAL);
         if (RT_SUCCESS(rc))
             Log(("vdiConstruct: %d - Opened '%s' in %s mode\n",
-                 iLevel, pszName, VDIDiskIsReadOnly(pData) ? "read-only" : "read-write"));
+                 iLevel, pszName, VDIDiskIsReadOnly(pThis) ? "read-only" : "read-write"));
         else
             AssertMsgFailed(("Failed to open image '%s' rc=%Vrc\n", pszName, rc));
@@ -387 +387 @@
     /* If any of the images has the flag set, handle zero writes like normal. */
     if (RT_SUCCESS(rc))
-        pData->fHonorZeroWrites = fHonorZeroWrites;
+        pThis->fHonorZeroWrites = fHonorZeroWrites;
 
     /* On failure, vdiDestruct will be called, so no need to clean up here. */