Changeset 11269 in vbox for trunk/src/VBox

Timestamp:

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

Author:

vboxsync

svn:sync-xref-src-repo-rev:

34351

Message:

Devices: pData -> pThis.

Location:

trunk/src/VBox/Devices

Files:

• Audio/DevIchAc97.cpp (modified) (12 diffs)
• Audio/DevSB16.cpp (modified) (1 diff)
• Audio/audio.c (modified) (4 diffs)
• Audio/audiosniffer.c (modified) (6 diffs)
• Bus/DevPCI.cpp (modified) (7 diffs)
• Graphics/DevVGA.cpp (modified) (110 diffs)
• Input/DevPS2.cpp (modified) (11 diffs)
• Input/DrvKeyboardQueue.cpp (modified) (6 diffs)
• Input/DrvMouseQueue.cpp (modified) (6 diffs)
• Network/DevPCNet.cpp (modified) (216 diffs)
• Network/DrvNAT.cpp (modified) (36 diffs)
• Network/DrvTAP.cpp (modified) (44 diffs)
• Network/DrvTAPWin.cpp (modified) (20 diffs)
• PC/DevACPI.cpp (modified) (1 diff)
• PC/DevAPIC.cpp (modified) (11 diffs)
• PC/DevPit-i8254.cpp (modified) (18 diffs)
• PC/DevRTC.cpp (modified) (11 diffs)
• PC/DrvACPI.cpp (modified) (4 diffs)
• Parallel/DevParallel.cpp (modified) (24 diffs)
• Parallel/DrvHostParallel.cpp (modified) (19 diffs)
• Serial/DevSerial.cpp (modified) (26 diffs)
• Serial/DrvChar.cpp (modified) (17 diffs)
• Serial/DrvHostSerial.cpp (modified) (50 diffs)
• Serial/DrvNamedPipe.cpp (modified) (21 diffs)
• Storage/DevATA.cpp (modified) (49 diffs)
• Storage/DrvBlock.cpp (modified) (55 diffs)
• Storage/DrvMediaISO.cpp (modified) (8 diffs)
• Storage/DrvRawImage.cpp (modified) (12 diffs)
• Storage/DrvVD.cpp (modified) (36 diffs)
• Storage/VBoxHDD.cpp (modified) (17 diffs)
• VMMDev/VBoxDev.cpp (modified) (95 diffs)

trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

@@ -1390 +1390 @@
     PPDMDEVINS  pDevIns = pPciDev->pDevIns;
     RTIOPORT    Port = (RTIOPORT)GCPhysAddress;
-    PCIAC97LinkState *pData = PCIDEV_2_ICHAC97STATE(pPciDev);
+    PCIAC97LinkState *pThis = PCIDEV_2_ICHAC97STATE(pPciDev);
 
     Assert(enmType == PCI_ADDRESS_SPACE_IO);
@@ -1396 +1396 @@
 
     if (iRegion == 0)
-        rc = PDMDevHlpIOPortRegister (pDevIns, Port, 256, pData,
+        rc = PDMDevHlpIOPortRegister (pDevIns, Port, 256, pThis,
                                       ichac97IOPortNAMWrite, ichac97IOPortNAMRead,
                                       NULL, NULL, "ICHAC97 NAM");
     else
-        rc = PDMDevHlpIOPortRegister (pDevIns, Port, 64, pData,
+        rc = PDMDevHlpIOPortRegister (pDevIns, Port, 64, pThis,
                                       ichac97IOPortNABMWrite, ichac97IOPortNABMRead,
                                       NULL, NULL, "ICHAC97 NABM");
@@ -1406 +1406 @@
         return rc;
 
-    pData->ac97.IOPortBase[iRegion] = Port;
+    pThis->ac97.IOPortBase[iRegion] = Port;
     return VINF_SUCCESS;
 }
@@ -1419 +1419 @@
 static DECLCALLBACK(int) ichac97SaveExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PCIAC97LinkState *pData = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
+    PCIAC97LinkState *pThis = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
     size_t  i;
     uint8_t active[LAST_INDEX];
-    AC97LinkState *s = &pData->ac97;
+    AC97LinkState *s = &pThis->ac97;
 
     SSMR3PutU32 (pSSMHandle, s->glob_cnt);
@@ -1463 +1463 @@
                                           uint32_t u32Version)
 {
-    PCIAC97LinkState *pData = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
+    PCIAC97LinkState *pThis = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
     size_t  i;
     uint8_t active[LAST_INDEX];
-    AC97LinkState *s = &pData->ac97;
+    AC97LinkState *s = &pThis->ac97;
 
     if (u32Version != AC97_SSM_VERSION)
@@ -1522 +1522 @@
 static DECLCALLBACK(void)  ac97Reset (PPDMDEVINS pDevIns)
 {
-    PCIAC97LinkState *pData = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
+    PCIAC97LinkState *pThis = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
 
     /*
      * Reset the device state (will need pDrv later).
      */
-    reset_bm_regs (&pData->ac97, &pData->ac97.bm_regs[0]);
-    reset_bm_regs (&pData->ac97, &pData->ac97.bm_regs[1]);
-    reset_bm_regs (&pData->ac97, &pData->ac97.bm_regs[2]);
+    reset_bm_regs (&pThis->ac97, &pThis->ac97.bm_regs[0]);
+    reset_bm_regs (&pThis->ac97, &pThis->ac97.bm_regs[1]);
+    reset_bm_regs (&pThis->ac97, &pThis->ac97.bm_regs[2]);
 
     /*
@@ -1536 +1536 @@
      * the codec manually.
      */
-    mixer_reset (&pData->ac97);
+    mixer_reset (&pThis->ac97);
 }
 
@@ -1551 +1551 @@
                                                    PDMINTERFACE enmInterface)
 {
-    PCIAC97LinkState *pData =
+    PCIAC97LinkState *pThis =
         (PCIAC97LinkState *)((uintptr_t)pInterface
                              - RT_OFFSETOF(PCIAC97LinkState, ac97.IBase));
-    Assert(&pData->ac97.IBase == pInterface);
+    Assert(&pThis->ac97.IBase == pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->ac97.IBase;
+            return &pThis->ac97.IBase;
         default:
             return NULL;
@@ -1585 +1585 @@
                                            PCFGMNODE pCfgHandle)
 {
-    PCIAC97LinkState *pData = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
-    AC97LinkState    *s     = &pData->ac97;
+    PCIAC97LinkState *pThis = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
+    AC97LinkState    *s     = &pThis->ac97;
     int               rc;
 
@@ -1599 +1599 @@
 
     /* PCI Device (the assertions will be removed later) */
-    PCIDevSetVendorId           (&pData->dev, 0x8086); /* 00 ro - intel. */             Assert (pData->dev.config[0x00] == 0x86); Assert (pData->dev.config[0x01] == 0x80);
-    PCIDevSetDeviceId           (&pData->dev, 0x2415); /* 02 ro - 82801 / 82801aa(?). */Assert (pData->dev.config[0x02] == 0x15); Assert (pData->dev.config[0x03] == 0x24);
-    PCIDevSetCommand            (&pData->dev, 0x0000); /* 04 rw,ro - pcicmd. */         Assert (pData->dev.config[0x04] == 0x00); Assert (pData->dev.config[0x05] == 0x00);
-    PCIDevSetStatus             (&pData->dev, 0x0280); /* 06 rwc?,ro? - pcists. */      Assert (pData->dev.config[0x06] == 0x80); Assert (pData->dev.config[0x07] == 0x02);
-    PCIDevSetRevisionId         (&pData->dev, 0x01);   /* 08 ro - rid. */               Assert (pData->dev.config[0x08] == 0x01);
-    PCIDevSetClassProg          (&pData->dev, 0x00);   /* 09 ro - pi. */                Assert (pData->dev.config[0x09] == 0x00);
-    PCIDevSetClassSub           (&pData->dev, 0x01);   /* 0a ro - scc; 01 == Audio. */  Assert (pData->dev.config[0x0a] == 0x01);
-    PCIDevSetClassBase          (&pData->dev, 0x04);   /* 0b ro - bcc; 04 == multimedia. */ Assert (pData->dev.config[0x0b] == 0x04);
-    PCIDevSetHeaderType         (&pData->dev, 0x00);   /* 0e ro - headtyp. */           Assert (pData->dev.config[0x0e] == 0x00);
-    PCIDevSetBaseAddress        (&pData->dev, 0,       /* 10 rw - nambar - native audio mixer base. */
-                                 true /* fIoSpace */, false /* fPrefetchable */, false /* f64Bit */, 0x00000000); Assert (pData->dev.config[0x10] == 0x01); Assert (pData->dev.config[0x11] == 0x00); Assert (pData->dev.config[0x12] == 0x00); Assert (pData->dev.config[0x13] == 0x00);
-    PCIDevSetBaseAddress        (&pData->dev, 1,       /* 14 rw - nabmbar - native audio bus mastering. */
-                                 true /* fIoSpace */, false /* fPrefetchable */, false /* f64Bit */, 0x00000000); Assert (pData->dev.config[0x14] == 0x01); Assert (pData->dev.config[0x15] == 0x00); Assert (pData->dev.config[0x16] == 0x00); Assert (pData->dev.config[0x17] == 0x00);
-    PCIDevSetSubSystemVendorId  (&pData->dev, 0x8086); /* 2c ro - intel.) */            Assert (pData->dev.config[0x2c] == 0x86); Assert (pData->dev.config[0x2d] == 0x80);
-    PCIDevSetSubSystemId        (&pData->dev, 0x0000); /* 2e ro. */                     Assert (pData->dev.config[0x2e] == 0x00); Assert (pData->dev.config[0x2f] == 0x00);
-    PCIDevSetInterruptLine      (&pData->dev, 0x00);   /* 3c rw. */                     Assert (pData->dev.config[0x3c] == 0x00);
-    PCIDevSetInterruptPin       (&pData->dev, 0x01);   /* 3d ro - INTA#. */             Assert (pData->dev.config[0x3d] == 0x01);
+    PCIDevSetVendorId           (&pThis->dev, 0x8086); /* 00 ro - intel. */             Assert (pThis->dev.config[0x00] == 0x86); Assert (pThis->dev.config[0x01] == 0x80);
+    PCIDevSetDeviceId           (&pThis->dev, 0x2415); /* 02 ro - 82801 / 82801aa(?). */Assert (pThis->dev.config[0x02] == 0x15); Assert (pThis->dev.config[0x03] == 0x24);
+    PCIDevSetCommand            (&pThis->dev, 0x0000); /* 04 rw,ro - pcicmd. */         Assert (pThis->dev.config[0x04] == 0x00); Assert (pThis->dev.config[0x05] == 0x00);
+    PCIDevSetStatus             (&pThis->dev, 0x0280); /* 06 rwc?,ro? - pcists. */      Assert (pThis->dev.config[0x06] == 0x80); Assert (pThis->dev.config[0x07] == 0x02);
+    PCIDevSetRevisionId         (&pThis->dev, 0x01);   /* 08 ro - rid. */               Assert (pThis->dev.config[0x08] == 0x01);
+    PCIDevSetClassProg          (&pThis->dev, 0x00);   /* 09 ro - pi. */                Assert (pThis->dev.config[0x09] == 0x00);
+    PCIDevSetClassSub           (&pThis->dev, 0x01);   /* 0a ro - scc; 01 == Audio. */  Assert (pThis->dev.config[0x0a] == 0x01);
+    PCIDevSetClassBase          (&pThis->dev, 0x04);   /* 0b ro - bcc; 04 == multimedia. */ Assert (pThis->dev.config[0x0b] == 0x04);
+    PCIDevSetHeaderType         (&pThis->dev, 0x00);   /* 0e ro - headtyp. */           Assert (pThis->dev.config[0x0e] == 0x00);
+    PCIDevSetBaseAddress        (&pThis->dev, 0,       /* 10 rw - nambar - native audio mixer base. */
+                                 true /* fIoSpace */, false /* fPrefetchable */, false /* f64Bit */, 0x00000000); Assert (pThis->dev.config[0x10] == 0x01); Assert (pThis->dev.config[0x11] == 0x00); Assert (pThis->dev.config[0x12] == 0x00); Assert (pThis->dev.config[0x13] == 0x00);
+    PCIDevSetBaseAddress        (&pThis->dev, 1,       /* 14 rw - nabmbar - native audio bus mastering. */
+                                 true /* fIoSpace */, false /* fPrefetchable */, false /* f64Bit */, 0x00000000); Assert (pThis->dev.config[0x14] == 0x01); Assert (pThis->dev.config[0x15] == 0x00); Assert (pThis->dev.config[0x16] == 0x00); Assert (pThis->dev.config[0x17] == 0x00);
+    PCIDevSetSubSystemVendorId  (&pThis->dev, 0x8086); /* 2c ro - intel.) */            Assert (pThis->dev.config[0x2c] == 0x86); Assert (pThis->dev.config[0x2d] == 0x80);
+    PCIDevSetSubSystemId        (&pThis->dev, 0x0000); /* 2e ro. */                     Assert (pThis->dev.config[0x2e] == 0x00); Assert (pThis->dev.config[0x2f] == 0x00);
+    PCIDevSetInterruptLine      (&pThis->dev, 0x00);   /* 3c rw. */                     Assert (pThis->dev.config[0x3c] == 0x00);
+    PCIDevSetInterruptPin       (&pThis->dev, 0x01);   /* 3d ro - INTA#. */             Assert (pThis->dev.config[0x3d] == 0x01);
 
     /*
@@ -1621 +1621 @@
      * saved state item.
      */
-    rc = PDMDevHlpPCIRegister (pDevIns, &pData->dev);
+    rc = PDMDevHlpPCIRegister (pDevIns, &pThis->dev);
     if (RT_FAILURE (rc))
         return rc;
@@ -1636 +1636 @@
 
     rc = PDMDevHlpSSMRegister (pDevIns, pDevIns->pDevReg->szDeviceName,
-                               iInstance, AC97_SSM_VERSION, sizeof(*pData),
+                               iInstance, AC97_SSM_VERSION, sizeof(*pThis),
                                NULL, ichac97SaveExec, NULL,
                                NULL, ichac97LoadExec, NULL);

trunk/src/VBox/Devices/Audio/DevSB16.cpp

@@ -1713 +1713 @@
                                                 PDMINTERFACE enmInterface)
 {
-    SB16State *pData = (SB16State *)((uintptr_t)pInterface
+    SB16State *pThis = (SB16State *)((uintptr_t)pInterface
                      - RT_OFFSETOF(SB16State, IBase));
-    Assert(&pData->IBase == pInterface);
+    Assert(&pThis->IBase == pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         default:
             return NULL;

trunk/src/VBox/Devices/Audio/audio.c

@@ -1929 +1929 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVAUDIO  pData = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
+    PDRVAUDIO  pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
     switch (enmInterface)
     {
@@ -1935 +1935 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_AUDIO_CONNECTOR:
-            return &pData->IAudioConnector;
+            return &pThis->IAudioConnector;
         default:
             return NULL;
@@ -1980 +1980 @@
 {
     int rc;
-    PDRVAUDIO pData = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
+    PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
     char *drvname;
 
@@ -1993 +1993 @@
      * Init the static parts.
      */
-    pData->pDrvIns                    = pDrvIns;
+    pThis->pDrvIns                    = pDrvIns;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface  = drvAudioQueryInterface;
     /* IAudio */
-    /* pData->IAudioConnector.pfn; */
+    /* pThis->IAudioConnector.pfn; */
 
     glob_audio_state.pDrvIns = pDrvIns;

trunk/src/VBox/Devices/Audio/audiosniffer.c

@@ -113 +113 @@
 static DECLCALLBACK(int) iface_Setup (PPDMIAUDIOSNIFFERPORT pInterface, bool fEnable, bool fKeepHostAudio)
 {
-    AUDIOSNIFFERSTATE *pData = IAUDIOSNIFFERPORT_2_AUDIOSNIFFERSTATE(pInterface);
-
-    Assert(g_pData == pData);
-
-    pData->fEnabled = fEnable;
-    pData->fKeepHostAudio = fKeepHostAudio;
+    AUDIOSNIFFERSTATE *pThis = IAUDIOSNIFFERPORT_2_AUDIOSNIFFERSTATE(pInterface);
+
+    Assert(g_pData == pThis);
+
+    pThis->fEnabled = fEnable;
+    pThis->fKeepHostAudio = fKeepHostAudio;
 
     return VINF_SUCCESS;
@@ -133 +133 @@
 static DECLCALLBACK(void *) iface_QueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    AUDIOSNIFFERSTATE *pData = (AUDIOSNIFFERSTATE *)((uintptr_t)pInterface - RT_OFFSETOF(AUDIOSNIFFERSTATE, Base));
+    AUDIOSNIFFERSTATE *pThis = (AUDIOSNIFFERSTATE *)((uintptr_t)pInterface - RT_OFFSETOF(AUDIOSNIFFERSTATE, Base));
 
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->Base;
+            return &pThis->Base;
         case PDMINTERFACE_AUDIO_SNIFFER_PORT:
-            return &pData->Port;
+            return &pThis->Port;
         default:
             return NULL;
@@ -163 +163 @@
     int rc = VINF_SUCCESS;
 
-    AUDIOSNIFFERSTATE *pData = PDMINS_2_DATA(pDevIns, AUDIOSNIFFERSTATE *);
+    AUDIOSNIFFERSTATE *pThis = PDMINS_2_DATA(pDevIns, AUDIOSNIFFERSTATE *);
 
     Assert(iInstance == 0);
@@ -178 +178 @@
      * Initialize data.
      */
-    pData->fEnabled = false;
-    pData->fKeepHostAudio = true;
-    pData->pDrv = NULL;
+    pThis->fEnabled = false;
+    pThis->fKeepHostAudio = true;
+    pThis->pDrv = NULL;
 
     /*
@@ -186 +186 @@
      */
     /* Base */
-    pData->Base.pfnQueryInterface = iface_QueryInterface;
+    pThis->Base.pfnQueryInterface = iface_QueryInterface;
 
     /* Audio Sniffer port */
-    pData->Port.pfnSetup = iface_Setup;
+    pThis->Port.pfnSetup = iface_Setup;
 
     /*
      * Get the corresponding connector interface
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pData->Base, &pData->pDrvBase, "Audio Sniffer Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->Base, &pThis->pDrvBase, "Audio Sniffer Port");
 
     if (RT_SUCCESS(rc))
     {
-        pData->pDrv = (PPDMIAUDIOSNIFFERCONNECTOR)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_AUDIO_SNIFFER_CONNECTOR);
-
-        if (!pData->pDrv)
+        pThis->pDrv = (PPDMIAUDIOSNIFFERCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_AUDIO_SNIFFER_CONNECTOR);
+
+        if (!pThis->pDrv)
         {
             AssertMsgFailed(("LUN #0 doesn't have a Audio Sniffer connector interface rc=%Vrc\n", rc));
@@ -219 +219 @@
     {
         /* Save PDM device instance data for future reference. */
-        pData->pDevIns = pDevIns;
+        pThis->pDevIns = pDevIns;
 
         /* Save the pointer to created instance in the global variable, so other
          * functions could reach it.
          */
-        g_pData = pData;
+        g_pData = pThis;
     }
 

trunk/src/VBox/Devices/Bus/DevPCI.cpp

@@ -996 +996 @@
 {
     uint32_t    i;
-    PPCIBUS     pData = PDMINS_2_DATA(pDevIns, PPCIBUS);
-    PPCIGLOBALS pGlobals = PCIBUS_2_PCIGLOBALS(pData);
+    PPCIBUS     pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
+    PPCIGLOBALS pGlobals = PCIBUS_2_PCIGLOBALS(pThis);
 
     /*
      * Bus state data.
      */
-    SSMR3PutU32(pSSMHandle, pData->uConfigReg);
+    SSMR3PutU32(pSSMHandle, pThis->uConfigReg);
     SSMR3PutBool(pSSMHandle, pGlobals->fUseIoApic);
     SSMR3PutU32(pSSMHandle, ~0);        /* separator */
@@ -1009 +1009 @@
      * Iterate all the devices.
      */
-    for (i = 0; i < RT_ELEMENTS(pData->devices); i++)
-    {
-        PPCIDEVICE pDev = pData->devices[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->devices); i++)
+    {
+        PPCIDEVICE pDev = pThis->devices[i];
         if (pDev)
         {
@@ -1035 +1035 @@
 static DECLCALLBACK(int) pciLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
 {
-    PPCIBUS     pData = PDMINS_2_DATA(pDevIns, PPCIBUS);
-    PPCIGLOBALS  pGlobals = PCIBUS_2_PCIGLOBALS(pData);
+    PPCIBUS     pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
+    PPCIGLOBALS  pGlobals = PCIBUS_2_PCIGLOBALS(pThis);
     uint32_t    u32;
     uint32_t    i;
@@ -1053 +1053 @@
      * Bus state data.
      */
-    SSMR3GetU32(pSSMHandle, &pData->uConfigReg);
+    SSMR3GetU32(pSSMHandle, &pThis->uConfigReg);
     if (u32Version > 1)
         SSMR3GetBool(pSSMHandle, &pGlobals->fUseIoApic);
@@ -1078 +1078 @@
         if (u32 == (uint32_t)~0)
             break;
-        if (    u32 >= RT_ELEMENTS(pData->devices)
+        if (    u32 >= RT_ELEMENTS(pThis->devices)
             ||  u32 < i)
         {
@@ -1088 +1088 @@
         for (; i < u32; i++)
         {
-            if (pData->devices[i])
+            if (pThis->devices[i])
             {
-                LogRel(("New device in slot %#x, %s (vendor=%#06x device=%#06x)\n", i, pData->devices[i]->name,
-                        PCIDevGetVendorId(pData->devices[i]), PCIDevGetDeviceId(pData->devices[i])));
+                LogRel(("New device in slot %#x, %s (vendor=%#06x device=%#06x)\n", i, pThis->devices[i]->name,
+                        PCIDevGetVendorId(pThis->devices[i]), PCIDevGetDeviceId(pThis->devices[i])));
                 if (SSMR3HandleGetAfter(pSSMHandle) != SSMAFTER_DEBUG_IT)
                     AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
@@ -1104 +1104 @@
 
         /* check that it's still around. */
-        pDev = pData->devices[i];
+        pDev = pThis->devices[i];
         if (!pDev)
         {

trunk/src/VBox/Devices/Graphics/DevVGA.cpp

@@ -340 +340 @@
  * Set a VRAM page dirty.
  *
- * @param   pData       VGA instance data.
+ * @param   pThis       VGA instance data.
  * @param   offVRAM     The VRAM offset of the page to set.
  */
-DECLINLINE(void) vga_set_dirty(VGAState *pData, RTGCPHYS offVRAM)
-{
-    AssertMsg(offVRAM < pData->vram_size, ("offVRAM = %p, pData->vram_size = %p\n", offVRAM, pData->vram_size));
-    ASMBitSet(&pData->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
-    pData->fHaveDirtyBits = true;
+DECLINLINE(void) vga_set_dirty(VGAState *pThis, RTGCPHYS offVRAM)
+{
+    AssertMsg(offVRAM < pThis->vram_size, ("offVRAM = %p, pThis->vram_size = %p\n", offVRAM, pThis->vram_size));
+    ASMBitSet(&pThis->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
+    pThis->fHaveDirtyBits = true;
 }
 
@@ -355 +355 @@
  * @returns true if dirty.
  * @returns false if clean.
- * @param   pData       VGA instance data.
+ * @param   pThis       VGA instance data.
  * @param   offVRAM     The VRAM offset of the page to check.
  */
-DECLINLINE(bool) vga_is_dirty(VGAState *pData, RTGCPHYS offVRAM)
-{
-    AssertMsg(offVRAM < pData->vram_size, ("offVRAM = %p, pData->vram_size = %p\n", offVRAM, pData->vram_size));
-    return ASMBitTest(&pData->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
+DECLINLINE(bool) vga_is_dirty(VGAState *pThis, RTGCPHYS offVRAM)
+{
+    AssertMsg(offVRAM < pThis->vram_size, ("offVRAM = %p, pThis->vram_size = %p\n", offVRAM, pThis->vram_size));
+    return ASMBitTest(&pThis->au32DirtyBitmap[0], offVRAM >> PAGE_SHIFT);
 }
 
@@ -367 +367 @@
  * Reset dirty flags in a give range.
  *
- * @param   pData           VGA instance data.
+ * @param   pThis           VGA instance data.
  * @param   offVRAMStart    Offset into the VRAM buffer of the first page.
  * @param   offVRAMEnd      Offset into the VRAM buffer of the last page - exclusive.
  */
-DECLINLINE(void) vga_reset_dirty(VGAState *pData, RTGCPHYS offVRAMStart, RTGCPHYS offVRAMEnd)
-{
-    Assert(offVRAMStart < pData->vram_size);
-    Assert(offVRAMEnd <= pData->vram_size);
+DECLINLINE(void) vga_reset_dirty(VGAState *pThis, RTGCPHYS offVRAMStart, RTGCPHYS offVRAMEnd)
+{
+    Assert(offVRAMStart < pThis->vram_size);
+    Assert(offVRAMEnd <= pThis->vram_size);
     Assert(offVRAMStart < offVRAMEnd);
-    ASMBitClearRange(&pData->au32DirtyBitmap[0], offVRAMStart >> PAGE_SHIFT, offVRAMEnd >> PAGE_SHIFT);
+    ASMBitClearRange(&pThis->au32DirtyBitmap[0], offVRAMStart >> PAGE_SHIFT, offVRAMEnd >> PAGE_SHIFT);
 }
 
@@ -3211 +3211 @@
 PDMBOTHCBDECL(int) vgaMMIOFill(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, uint32_t u32Item, unsigned cbItem, unsigned cItems)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     uint32_t b;
     uint32_t write_mask, bit_mask, set_mask;
@@ -3226 +3226 @@
     /// @todo add check for the end of region
     GCPhysAddr &= 0x1ffff;
-    switch((pData->gr[6] >> 2) & 3) {
+    switch((pThis->gr[6] >> 2) & 3) {
     case 0:
         break;
@@ -3232 +3232 @@
         if (GCPhysAddr >= 0x10000)
             return VINF_SUCCESS;
-        GCPhysAddr += pData->bank_offset;
+        GCPhysAddr += pThis->bank_offset;
         break;
     case 2:
@@ -3247 +3247 @@
     }
 
-    if (pData->sr[4] & 0x08) {
+    if (pThis->sr[4] & 0x08) {
         /* chain 4 mode : simplest access */
 #ifdef IN_GC
@@ -3253 +3253 @@
             return VINF_IOM_HC_MMIO_WRITE;
 #else
-        if (GCPhysAddr + cItems * cbItem >= pData->vram_size)
+        if (GCPhysAddr + cItems * cbItem >= pThis->vram_size)
         {
             AssertMsgFailed(("GCPhysAddr=%VGp cItems=%#x cbItem=%d\n", GCPhysAddr, cItems, cbItem));
@@ -3263 +3263 @@
             for (i = 0; i < cbItem; i++)
             {
-                if (pData->sr[2] & (1 << (GCPhysAddr & 3)))
+                if (pThis->sr[2] & (1 << (GCPhysAddr & 3)))
                 {
-                    pData->CTX_SUFF(vram_ptr)[GCPhysAddr] = aVal[i];
-                    vga_set_dirty(pData, GCPhysAddr);
+                    pThis->CTX_SUFF(vram_ptr)[GCPhysAddr] = aVal[i];
+                    vga_set_dirty(pThis, GCPhysAddr);
                 }
                 GCPhysAddr++;
             }
-    } else if (pData->gr[5] & 0x10) {
+    } else if (pThis->gr[5] & 0x10) {
         /* odd/even mode (aka text mode mapping) */
 #ifdef IN_GC
@@ -3276 +3276 @@
             return VINF_IOM_HC_MMIO_WRITE;
 #else
-        if (GCPhysAddr * 2 + cItems * cbItem >= pData->vram_size)
+        if (GCPhysAddr * 2 + cItems * cbItem >= pThis->vram_size)
         {
             AssertMsgFailed(("GCPhysAddr=%VGp cItems=%#x cbItem=%d\n", GCPhysAddr, cItems, cbItem));
@@ -3285 +3285 @@
             for (i = 0; i < cbItem; i++)
             {
-                unsigned plane = (pData->gr[4] & 2) | (GCPhysAddr & 1);
-                if (pData->sr[2] & (1 << plane)) {
+                unsigned plane = (pThis->gr[4] & 2) | (GCPhysAddr & 1);
+                if (pThis->sr[2] & (1 << plane)) {
                     RTGCPHYS PhysAddr2 = ((GCPhysAddr & ~1) << 2) | plane;
-                    pData->CTX_SUFF(vram_ptr)[PhysAddr2] = aVal[i];
-                    vga_set_dirty(pData, PhysAddr2);
+                    pThis->CTX_SUFF(vram_ptr)[PhysAddr2] = aVal[i];
+                    vga_set_dirty(pThis, PhysAddr2);
                 }
                 GCPhysAddr++;
@@ -3298 +3298 @@
             return VINF_IOM_HC_MMIO_WRITE;
 #else
-        if (GCPhysAddr + cItems * cbItem >= pData->vram_size)
+        if (GCPhysAddr + cItems * cbItem >= pThis->vram_size)
         {
             AssertMsgFailed(("GCPhysAddr=%VGp cItems=%#x cbItem=%d\n", GCPhysAddr, cItems, cbItem));
@@ -3306 +3306 @@
 
         /* standard VGA latched access */
-        switch(pData->gr[5] & 3) {
+        switch(pThis->gr[5] & 3) {
         default:
         case 0:
             /* rotate */
-            b = pData->gr[3] & 7;
-            bit_mask = pData->gr[8];
+            b = pThis->gr[3] & 7;
+            bit_mask = pThis->gr[8];
             bit_mask |= bit_mask << 8;
             bit_mask |= bit_mask << 16;
-            set_mask = mask16[pData->gr[1]];
+            set_mask = mask16[pThis->gr[1]];
 
             for (i = 0; i < cbItem; i++)
@@ -3323 +3323 @@
 
                 /* apply set/reset mask */
-                aVal[i] = (aVal[i] & ~set_mask) | (mask16[pData->gr[0]] & set_mask);
-
-                APPLY_LOGICAL_AND_MASK(pData, aVal[i], bit_mask);
+                aVal[i] = (aVal[i] & ~set_mask) | (mask16[pThis->gr[0]] & set_mask);
+
+                APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
             }
             break;
         case 1:
             for (i = 0; i < cbItem; i++)
-                aVal[i] = pData->latch;
+                aVal[i] = pThis->latch;
             break;
         case 2:
-            bit_mask = pData->gr[8];
+            bit_mask = pThis->gr[8];
             bit_mask |= bit_mask << 8;
             bit_mask |= bit_mask << 16;
@@ -3340 +3340 @@
                 aVal[i] = mask16[aVal[i] & 0x0f];
 
-                APPLY_LOGICAL_AND_MASK(pData, aVal[i], bit_mask);
+                APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
             }
             break;
         case 3:
             /* rotate */
-            b = pData->gr[3] & 7;
+            b = pThis->gr[3] & 7;
 
             for (i = 0; i < cbItem; i++)
             {
                 aVal[i] = (aVal[i] >> b) | (aVal[i] << (8 - b));
-                bit_mask = pData->gr[8] & aVal[i];
+                bit_mask = pThis->gr[8] & aVal[i];
                 bit_mask |= bit_mask << 8;
                 bit_mask |= bit_mask << 16;
-                aVal[i] = mask16[pData->gr[0]];
-
-                APPLY_LOGICAL_AND_MASK(pData, aVal[i], bit_mask);
+                aVal[i] = mask16[pThis->gr[0]];
+
+                APPLY_LOGICAL_AND_MASK(pThis, aVal[i], bit_mask);
             }
             break;
@@ -3361 +3361 @@
 
         /* mask data according to sr[2] */
-        write_mask = mask16[pData->sr[2]];
+        write_mask = mask16[pThis->sr[2]];
 
         /* actually write data */
@@ -3369 +3369 @@
             while (cItems-- > 0)
             {
-                ((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
-                vga_set_dirty(pData, GCPhysAddr << 2);
+                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
+                vga_set_dirty(pThis, GCPhysAddr << 2);
                 GCPhysAddr++;
             }
@@ -3379 +3379 @@
             while (cItems-- > 0)
             {
-                ((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
-                vga_set_dirty(pData, GCPhysAddr << 2);
+                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[0] & write_mask);
+                vga_set_dirty(pThis, GCPhysAddr << 2);
                 GCPhysAddr++;
 
-                ((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[1] & write_mask);
-                vga_set_dirty(pData, GCPhysAddr << 2);
+                ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[1] & write_mask);
+                vga_set_dirty(pThis, GCPhysAddr << 2);
                 GCPhysAddr++;
             }
@@ -3395 +3395 @@
                 for (i = 0; i < cbItem; i++)
                 {
-                    ((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pData->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[i] & write_mask);
-                    vga_set_dirty(pData, GCPhysAddr << 2);
+                    ((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] = (((uint32_t *)pThis->CTX_SUFF(vram_ptr))[GCPhysAddr] & ~write_mask) | (aVal[i] & write_mask);
+                    vga_set_dirty(pThis, GCPhysAddr << 2);
                     GCPhysAddr++;
                 }
@@ -3418 +3418 @@
 PDMBOTHCBDECL(int) vgaMMIORead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
-    STAM_PROFILE_START(&pData->StatGCMemoryRead, a);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    STAM_PROFILE_START(&pThis->StatGCMemoryRead, a);
     NOREF(pvUser);
     switch (cb)
     {
         case 1:
-            *(uint8_t  *)pv = vga_mem_readb(pData, GCPhysAddr); break;
+            *(uint8_t  *)pv = vga_mem_readb(pThis, GCPhysAddr); break;
         case 2:
-            *(uint16_t *)pv = vga_mem_readb(pData, GCPhysAddr)
-                           | (vga_mem_readb(pData, GCPhysAddr + 1) << 8);
+            *(uint16_t *)pv = vga_mem_readb(pThis, GCPhysAddr)
+                           | (vga_mem_readb(pThis, GCPhysAddr + 1) << 8);
             break;
         case 4:
-            *(uint32_t *)pv = vga_mem_readb(pData, GCPhysAddr)
-                           | (vga_mem_readb(pData, GCPhysAddr + 1) <<  8)
-                           | (vga_mem_readb(pData, GCPhysAddr + 2) << 16)
-                           | (vga_mem_readb(pData, GCPhysAddr + 3) << 24);
+            *(uint32_t *)pv = vga_mem_readb(pThis, GCPhysAddr)
+                           | (vga_mem_readb(pThis, GCPhysAddr + 1) <<  8)
+                           | (vga_mem_readb(pThis, GCPhysAddr + 2) << 16)
+                           | (vga_mem_readb(pThis, GCPhysAddr + 3) << 24);
             break;
 
         case 8:
-            *(uint64_t *)pv = (uint64_t)vga_mem_readb(pData, GCPhysAddr)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 1) <<  8)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 2) << 16)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 3) << 24)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 4) << 32)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 5) << 40)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 6) << 48)
-                           | ((uint64_t)vga_mem_readb(pData, GCPhysAddr + 7) << 56);
+            *(uint64_t *)pv = (uint64_t)vga_mem_readb(pThis, GCPhysAddr)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 1) <<  8)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 2) << 16)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 3) << 24)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 4) << 32)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 5) << 40)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 6) << 48)
+                           | ((uint64_t)vga_mem_readb(pThis, GCPhysAddr + 7) << 56);
             break;
 
@@ -3451 +3451 @@
             uint8_t *pu8Data = (uint8_t *)pv;
             while (cb-- > 0)
-                *pu8Data++ = vga_mem_readb(pData, GCPhysAddr++);
-        }
-    }
-    STAM_PROFILE_STOP(&pData->StatGCMemoryRead, a);
+                *pu8Data++ = vga_mem_readb(pThis, GCPhysAddr++);
+        }
+    }
+    STAM_PROFILE_STOP(&pThis->StatGCMemoryRead, a);
     return VINF_SUCCESS;
 }
@@ -3470 +3470 @@
 PDMBOTHCBDECL(int) vgaMMIOWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     uint8_t  *pu8 = (uint8_t *)pv;
     int rc = VINF_SUCCESS;
-    STAM_PROFILE_START(&pData->StatGCMemoryWrite, a);
+    STAM_PROFILE_START(&pThis->StatGCMemoryWrite, a);
 
     switch (cb)
     {
         case 1:
-            rc = vga_mem_writeb(pData, GCPhysAddr, *pu8);
+            rc = vga_mem_writeb(pThis, GCPhysAddr, *pu8);
             break;
 #if 1
         case 2:
-            rc = vga_mem_writeb(pData, GCPhysAddr + 0, pu8[0]);
+            rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pu8[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 1, pu8[1]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pu8[1]);
             break;
         case 4:
-            rc = vga_mem_writeb(pData, GCPhysAddr + 0, pu8[0]);
+            rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pu8[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 1, pu8[1]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pu8[1]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 2, pu8[2]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 2, pu8[2]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 3, pu8[3]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 3, pu8[3]);
             break;
         case 8:
-            rc = vga_mem_writeb(pData, GCPhysAddr + 0, pu8[0]);
+            rc = vga_mem_writeb(pThis, GCPhysAddr + 0, pu8[0]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 1, pu8[1]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 1, pu8[1]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 2, pu8[2]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 2, pu8[2]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 3, pu8[3]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 3, pu8[3]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 4, pu8[4]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 4, pu8[4]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 5, pu8[5]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 5, pu8[5]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 6, pu8[6]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 6, pu8[6]);
             if (RT_LIKELY(rc == VINF_SUCCESS))
-                rc = vga_mem_writeb(pData, GCPhysAddr + 7, pu8[7]);
+                rc = vga_mem_writeb(pThis, GCPhysAddr + 7, pu8[7]);
             break;
 #else
@@ -3525 +3525 @@
         default:
             while (cb-- > 0 && rc == VINF_SUCCESS)
-                rc = vga_mem_writeb(pData, GCPhysAddr++, *pu8++);
-            break;
-
-    }
-    STAM_PROFILE_STOP(&pData->StatGCMemoryWrite, a);
+                rc = vga_mem_writeb(pThis, GCPhysAddr++, *pu8++);
+            break;
+
+    }
+    STAM_PROFILE_STOP(&pThis->StatGCMemoryWrite, a);
     return rc;
 }
@@ -3538 +3538 @@
  * @returns VBox status code.
  * @param   pVM         VM handle.
- * @param   pData       VGA device instance data.
+ * @param   pThis       VGA device instance data.
  * @param   GCPhys      The access physical address.
  * @param   GCPtr       The access virtual address (only GC).
  */
-static int vgaLFBAccess(PVM pVM, PVGASTATE pData, RTGCPHYS GCPhys, RTGCPTR GCPtr)
+static int vgaLFBAccess(PVM pVM, PVGASTATE pThis, RTGCPHYS GCPhys, RTGCPTR GCPtr)
 {
     int rc;
@@ -3549 +3549 @@
      * Set page dirty bit.
      */
-    vga_set_dirty(pData, GCPhys - pData->GCPhysVRAM);
-    pData->fLFBUpdated = true;
+    vga_set_dirty(pThis, GCPhys - pThis->GCPhysVRAM);
+    pThis->fLFBUpdated = true;
 
     /*
@@ -3557 +3557 @@
      * ASSUME: the guest always maps video memory RW.
      */
-    rc = PGMHandlerPhysicalPageTempOff(pVM, pData->GCPhysVRAM, GCPhys);
+    rc = PGMHandlerPhysicalPageTempOff(pVM, pThis->GCPhysVRAM, GCPhys);
     if (RT_SUCCESS(rc))
     {
@@ -3592 +3592 @@
 PDMBOTHCBDECL(int) vgaGCLFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
 {
-    PVGASTATE   pData = (PVGASTATE)pvUser;
-    Assert(pData);
-    Assert(GCPhysFault >= pData->GCPhysVRAM);
+    PVGASTATE   pThis = (PVGASTATE)pvUser;
+    Assert(pThis);
+    Assert(GCPhysFault >= pThis->GCPhysVRAM);
     AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
 
-    return vgaLFBAccess(pVM, pData, GCPhysFault, pvFault);
+    return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault);
 }
 
@@ -3615 +3615 @@
 PDMBOTHCBDECL(int) vgaR0LFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
 {
-    PVGASTATE   pData = (PVGASTATE)pvUser;
-    Assert(pData);
-    Assert(GCPhysFault >= pData->GCPhysVRAM);
+    PVGASTATE   pThis = (PVGASTATE)pvUser;
+    Assert(pThis);
+    Assert(GCPhysFault >= pThis->GCPhysVRAM);
     AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
 
-    return vgaLFBAccess(pVM, pData, GCPhysFault, pvFault);
+    return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault);
 }
 
@@ -3640 +3640 @@
 static DECLCALLBACK(int) vgaR3LFBAccessHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
 {
-    PVGASTATE   pData = (PVGASTATE)pvUser;
+    PVGASTATE   pThis = (PVGASTATE)pvUser;
     int         rc;
-    Assert(pData);
-    Assert(GCPhys >= pData->GCPhysVRAM);
-    rc = vgaLFBAccess(pVM, pData, GCPhys, 0);
+    Assert(pThis);
+    Assert(GCPhys >= pThis->GCPhysVRAM);
+    rc = vgaLFBAccess(pVM, pThis, GCPhys, 0);
     if (RT_SUCCESS(rc))
         return VINF_PGM_HANDLER_DO_DEFAULT;
@@ -3671 +3671 @@
 PDMBOTHCBDECL(int) vbeIOPortWriteVBEExtra(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     NOREF(pvUser);
     NOREF(Port);
@@ -3678 +3678 @@
     {
         Log(("vbeIOPortWriteVBEExtra: addr=%#RX32\n", u32));
-        pData->u16VBEExtraAddress = u32;
+        pThis->u16VBEExtraAddress = u32;
         return VINF_SUCCESS;
     }
@@ -3700 +3700 @@
 PDMBOTHCBDECL(int) vbeIOPortReadVBEExtra(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     NOREF(pvUser);
     NOREF(Port);
 
-    if (pData->u16VBEExtraAddress == 0xffff)
+    if (pThis->u16VBEExtraAddress == 0xffff)
     {
         Log(("vbeIOPortReadVBEExtra: Requested number of 64k video banks\n"));
-        *pu32 = pData->vram_size / _64K;
+        *pu32 = pThis->vram_size / _64K;
         return VINF_SUCCESS;
     }
 
-    if (    pData->u16VBEExtraAddress >= pData->cbVBEExtraData
-        ||  pData->u16VBEExtraAddress + cb > pData->cbVBEExtraData)
+    if (    pThis->u16VBEExtraAddress >= pThis->cbVBEExtraData
+        ||  pThis->u16VBEExtraAddress + cb > pThis->cbVBEExtraData)
     {
         *pu32 = 0;
         Log(("vbeIOPortReadVBEExtra: Requested address is out of VBE data!!! Address=%#x(%d) cbVBEExtraData=%#x(%d)\n",
-             pData->u16VBEExtraAddress, pData->u16VBEExtraAddress, pData->cbVBEExtraData, pData->cbVBEExtraData));
+             pThis->u16VBEExtraAddress, pThis->u16VBEExtraAddress, pThis->cbVBEExtraData, pThis->cbVBEExtraData));
         return VINF_SUCCESS;
     }
@@ -3722 +3722 @@
     if (cb == 1)
     {
-        *pu32 = pData->pu8VBEExtraData[pData->u16VBEExtraAddress] & 0xFF;
+        *pu32 = pThis->pu8VBEExtraData[pThis->u16VBEExtraAddress] & 0xFF;
 
         Log(("vbeIOPortReadVBEExtra: cb=%#x %.*Vhxs\n", cb, cb, pu32));
@@ -3730 +3730 @@
     if (cb == 2)
     {
-        *pu32 = pData->pu8VBEExtraData[pData->u16VBEExtraAddress]
-              | pData->pu8VBEExtraData[pData->u16VBEExtraAddress + 1] << 8;
+        *pu32 = pThis->pu8VBEExtraData[pThis->u16VBEExtraAddress]
+              | pThis->pu8VBEExtraData[pThis->u16VBEExtraAddress + 1] << 8;
 
         Log(("vbeIOPortReadVBEExtra: cb=%#x %.*Vhxs\n", cb, cb, pu32));
@@ -3747 +3747 @@
  * @returns VBox status code.
  *
- * @param   pData       The VGA instance data.
+ * @param   pThis       The VGA instance data.
  */
-static int vbeParseBitmap(PVGASTATE pData)
+static int vbeParseBitmap(PVGASTATE pThis)
 {
     uint16_t    i;
@@ -3760 +3760 @@
      * Get bitmap header data
      */
-    bmpInfo = (PBMPINFO)(pData->pu8Logo + sizeof(LOGOHDR));
-    pWinHdr = (PWINHDR)(pData->pu8Logo + sizeof(LOGOHDR) + sizeof(BMPINFO));
+    bmpInfo = (PBMPINFO)(pThis->pu8Logo + sizeof(LOGOHDR));
+    pWinHdr = (PWINHDR)(pThis->pu8Logo + sizeof(LOGOHDR) + sizeof(BMPINFO));
 
     if (bmpInfo->Type == BMP_ID)
@@ -3769 +3769 @@
             case BMP_HEADER_OS21:
                 pOs2Hdr = (POS2HDR)pWinHdr;
-                pData->cxLogo = pOs2Hdr->Width;
-                pData->cyLogo = pOs2Hdr->Height;
-                pData->cLogoPlanes = pOs2Hdr->Planes;
-                pData->cLogoBits = pOs2Hdr->BitCount;
-                pData->LogoCompression = BMP_COMPRESS_NONE;
-                pData->cLogoUsedColors = 0;
+                pThis->cxLogo = pOs2Hdr->Width;
+                pThis->cyLogo = pOs2Hdr->Height;
+                pThis->cLogoPlanes = pOs2Hdr->Planes;
+                pThis->cLogoBits = pOs2Hdr->BitCount;
+                pThis->LogoCompression = BMP_COMPRESS_NONE;
+                pThis->cLogoUsedColors = 0;
                 break;
 
             case BMP_HEADER_OS22:
                 pOs22Hdr = (POS22HDR)pWinHdr;
-                pData->cxLogo = pOs22Hdr->Width;
-                pData->cyLogo = pOs22Hdr->Height;
-                pData->cLogoPlanes = pOs22Hdr->Planes;
-                pData->cLogoBits = pOs22Hdr->BitCount;
-                pData->LogoCompression = pOs22Hdr->Compression;
-                pData->cLogoUsedColors = pOs22Hdr->ClrUsed;
+                pThis->cxLogo = pOs22Hdr->Width;
+                pThis->cyLogo = pOs22Hdr->Height;
+                pThis->cLogoPlanes = pOs22Hdr->Planes;
+                pThis->cLogoBits = pOs22Hdr->BitCount;
+                pThis->LogoCompression = pOs22Hdr->Compression;
+                pThis->cLogoUsedColors = pOs22Hdr->ClrUsed;
                 break;
 
             case BMP_HEADER_WIN3:
-                pData->cxLogo = pWinHdr->Width;
-                pData->cyLogo = pWinHdr->Height;
-                pData->cLogoPlanes = pWinHdr->Planes;
-                pData->cLogoBits = pWinHdr->BitCount;
-                pData->LogoCompression = pWinHdr->Compression;
-                pData->cLogoUsedColors = pWinHdr->ClrUsed;
+                pThis->cxLogo = pWinHdr->Width;
+                pThis->cyLogo = pWinHdr->Height;
+                pThis->cLogoPlanes = pWinHdr->Planes;
+                pThis->cLogoBits = pWinHdr->BitCount;
+                pThis->LogoCompression = pWinHdr->Compression;
+                pThis->cLogoUsedColors = pWinHdr->ClrUsed;
                 break;
 
@@ -3801 +3801 @@
         }
 
-        if (pData->cxLogo > LOGO_MAX_WIDTH || pData->cyLogo > LOGO_MAX_HEIGHT)
+        if (pThis->cxLogo > LOGO_MAX_WIDTH || pThis->cyLogo > LOGO_MAX_HEIGHT)
         {
-            AssertMsgFailed(("Bitmap %ux%u is too big.\n", pData->cxLogo, pData->cyLogo));
+            AssertMsgFailed(("Bitmap %ux%u is too big.\n", pThis->cxLogo, pThis->cyLogo));
             return VERR_INVALID_PARAMETER;
         }
 
-        if (pData->cLogoPlanes != 1)
+        if (pThis->cLogoPlanes != 1)
         {
-            AssertMsgFailed(("Bitmap planes %u != 1.\n", pData->cLogoPlanes));
+            AssertMsgFailed(("Bitmap planes %u != 1.\n", pThis->cLogoPlanes));
             return VERR_INVALID_PARAMETER;
         }
 
-        if (pData->cLogoBits != 4 && pData->cLogoBits != 8 && pData->cLogoBits != 24)
+        if (pThis->cLogoBits != 4 && pThis->cLogoBits != 8 && pThis->cLogoBits != 24)
         {
-            AssertMsgFailed(("Unsupported %u depth.\n", pData->cLogoBits));
+            AssertMsgFailed(("Unsupported %u depth.\n", pThis->cLogoBits));
             return VERR_INVALID_PARAMETER;
         }
 
-        if (pData->cLogoUsedColors > 256)
+        if (pThis->cLogoUsedColors > 256)
         {
-            AssertMsgFailed(("Unsupported %u colors.\n", pData->cLogoUsedColors));
+            AssertMsgFailed(("Unsupported %u colors.\n", pThis->cLogoUsedColors));
             return VERR_INVALID_PARAMETER;
         }
 
-        if (pData->LogoCompression != BMP_COMPRESS_NONE)
+        if (pThis->LogoCompression != BMP_COMPRESS_NONE)
         {
-            AssertMsgFailed(("Unsupported %u compression.\n", pData->LogoCompression));
+            AssertMsgFailed(("Unsupported %u compression.\n", pThis->LogoCompression));
             return VERR_INVALID_PARAMETER;
         }
@@ -3834 +3834 @@
          * Read bitmap palette
          */
-        if (!pData->cLogoUsedColors)
-            pData->cLogoPalEntries = 1 << (pData->cLogoPlanes * pData->cLogoBits);
+        if (!pThis->cLogoUsedColors)
+            pThis->cLogoPalEntries = 1 << (pThis->cLogoPlanes * pThis->cLogoBits);
         else
-            pData->cLogoPalEntries = pData->cLogoUsedColors;
-
-        if (pData->cLogoPalEntries)
+            pThis->cLogoPalEntries = pThis->cLogoUsedColors;
+
+        if (pThis->cLogoPalEntries)
         {
-            const uint8_t *pu8Pal = pData->pu8Logo + sizeof(LOGOHDR) + sizeof(BMPINFO) + pWinHdr->Size; /* ASSUMES Size location (safe) */
-
-            for (i = 0; i < pData->cLogoPalEntries; i++)
+            const uint8_t *pu8Pal = pThis->pu8Logo + sizeof(LOGOHDR) + sizeof(BMPINFO) + pWinHdr->Size; /* ASSUMES Size location (safe) */
+
+            for (i = 0; i < pThis->cLogoPalEntries; i++)
             {
                 uint16_t j;
@@ -3856 +3856 @@
 
                 pu8Pal++; /* skip unused byte */
-                pData->au32LogoPalette[i] = u32Pal;
+                pThis->au32LogoPalette[i] = u32Pal;
             }
         }
@@ -3863 +3863 @@
          * Bitmap data offset
          */
-        pData->pu8LogoBitmap = pData->pu8Logo + sizeof(LOGOHDR) + bmpInfo->Offset;
+        pThis->pu8LogoBitmap = pThis->pu8Logo + sizeof(LOGOHDR) + bmpInfo->Offset;
     }
 
@@ -4020 +4020 @@
 PDMBOTHCBDECL(int) vbeIOPortWriteCMDLogo(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     NOREF(pvUser);
     NOREF(Port);
@@ -4032 +4032 @@
         {
             case LOGO_CMD_SET_OFFSET:
-                pData->offLogoData = u32 & 0xFF;
+                pThis->offLogoData = u32 & 0xFF;
                 break;
 
@@ -4038 +4038 @@
             {
                 uint8_t         iStep = u32 & 0xFF;
-                const uint8_t  *pu8Src = pData->pu8LogoBitmap;
+                const uint8_t  *pu8Src = pThis->pu8LogoBitmap;
                 uint8_t        *pu8Dst;
-                PLOGOHDR        pLogoHdr = (PLOGOHDR)pData->pu8Logo;
+                PLOGOHDR        pLogoHdr = (PLOGOHDR)pThis->pu8Logo;
                 uint32_t        offDirty = 0;
-                uint16_t        xLogo = (LOGO_MAX_WIDTH - pData->cxLogo) / 2;
-                uint16_t        yLogo = LOGO_MAX_HEIGHT - (LOGO_MAX_HEIGHT - pData->cyLogo) / 2;
+                uint16_t        xLogo = (LOGO_MAX_WIDTH - pThis->cxLogo) / 2;
+                uint16_t        yLogo = LOGO_MAX_HEIGHT - (LOGO_MAX_HEIGHT - pThis->cyLogo) / 2;
 
                 /* Check VRAM size */
-                if (pData->vram_size < LOGO_MAX_SIZE)
+                if (pThis->vram_size < LOGO_MAX_SIZE)
                     break;
 
-                if (pData->vram_size >= LOGO_MAX_SIZE * 2)
-                    pu8Dst = pData->vram_ptrR3 + LOGO_MAX_SIZE;
+                if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
+                    pu8Dst = pThis->vram_ptrR3 + LOGO_MAX_SIZE;
                 else
-                    pu8Dst = pData->vram_ptrR3;
+                    pu8Dst = pThis->vram_ptrR3;
 
                 /* Clear screen - except on power on... */
-                if (!pData->fLogoClearScreen)
+                if (!pThis->fLogoClearScreen)
                 {
                     uint32_t *pu32TmpPtr = (uint32_t *)pu8Dst;
@@ -4065 +4065 @@
                             *pu32TmpPtr++ = 0;
                     }
-                    pData->fLogoClearScreen = true;
+                    pThis->fLogoClearScreen = true;
                 }
 
                 /* Show the bitmap. */
-                vbeShowBitmap(pData->cLogoBits, xLogo, yLogo,
-                              pData->cxLogo, pData->cyLogo,
-                              iStep, &pData->au32LogoPalette[0],
+                vbeShowBitmap(pThis->cLogoBits, xLogo, yLogo,
+                              pThis->cxLogo, pThis->cyLogo,
+                              iStep, &pThis->au32LogoPalette[0],
                               pu8Src, pu8Dst);
 
@@ -4078 +4078 @@
                     vbeShowBitmap(1, LOGO_F12TEXT_X, LOGO_F12TEXT_Y,
                                   LOGO_F12TEXT_WIDTH, LOGO_F12TEXT_HEIGHT,
-                                  iStep, &pData->au32LogoPalette[0],
+                                  iStep, &pThis->au32LogoPalette[0],
                                   &g_abLogoF12BootText[0], pu8Dst);
 
                 /* Blit the offscreen buffer. */
-                if (pData->vram_size >= LOGO_MAX_SIZE * 2)
+                if (pThis->vram_size >= LOGO_MAX_SIZE * 2)
                 {
-                    uint32_t *pu32TmpDst = (uint32_t *)pData->vram_ptrR3;
-                    uint32_t *pu32TmpSrc = (uint32_t *)(pData->vram_ptrR3 + LOGO_MAX_SIZE);
+                    uint32_t *pu32TmpDst = (uint32_t *)pThis->vram_ptrR3;
+                    uint32_t *pu32TmpSrc = (uint32_t *)(pThis->vram_ptrR3 + LOGO_MAX_SIZE);
                     for (int i = 0; i < LOGO_MAX_WIDTH; i++)
                     {
@@ -4096 +4096 @@
                 while (offDirty <= LOGO_MAX_SIZE)
                 {
-                    vga_set_dirty(pData, offDirty);
+                    vga_set_dirty(pThis, offDirty);
                     offDirty += PAGE_SIZE;
                 }
@@ -4104 +4104 @@
             default:
                 Log(("vbeIOPortWriteCMDLogo: invalid command %d\n", u32));
-                pData->LogoCommand = LOGO_CMD_NOP;
+                pThis->LogoCommand = LOGO_CMD_NOP;
                 break;
         }
@@ -4129 +4129 @@
 PDMBOTHCBDECL(int) vbeIOPortReadCMDLogo(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     NOREF(pvUser);
     NOREF(Port);
@@ -4135 +4135 @@
     PRTUINT64U  p;
 
-    if (pData->offLogoData + cb > pData->cbLogo)
+    if (pThis->offLogoData + cb > pThis->cbLogo)
     {
         Log(("vbeIOPortReadCMDLogo: Requested address is out of Logo data!!! offLogoData=%#x(%d) cbLogo=%#x(%d)\n",
-             pData->offLogoData, pData->offLogoData, pData->cbLogo, pData->cbLogo));
+             pThis->offLogoData, pThis->offLogoData, pThis->cbLogo, pThis->cbLogo));
         return VINF_SUCCESS;
     }
-    p = (PRTUINT64U)&pData->pu8Logo[pData->offLogoData];
+    p = (PRTUINT64U)&pThis->pu8Logo[pThis->offLogoData];
 
     switch (cb)
@@ -4151 +4151 @@
         default: AssertFailed(); break;
     }
-    Log(("vbeIOPortReadCMDLogo: LogoOffset=%#x(%d) cb=%#x %.*Vhxs\n", pData->offLogoData, pData->offLogoData, cb, cb, pu32));
-
-    pData->LogoCommand = LOGO_CMD_NOP;
-    pData->offLogoData += cb;
+    Log(("vbeIOPortReadCMDLogo: LogoOffset=%#x(%d) cb=%#x %.*Vhxs\n", pThis->offLogoData, pThis->offLogoData, cb, cb, pu32));
+
+    pThis->LogoCommand = LOGO_CMD_NOP;
+    pThis->offLogoData += cb;
 
     return VINF_SUCCESS;
@@ -4245 +4245 @@
 static DECLCALLBACK(void *) vgaPortQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    PVGASTATE pData = (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, Base));
+    PVGASTATE pThis = (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, Base));
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->Base;
+            return &pThis->Base;
         case PDMINTERFACE_DISPLAY_PORT:
-            return &pData->Port;
+            return &pThis->Port;
         default:
             return NULL;
@@ -4323 +4323 @@
 static DECLCALLBACK(int) vgaPortUpdateDisplay(PPDMIDISPLAYPORT pInterface)
 {
-    PVGASTATE pData = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pData));
+    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
+    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
 
 #ifdef DEBUG_sunlover
@@ -4332 +4332 @@
     /* This should be called only in non VBVA mode. */
 
-    int rc = vga_update_display(pData);
+    int rc = vga_update_display(pThis);
     if (rc != VINF_SUCCESS)
         return rc;
 
-    if (pData->fHaveDirtyBits && pData->GCPhysVRAM && pData->GCPhysVRAM != NIL_RTGCPHYS32)
-    {
-        PPDMDEVINS pDevIns = pData->CTX_SUFF(pDevIns);
-        PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pData->GCPhysVRAM);
-        pData->fHaveDirtyBits = false;
+    if (pThis->fHaveDirtyBits && pThis->GCPhysVRAM && pThis->GCPhysVRAM != NIL_RTGCPHYS32)
+    {
+        PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+        PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
+        pThis->fHaveDirtyBits = false;
     }
 
@@ -4355 +4355 @@
 static DECLCALLBACK(int) vgaPortUpdateDisplayAll(PPDMIDISPLAYPORT pInterface)
 {
-    PVGASTATE pData = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pData));
+    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
+    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
 
     /* This is called both in VBVA mode and normal modes. */
@@ -4364 +4364 @@
 #endif /* DEBUG_sunlover */
 
-    pData->graphic_mode = -1; /* force full update */
-
-    int rc = vga_update_display(pData);
+    pThis->graphic_mode = -1; /* force full update */
+
+    int rc = vga_update_display(pThis);
 
     /* The dirty bits array has been just cleared, reset handlers as well. */
-    if (pData->GCPhysVRAM && pData->GCPhysVRAM != NIL_RTGCPHYS32)
-    {
-        PPDMDEVINS pDevIns = pData->CTX_SUFF(pDevIns);
-        PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pData->GCPhysVRAM);
+    if (pThis->GCPhysVRAM && pThis->GCPhysVRAM != NIL_RTGCPHYS32)
+    {
+        PPDMDEVINS pDevIns = pThis->CTX_SUFF(pDevIns);
+        PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
     }
 
@@ -4389 +4389 @@
 static DECLCALLBACK(int) vgaPortSetRefreshRate(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval)
 {
-    PVGASTATE pData = IDISPLAYPORT_2_VGASTATE(pInterface);
-
-    pData->cMilliesRefreshInterval = cMilliesInterval;
+    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
+
+    pThis->cMilliesRefreshInterval = cMilliesInterval;
     if (cMilliesInterval)
-        return TMTimerSetMillies(pData->RefreshTimer, cMilliesInterval);
-    return TMTimerStop(pData->RefreshTimer);
+        return TMTimerSetMillies(pThis->RefreshTimer, cMilliesInterval);
+    return TMTimerStop(pThis->RefreshTimer);
 }
 
@@ -4401 +4401 @@
 static DECLCALLBACK(int) vgaPortQueryColorDepth(PPDMIDISPLAYPORT pInterface, uint32_t *pcBits)
 {
-    PVGASTATE pData = IDISPLAYPORT_2_VGASTATE(pInterface);
+    PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
 
     if (!pcBits)
         return VERR_INVALID_PARAMETER;
-    *pcBits = vga_get_bpp(pData);
+    *pcBits = vga_get_bpp(pThis);
     return VINF_SUCCESS;
 }
@@ -4428 +4428 @@
     uint32_t                fRenderVRAM;
     size_t                  cbRequired;
-    PVGASTATE               pData = IDISPLAYPORT_2_VGASTATE(pInterface);
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pData));
+    PVGASTATE               pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
+    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
     LogFlow(("vgaPortSnapshot: pvData=%p cbData=%d pcx=%p pcy=%p pcbData=%p\n", pvData, cbData, pcx, pcy, pcbData));
 
@@ -4451 +4451 @@
      * Validate the buffer size.
      */
-    cbRequired = RT_ALIGN_Z(pData->last_scr_width, 4) * pData->last_scr_height * 4;
+    cbRequired = RT_ALIGN_Z(pThis->last_scr_width, 4) * pThis->last_scr_height * 4;
     if (cbRequired > cbData)
     {
@@ -4463 +4463 @@
     Connector.pu8Data       = (uint8_t*)pvData;
     Connector.cBits         = 32;
-    Connector.cx            = pData->pDrv->cx;
-    Connector.cy            = pData->pDrv->cy;
+    Connector.cx            = pThis->pDrv->cx;
+    Connector.cy            = pThis->pDrv->cy;
     Connector.cbScanline    = RT_ALIGN_32(Connector.cx, 4) * 4;
     Connector.pfnRefresh    = vgaDummyRefresh;
@@ -4471 +4471 @@
 
     /* save & replace state data. */
-    pConnector = pData->pDrv;
-    pData->pDrv = &Connector;
-    graphic_mode = pData->graphic_mode;
-    pData->graphic_mode = -1;           /* force a full refresh. */
-    fRenderVRAM = pData->fRenderVRAM;
-    pData->fRenderVRAM = 1;             /* force the guest VRAM rendering to the given buffer. */
+    pConnector = pThis->pDrv;
+    pThis->pDrv = &Connector;
+    graphic_mode = pThis->graphic_mode;
+    pThis->graphic_mode = -1;           /* force a full refresh. */
+    fRenderVRAM = pThis->fRenderVRAM;
+    pThis->fRenderVRAM = 1;             /* force the guest VRAM rendering to the given buffer. */
 
     /* make the snapshot. */
-    int rc = vga_update_display(pData);
+    int rc = vga_update_display(pThis);
 
     /* restore */
-    pData->pDrv = pConnector;
-    pData->graphic_mode = graphic_mode;
-    pData->fRenderVRAM = fRenderVRAM;
+    pThis->pDrv = pConnector;
+    pThis->graphic_mode = graphic_mode;
+    pThis->fRenderVRAM = fRenderVRAM;
 
     if (rc != VINF_SUCCESS)
@@ -4516 +4516 @@
 static DECLCALLBACK(int) vgaPortDisplayBlt(PPDMIDISPLAYPORT pInterface, const void *pvData, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
 {
-    PVGASTATE       pData = IDISPLAYPORT_2_VGASTATE(pInterface);
+    PVGASTATE       pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
     int             rc = VINF_SUCCESS;
-    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pData));
+    PDMDEV_ASSERT_EMT(VGASTATE2DEVINS(pThis));
     LogFlow(("vgaPortDisplayBlt: pvData=%p x=%d y=%d cx=%d cy=%d\n", pvData, x, y, cx, cy));
 
@@ -4525 +4525 @@
      */
     if (    pvData
-        &&  x      <  pData->pDrv->cx
-        &&  cx     <= pData->pDrv->cx
-        &&  cx + x <= pData->pDrv->cx
-        &&  y      <  pData->pDrv->cy
-        &&  cy     <= pData->pDrv->cy
-        &&  cy + y <= pData->pDrv->cy)
+        &&  x      <  pThis->pDrv->cx
+        &&  cx     <= pThis->pDrv->cx
+        &&  cx + x <= pThis->pDrv->cx
+        &&  y      <  pThis->pDrv->cy
+        &&  cy     <= pThis->pDrv->cy
+        &&  cy + y <= pThis->pDrv->cy)
     {
         /*
@@ -4536 +4536 @@
          */
         size_t  cbPixelDst = 0;
-        switch (pData->pDrv->cBits)
+        switch (pThis->pDrv->cBits)
         {
             case 8:
@@ -4562 +4562 @@
             size_t      cbLineSrc   = RT_ALIGN_Z(cx, 4) * 4;
             uint8_t    *pu8Src      = (uint8_t *)pvData;
-            size_t      cbLineDst   = pData->pDrv->cbScanline;
-            uint8_t    *pu8Dst      = pData->pDrv->pu8Data + y * cbLineDst + x * cbPixelDst;
+            size_t      cbLineDst   = pThis->pDrv->cbScanline;
+            uint8_t    *pu8Dst      = pThis->pDrv->pu8Data + y * cbLineDst + x * cbPixelDst;
             uint32_t    cyLeft      = cy;
-            vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[VGA_DRAW_LINE32 * 4 + get_depth_index(pData->pDrv->cBits)];
+            vga_draw_line_func *pfnVgaDrawLine = vga_draw_line_table[VGA_DRAW_LINE32 * 4 + get_depth_index(pThis->pDrv->cBits)];
             Assert(pfnVgaDrawLine);
             while (cyLeft-- > 0)
             {
-                pfnVgaDrawLine(pData, pu8Dst, pu8Src, cx);
+                pfnVgaDrawLine(pThis, pu8Dst, pu8Src, cx);
                 pu8Dst += cbLineDst;
                 pu8Src += cbLineSrc;
@@ -4577 +4577 @@
              * Invalidate the area.
              */
-            pData->pDrv->pfnUpdateRect(pData->pDrv, x, y, cx, cy);
+            pThis->pDrv->pfnUpdateRect(pThis->pDrv, x, y, cx, cy);
         }
     }
@@ -4750 +4750 @@
 static DECLCALLBACK(void) vgaTimerRefresh(PPDMDEVINS pDevIns, PTMTIMER pTimer)
 {
-    PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
-    if (pData->pDrv)
-        pData->pDrv->pfnRefresh(pData->pDrv);
-    if (pData->cMilliesRefreshInterval)
-        TMTimerSetMillies(pTimer, pData->cMilliesRefreshInterval);
+    PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    if (pThis->pDrv)
+        pThis->pDrv->pfnRefresh(pThis->pDrv);
+    if (pThis->cMilliesRefreshInterval)
+        TMTimerSetMillies(pTimer, pThis->cMilliesRefreshInterval);
 }
 
@@ -4775 +4775 @@
     int         rc;
     PPDMDEVINS  pDevIns = pPciDev->pDevIns;
-    PVGASTATE   pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     LogFlow(("vgaR3IORegionMap: iRegion=%d GCPhysAddress=%VGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
     AssertReturn(iRegion == 0 && enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
@@ -4790 +4790 @@
             rc = PGMR3HandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
                                               PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
-                                              GCPhysAddress, GCPhysAddress + (pData->vram_size - 1),
-                                              vgaR3LFBAccessHandler, pData,
+                                              GCPhysAddress, GCPhysAddress + (pThis->vram_size - 1),
+                                              vgaR3LFBAccessHandler, pThis,
                                               g_DeviceVga.szR0Mod, "vgaR0LFBAccessHandler", pDevIns->pvInstanceDataR0,
                                               g_DeviceVga.szGCMod, "vgaGCLFBAccessHandler", pDevIns->pvInstanceDataGC,
@@ -4797 +4797 @@
             AssertRC(rc);
             if (RT_SUCCESS(rc))
-                pData->GCPhysVRAM = GCPhysAddress;
+                pThis->GCPhysVRAM = GCPhysAddress;
         }
     }
@@ -4806 +4806 @@
          * Deregister the access handler so PGM doesn't get upset.
          */
-        Assert(pData->GCPhysVRAM);
-        rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pData->GCPhysVRAM);
+        Assert(pThis->GCPhysVRAM);
+        rc = PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
         AssertRC(rc);
-        pData->GCPhysVRAM = 0;
+        pThis->GCPhysVRAM = 0;
     }
     return rc;
@@ -4857 +4857 @@
 static DECLCALLBACK(void)  vgaR3Reset(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE       pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     char           *pchStart;
     char           *pchEnd;
@@ -4863 +4863 @@
 
     /* Clear the VRAM ourselves. */
-    if (pData->vram_ptrR3 && pData->vram_size)
+    if (pThis->vram_ptrR3 && pThis->vram_size)
     {
 #ifdef LOG_ENABLED /** @todo separate function. */
         /* First dump the textmode contents to the log; handy for capturing Windows blue screens. */
         uint8_t graphic_mode;
-        VGAState *s = pData;
+        VGAState *s = pThis;
 
         if (!(s->ar_index & 0x20)) {
@@ -4940 +4940 @@
 
 #endif /* LOG_ENABLED */
-        memset(pData->vram_ptrR3, 0, pData->vram_size);
+        memset(pThis->vram_ptrR3, 0, pThis->vram_size);
     }
 
@@ -4950 +4950 @@
      */
     /* 1st part. */
-    pchStart = (char *)&pData->latch;
-    pchEnd   = (char *)&pData->invalidated_y_table;
+    pchStart = (char *)&pThis->latch;
+    pchEnd   = (char *)&pThis->invalidated_y_table;
     memset(pchStart, 0, pchEnd - pchStart);
 
     /* 2nd part. */
-    pchStart = (char *)&pData->last_palette;
-    pchEnd   = (char *)&pData->u32Marker;
+    pchStart = (char *)&pThis->last_palette;
+    pchEnd   = (char *)&pThis->u32Marker;
     memset(pchStart, 0, pchEnd - pchStart);
 
@@ -4963 +4963 @@
      * Restore and re-init some bits.
      */
-    pData->get_bpp        = vga_get_bpp;
-    pData->get_offsets    = vga_get_offsets;
-    pData->get_resolution = vga_get_resolution;
-    pData->graphic_mode   = -1;         /* Force full update. */
+    pThis->get_bpp        = vga_get_bpp;
+    pThis->get_offsets    = vga_get_offsets;
+    pThis->get_resolution = vga_get_resolution;
+    pThis->graphic_mode   = -1;         /* Force full update. */
 #ifdef CONFIG_BOCHS_VBE
-    pData->vbe_regs[VBE_DISPI_INDEX_ID] = VBE_DISPI_ID0;
-    pData->vbe_regs[VBE_DISPI_INDEX_VBOX_VIDEO] = 0;
-    pData->vbe_bank_mask    = ((pData->vram_size >> 16) - 1);
+    pThis->vbe_regs[VBE_DISPI_INDEX_ID] = VBE_DISPI_ID0;
+    pThis->vbe_regs[VBE_DISPI_INDEX_VBOX_VIDEO] = 0;
+    pThis->vbe_bank_mask    = ((pThis->vram_size >> 16) - 1);
 #endif /* CONFIG_BOCHS_VBE */
 
@@ -4976 +4976 @@
      * Reset the LBF mapping.
      */
-    pData->fLFBUpdated = false;
-    if (    (   pData->fGCEnabled
-             || pData->fR0Enabled)
-        &&  pData->GCPhysVRAM
-        &&  pData->GCPhysVRAM != NIL_RTGCPHYS32)
-    {
-        int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pData->GCPhysVRAM);
+    pThis->fLFBUpdated = false;
+    if (    (   pThis->fGCEnabled
+             || pThis->fR0Enabled)
+        &&  pThis->GCPhysVRAM
+        &&  pThis->GCPhysVRAM != NIL_RTGCPHYS32)
+    {
+        int rc = PGMHandlerPhysicalReset(PDMDevHlpGetVM(pDevIns), pThis->GCPhysVRAM);
         AssertRC(rc);
     }
@@ -4989 +4989 @@
      * Reset the logo data.
      */
-    pData->LogoCommand = LOGO_CMD_NOP;
-    pData->offLogoData = 0;
+    pThis->LogoCommand = LOGO_CMD_NOP;
+    pThis->offLogoData = 0;
 
     /* notify port handler */
-    if (pData->pDrv)
-        pData->pDrv->pfnReset(pData->pDrv);
+    if (pThis->pDrv)
+        pThis->pDrv->pfnReset(pThis->pDrv);
 }
 
@@ -5010 +5010 @@
     if (offDelta)
     {
-        PVGASTATE pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+        PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
         LogFlow(("vgaRelocate: offDelta = %08X\n", offDelta));
 
-        pData->RCPtrLFBHandler += offDelta;
-        pData->vram_ptrRC += offDelta;
-        pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+        pThis->RCPtrLFBHandler += offDelta;
+        pThis->vram_ptrRC += offDelta;
+        pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     }
 }
@@ -5035 +5035 @@
 static DECLCALLBACK(int)  vgaAttach(PPDMDEVINS pDevIns, unsigned iLUN)
 {
-    PVGASTATE   pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     switch (iLUN)
     {
@@ -5041 +5041 @@
         case 0:
         {
-            int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pData->Base, &pData->pDrvBase, "Display Port");
+            int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Base, &pThis->pDrvBase, "Display Port");
             if (RT_SUCCESS(rc))
             {
-                pData->pDrv = (PDMIDISPLAYCONNECTOR*)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_DISPLAY_CONNECTOR);
-                if (pData->pDrv)
+                pThis->pDrv = (PDMIDISPLAYCONNECTOR*)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_DISPLAY_CONNECTOR);
+                if (pThis->pDrv)
                 {
-                    /* pData->pDrv->pu8Data can be NULL when there is no framebuffer. */
-                    if (    pData->pDrv->pfnRefresh
-                        &&  pData->pDrv->pfnResize
-                        &&  pData->pDrv->pfnUpdateRect)
+                    /* pThis->pDrv->pu8Data can be NULL when there is no framebuffer. */
+                    if (    pThis->pDrv->pfnRefresh
+                        &&  pThis->pDrv->pfnResize
+                        &&  pThis->pDrv->pfnUpdateRect)
                         rc = VINF_SUCCESS;
                     else
                     {
-                        Assert(pData->pDrv->pfnRefresh);
-                        Assert(pData->pDrv->pfnResize);
-                        Assert(pData->pDrv->pfnUpdateRect);
-                        pData->pDrv = NULL;
-                        pData->pDrvBase = NULL;
+                        Assert(pThis->pDrv->pfnRefresh);
+                        Assert(pThis->pDrv->pfnResize);
+                        Assert(pThis->pDrv->pfnUpdateRect);
+                        pThis->pDrv = NULL;
+                        pThis->pDrvBase = NULL;
                         rc = VERR_INTERNAL_ERROR;
                     }
@@ -5065 +5065 @@
                 {
                     AssertMsgFailed(("LUN #0 doesn't have a display connector interface! rc=%Vrc\n", rc));
-                    pData->pDrvBase = NULL;
+                    pThis->pDrvBase = NULL;
                     rc = VERR_PDM_MISSING_INTERFACE;
                 }
@@ -5102 +5102 @@
      * Reset the interfaces and update the controller state.
      */
-    PVGASTATE   pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     switch (iLUN)
     {
         /* LUN #0: Display port. */
         case 0:
-            pData->pDrv = NULL;
-            pData->pDrvBase = NULL;
+            pThis->pDrv = NULL;
+            pThis->pDrvBase = NULL;
             break;
 
@@ -5138 +5138 @@
     int         rc;
     unsigned i;
-    PVGASTATE   pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     PVM         pVM = PDMDevHlpGetVM(pDevIns);
 #ifdef VBE_NEW_DYN_LIST
@@ -5194 +5194 @@
      * Init state data.
      */
-    rc = CFGMR3QueryU32Def(pCfgHandle, "VRamSize", &pData->vram_size, VGA_VRAM_DEFAULT);
+    rc = CFGMR3QueryU32Def(pCfgHandle, "VRamSize", &pThis->vram_size, VGA_VRAM_DEFAULT);
     AssertLogRelRCReturn(rc, rc);
-    if (pData->vram_size > VGA_VRAM_MAX)
+    if (pThis->vram_size > VGA_VRAM_MAX)
         return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
-                                   "VRamSize is too large, %#x, max %#x", pData->vram_size, VGA_VRAM_MAX);
-    if (pData->vram_size < VGA_VRAM_MIN)
+                                   "VRamSize is too large, %#x, max %#x", pThis->vram_size, VGA_VRAM_MAX);
+    if (pThis->vram_size < VGA_VRAM_MIN)
         return PDMDevHlpVMSetError(pDevIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
-                                   "VRamSize is too small, %#x, max %#x", pData->vram_size, VGA_VRAM_MIN);
+                                   "VRamSize is too small, %#x, max %#x", pThis->vram_size, VGA_VRAM_MIN);
 
     rc = CFGMR3QueryBoolDef(pCfgHandle, "GCEnabled", &f, true);
     AssertLogRelRCReturn(rc, rc);
-    Log(("VGA: fGCEnabled=%d\n", pData->fGCEnabled));
+    Log(("VGA: fGCEnabled=%d\n", pThis->fGCEnabled));
 
     rc = CFGMR3QueryBoolDef(pCfgHandle, "R0Enabled", &f, true);
     AssertLogRelRCReturn(rc, rc);
-    Log(("VGA: VRamSize=%#x fGCenabled=%RTbool fR0Enabled=%RTbool\n", pData->vram_size, pData->fGCEnabled, pData->fR0Enabled));
-
-    pData->pDevInsR3 = pDevIns;
-    pData->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    Log(("VGA: VRamSize=%#x fGCenabled=%RTbool fR0Enabled=%RTbool\n", pThis->vram_size, pThis->fGCEnabled, pThis->fR0Enabled));
+
+    pThis->pDevInsR3 = pDevIns;
+    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
 
     vgaR3Reset(pDevIns);
 
     /* The PCI devices configuration. */
-    PCIDevSetVendorId(  &pData->Dev, 0x80ee);   /* PCI vendor, just a free bogus value */
-    PCIDevSetDeviceId(  &pData->Dev, 0xbeef);
-    PCIDevSetClassSub(  &pData->Dev,   0x00);   /* VGA controller */
-    PCIDevSetClassBase( &pData->Dev,   0x03);
-    PCIDevSetHeaderType(&pData->Dev,   0x00);
+    PCIDevSetVendorId(  &pThis->Dev, 0x80ee);   /* PCI vendor, just a free bogus value */
+    PCIDevSetDeviceId(  &pThis->Dev, 0xbeef);
+    PCIDevSetClassSub(  &pThis->Dev,   0x00);   /* VGA controller */
+    PCIDevSetClassBase( &pThis->Dev,   0x03);
+    PCIDevSetHeaderType(&pThis->Dev,   0x00);
 
     /* The LBF access handler - error handling is better here than in the map function.  */
-    rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, "vgaGCLFBAccessHandler", &pData->RCPtrLFBHandler);
+    rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, "vgaGCLFBAccessHandler", &pThis->RCPtrLFBHandler);
     if (RT_FAILURE(rc))
     {
@@ -5233 +5233 @@
 
     /* the interfaces. */
-    pData->Base.pfnQueryInterface       = vgaPortQueryInterface;
-
-    pData->Port.pfnUpdateDisplay        = vgaPortUpdateDisplay;
-    pData->Port.pfnUpdateDisplayAll     = vgaPortUpdateDisplayAll;
-    pData->Port.pfnQueryColorDepth      = vgaPortQueryColorDepth;
-    pData->Port.pfnSetRefreshRate       = vgaPortSetRefreshRate;
-    pData->Port.pfnSnapshot             = vgaPortSnapshot;
-    pData->Port.pfnDisplayBlt           = vgaPortDisplayBlt;
-    pData->Port.pfnUpdateDisplayRect    = vgaPortUpdateDisplayRect;
-    pData->Port.pfnSetRenderVRAM        = vgaPortSetRenderVRAM;
+    pThis->Base.pfnQueryInterface       = vgaPortQueryInterface;
+
+    pThis->Port.pfnUpdateDisplay        = vgaPortUpdateDisplay;
+    pThis->Port.pfnUpdateDisplayAll     = vgaPortUpdateDisplayAll;
+    pThis->Port.pfnQueryColorDepth      = vgaPortQueryColorDepth;
+    pThis->Port.pfnSetRefreshRate       = vgaPortSetRefreshRate;
+    pThis->Port.pfnSnapshot             = vgaPortSnapshot;
+    pThis->Port.pfnDisplayBlt           = vgaPortDisplayBlt;
+    pThis->Port.pfnUpdateDisplayRect    = vgaPortUpdateDisplayRect;
+    pThis->Port.pfnSetRenderVRAM        = vgaPortSetRenderVRAM;
 
 
@@ -5248 +5248 @@
      * Allocate the VRAM and map the first 256KB of it into GC so we can speed up VGA support.
      */
-    rc = PDMDevHlpMMIO2Register(pDevIns, 0 /* iRegion */, pData->vram_size, 0, (void **)&pData->vram_ptrR3, "VRam");
-    AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMIO2Register(%#x,) -> %Rrc\n", pData->vram_size, rc), rc);
-    pData->vram_ptrR0 = (RTR0PTR)pData->vram_ptrR3; /** @todo #1865 Map parts into R0 or just use PGM access (Mac only). */
+    rc = PDMDevHlpMMIO2Register(pDevIns, 0 /* iRegion */, pThis->vram_size, 0, (void **)&pThis->vram_ptrR3, "VRam");
+    AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMIO2Register(%#x,) -> %Rrc\n", pThis->vram_size, rc), rc);
+    pThis->vram_ptrR0 = (RTR0PTR)pThis->vram_ptrR3; /** @todo #1865 Map parts into R0 or just use PGM access (Mac only). */
 
     RTRCPTR pRCMapping = 0;
     rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 0 /* iRegion */, 0 /* off */,  VGA_MAPPING_SIZE, "VGA VRam", &pRCMapping);
-    AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMHyperMapMMIO2(%#x,) -> %Rrc\n", pData->vram_size, rc), rc);
-    pData->vram_ptrRC = pRCMapping;
+    AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMHyperMapMMIO2(%#x,) -> %Rrc\n", pThis->vram_size, rc), rc);
+    pThis->vram_ptrRC = pRCMapping;
 
     /*
@@ -5297 +5297 @@
 
     /* guest context extension */
-    if (pData->fGCEnabled)
+    if (pThis->fGCEnabled)
     {
         rc = PDMDevHlpIOPortRegisterGC(pDevIns,  0x3c0, 16, 0, "vgaIOPortWrite",       "vgaIOPortRead", NULL, NULL,     "VGA - 3c0 (GC)");
@@ -5338 +5338 @@
 
     /* R0 context extension */
-    if (pData->fR0Enabled)
+    if (pThis->fR0Enabled)
     {
         rc = PDMDevHlpIOPortRegisterR0(pDevIns,  0x3c0, 16, 0, "vgaIOPortWrite",       "vgaIOPortRead", NULL, NULL,     "VGA - 3c0 (GC)");
@@ -5382 +5382 @@
     if (RT_FAILURE(rc))
         return rc;
-    if (pData->fGCEnabled)
+    if (pThis->fGCEnabled)
     {
         rc = PDMDevHlpMMIORegisterGC(pDevIns, 0x000a0000, 0x00020000, 0, "vgaMMIOWrite", "vgaMMIORead", "vgaMMIOFill");
@@ -5388 +5388 @@
             return rc;
     }
-    if (pData->fR0Enabled)
+    if (pThis->fR0Enabled)
     {
         rc = PDMDevHlpMMIORegisterR0(pDevIns, 0x000a0000, 0x00020000, 0, "vgaMMIOWrite", "vgaMMIORead", "vgaMMIOFill");
@@ -5407 +5407 @@
 
     /* save */
-    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pThis),
                                           NULL, vgaR3SaveExec, NULL,
                                           NULL, vgaR3LoadExec, NULL);
@@ -5414 +5414 @@
 
     /* PCI */
-    rc = PDMDevHlpPCIRegister(pDevIns, &pData->Dev);
+    rc = PDMDevHlpPCIRegister(pDevIns, &pThis->Dev);
     if (RT_FAILURE(rc))
         return rc;
-    /*AssertMsg(pData->Dev.devfn == 16 || iInstance != 0, ("pData->Dev.devfn=%d\n", pData->Dev.devfn));*/
-    if (pData->Dev.devfn != 16 && iInstance == 0)
-        Log(("!!WARNING!!: pData->dev.devfn=%d (ignore if testcase or not started by Main)\n", pData->Dev.devfn));
-
-    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0 /* iRegion */, pData->vram_size, PCI_ADDRESS_SPACE_MEM_PREFETCH, vgaR3IORegionMap);
+    /*AssertMsg(pThis->Dev.devfn == 16 || iInstance != 0, ("pThis->Dev.devfn=%d\n", pThis->Dev.devfn));*/
+    if (pThis->Dev.devfn != 16 && iInstance == 0)
+        Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or not started by Main)\n", pThis->Dev.devfn));
+
+    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0 /* iRegion */, pThis->vram_size, PCI_ADDRESS_SPACE_MEM_PREFETCH, vgaR3IORegionMap);
     if (RT_FAILURE(rc))
         return rc;
@@ -5428 +5428 @@
      * Create the refresh timer.
      */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh, "VGA Refresh Timer", &pData->RefreshTimer);
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, vgaTimerRefresh, "VGA Refresh Timer", &pThis->RefreshTimer);
     if (RT_FAILURE(rc))
         return rc;
@@ -5460 +5460 @@
      * Allocate and initialize buffer for the VBE BIOS Extra Data.
      */
-    pData->cbVBEExtraData = sizeof(VBEHEADER) + cb;
-    pData->pu8VBEExtraData = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, pData->cbVBEExtraData);
-    if (!pData->pu8VBEExtraData)
+    pThis->cbVBEExtraData = sizeof(VBEHEADER) + cb;
+    pThis->pu8VBEExtraData = (uint8_t *)PDMDevHlpMMHeapAllocZ(pDevIns, pThis->cbVBEExtraData);
+    if (!pThis->pu8VBEExtraData)
         return VERR_NO_MEMORY;
 
-    pVBEDataHdr = (PVBEHEADER)pData->pu8VBEExtraData;
+    pVBEDataHdr = (PVBEHEADER)pThis->pu8VBEExtraData;
     pVBEDataHdr->u16Signature = VBEHEADER_MAGIC;
     pVBEDataHdr->cbData = cb;
@@ -5484 +5484 @@
                 * mode_info_list[i].info.YResolution
                 * pixelWidth;
-        if (reqSize >= pData->vram_size)
+        if (reqSize >= pThis->vram_size)
             continue;
         *pCurMode = mode_info_list[i];
@@ -5514 +5514 @@
                 pixelWidth = (pDefMode->info.BitsPerPixel + 7) / 8;
             reqSize = pDefMode->info.XResolution * pDefMode->info.YResolution *  pixelWidth;
-            if (reqSize >= pData->vram_size)
+            if (reqSize >= pThis->vram_size)
                 continue;
             *pCurMode = *pDefMode;
@@ -5553 +5553 @@
                 }
 #ifdef VRAM_SIZE_FIX
-                if (cx * cy * cBits / 8 >= pData->vram_size)
+                if (cx * cy * cBits / 8 >= pThis->vram_size)
                 {
                     AssertMsgFailed(("Configuration error: custom video mode %dx%dx%dbits is too large for the virtual video memory of %dMb.  Please increase the video memory size.\n",
-                                     cx, cy, cBits, pData->vram_size / _1M));
+                                     cx, cy, cBits, pThis->vram_size / _1M));
                     return VERR_VGA_INVALID_CUSTOM_MODE;
                 }
@@ -5684 +5684 @@
      * Get the Logo file name.
      */
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "LogoFile", &pData->pszLogoFile);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "LogoFile", &pThis->pszLogoFile);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->pszLogoFile = NULL;
+        pThis->pszLogoFile = NULL;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Querying \"LogoFile\" as a string failed"));
-    else if (!*pData->pszLogoFile)
-    {
-        MMR3HeapFree(pData->pszLogoFile);
-        pData->pszLogoFile = NULL;
+    else if (!*pThis->pszLogoFile)
+    {
+        MMR3HeapFree(pThis->pszLogoFile);
+        pThis->pszLogoFile = NULL;
     }
 
@@ -5701 +5701 @@
     LogoHdr.cbLogo = g_cbVgaDefBiosLogo;
     RTFILE FileLogo = NIL_RTFILE;
-    if (pData->pszLogoFile)
-    {
-        rc = RTFileOpen(&FileLogo, pData->pszLogoFile,
+    if (pThis->pszLogoFile)
+    {
+        rc = RTFileOpen(&FileLogo, pThis->pszLogoFile,
                         RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
         if (RT_SUCCESS(rc))
@@ -5722 +5722 @@
              * Ignore failure and fall back to the default logo.
              */
-            LogRel(("vgaR3Construct: Failed to open logo file '%s', rc=%Vrc!\n", pData->pszLogoFile, rc));
+            LogRel(("vgaR3Construct: Failed to open logo file '%s', rc=%Vrc!\n", pThis->pszLogoFile, rc));
             if (FileLogo != NIL_RTFILE)
                 RTFileClose(FileLogo);
             FileLogo = NIL_RTFILE;
-            MMR3HeapFree(pData->pszLogoFile);
-            pData->pszLogoFile = NULL;
+            MMR3HeapFree(pThis->pszLogoFile);
+            pThis->pszLogoFile = NULL;
         }
     }
@@ -5734 +5734 @@
      * Disable graphic splash screen if it doesn't fit into VRAM.
      */
-    if (pData->vram_size < LOGO_MAX_SIZE)
+    if (pThis->vram_size < LOGO_MAX_SIZE)
         LogoHdr.fu8FadeIn = LogoHdr.fu8FadeOut = LogoHdr.u16LogoMillies = 0;
 
@@ -5741 +5741 @@
      * RT_MAX() is applied to let us fall back to default logo on read failure.
      */
-    pData->cbLogo = sizeof(LogoHdr) + LogoHdr.cbLogo;
-    pData->pu8Logo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, RT_MAX(pData->cbLogo, g_cbVgaDefBiosLogo + sizeof(LogoHdr)));
-    if (pData->pu8Logo)
+    pThis->cbLogo = sizeof(LogoHdr) + LogoHdr.cbLogo;
+    pThis->pu8Logo = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, RT_MAX(pThis->cbLogo, g_cbVgaDefBiosLogo + sizeof(LogoHdr)));
+    if (pThis->pu8Logo)
     {
         /*
          * Write the logo header.
          */
-        PLOGOHDR pLogoHdr = (PLOGOHDR)pData->pu8Logo;
+        PLOGOHDR pLogoHdr = (PLOGOHDR)pThis->pu8Logo;
         *pLogoHdr = LogoHdr;
 
@@ -5754 +5754 @@
          * Write the logo bitmap.
          */
-        if (pData->pszLogoFile)
+        if (pThis->pszLogoFile)
         {
             rc = RTFileRead(FileLogo, pLogoHdr + 1, LogoHdr.cbLogo, NULL);
@@ -5767 +5767 @@
             memcpy(pLogoHdr + 1, g_abVgaDefBiosLogo, LogoHdr.cbLogo);
 
-        rc = vbeParseBitmap(pData);
+        rc = vbeParseBitmap(pThis);
         if (RT_FAILURE(rc))
         {
@@ -5775 +5775 @@
         }
 
-        rc = vbeParseBitmap(pData);
+        rc = vbeParseBitmap(pThis);
         if (RT_FAILURE(rc))
             AssertReleaseMsgFailed(("Internal bitmap failed! vbeParseBitmap() -> %Vrc\n", rc));
@@ -5793 +5793 @@
      * Statistics.
      */
-    STAM_REG(pVM, &pData->StatGCMemoryRead,     STAMTYPE_PROFILE, "/Devices/VGA/GC/Memory/Read",         STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryRead() body.");
-    STAM_REG(pVM, &pData->StatGCMemoryWrite,    STAMTYPE_PROFILE, "/Devices/VGA/GC/Memory/Write",        STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryWrite() body.");
-    STAM_REG(pVM, &pData->StatGCIOPortRead,     STAMTYPE_PROFILE, "/Devices/VGA/GC/IOPort/Read",         STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCIOPortRead() body.");
-    STAM_REG(pVM, &pData->StatGCIOPortWrite,    STAMTYPE_PROFILE, "/Devices/VGA/GC/IOPort/Write",        STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCIOPortWrite() body.");
+    STAM_REG(pVM, &pThis->StatGCMemoryRead,     STAMTYPE_PROFILE, "/Devices/VGA/GC/Memory/Read",         STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryRead() body.");
+    STAM_REG(pVM, &pThis->StatGCMemoryWrite,    STAMTYPE_PROFILE, "/Devices/VGA/GC/Memory/Write",        STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCMemoryWrite() body.");
+    STAM_REG(pVM, &pThis->StatGCIOPortRead,     STAMTYPE_PROFILE, "/Devices/VGA/GC/IOPort/Read",         STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCIOPortRead() body.");
+    STAM_REG(pVM, &pThis->StatGCIOPortWrite,    STAMTYPE_PROFILE, "/Devices/VGA/GC/IOPort/Write",        STAMUNIT_TICKS_PER_CALL, "Profiling of the VGAGCIOPortWrite() body.");
 
     return rc;
@@ -5813 +5813 @@
 {
 #ifdef VBE_NEW_DYN_LIST
-    PVGASTATE   pData = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis = PDMINS_2_DATA(pDevIns, PVGASTATE);
     LogFlow(("vgaR3Destruct:\n"));
 
@@ -5819 +5819 @@
      * Free MM heap pointers.
      */
-    if (pData->pu8VBEExtraData)
-    {
-        MMR3HeapFree(pData->pu8VBEExtraData);
-        pData->pu8VBEExtraData = NULL;
+    if (pThis->pu8VBEExtraData)
+    {
+        MMR3HeapFree(pThis->pu8VBEExtraData);
+        pThis->pu8VBEExtraData = NULL;
     }
 #endif

trunk/src/VBox/Devices/Input/DevPS2.cpp

@@ -1427 +1427 @@
 static DECLCALLBACK(void *)  kbdKeyboardQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    KBDState *pData = (KBDState *)((uintptr_t)pInterface -  RT_OFFSETOF(KBDState, Keyboard.Base));
+    KBDState *pThis = (KBDState *)((uintptr_t)pInterface -  RT_OFFSETOF(KBDState, Keyboard.Base));
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->Keyboard.Base;
+            return &pThis->Keyboard.Base;
         case PDMINTERFACE_KEYBOARD_PORT:
-            return &pData->Keyboard.Port;
+            return &pThis->Keyboard.Port;
         default:
             return NULL;
@@ -1454 +1454 @@
 static DECLCALLBACK(int) kbdKeyboardPutEvent(PPDMIKEYBOARDPORT pInterface, uint8_t u8KeyCode)
 {
-    KBDState *pData = IKEYBOARDPORT_2_KBDSTATE(pInterface);
-    pc_kbd_put_keycode(pData, u8KeyCode);
+    KBDState *pThis = IKEYBOARDPORT_2_KBDSTATE(pInterface);
+    pc_kbd_put_keycode(pThis, u8KeyCode);
     return VINF_SUCCESS;
 }
@@ -1472 +1472 @@
 static DECLCALLBACK(void *)  kbdMouseQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    KBDState *pData = (KBDState *)((uintptr_t)pInterface -  RT_OFFSETOF(KBDState, Mouse.Base));
+    KBDState *pThis = (KBDState *)((uintptr_t)pInterface -  RT_OFFSETOF(KBDState, Mouse.Base));
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->Mouse.Base;
+            return &pThis->Mouse.Base;
         case PDMINTERFACE_MOUSE_PORT:
-            return &pData->Mouse.Port;
+            return &pThis->Mouse.Port;
         default:
             return NULL;
@@ -1502 +1502 @@
 static DECLCALLBACK(int) kbdMousePutEvent(PPDMIMOUSEPORT pInterface, int32_t i32DeltaX, int32_t i32DeltaY, int32_t i32DeltaZ, uint32_t fButtonStates)
 {
-    KBDState *pData = IMOUSEPORT_2_KBDSTATE(pInterface);
-    pc_kbd_mouse_event(pData, i32DeltaX, i32DeltaY, i32DeltaZ, fButtonStates);
+    KBDState *pThis = IMOUSEPORT_2_KBDSTATE(pInterface);
+    pc_kbd_mouse_event(pThis, i32DeltaX, i32DeltaY, i32DeltaZ, fButtonStates);
     return VINF_SUCCESS;
 }
@@ -1529 +1529 @@
 {
     int         rc;
-    KBDState   *pData = PDMINS_2_DATA(pDevIns, KBDState *);
+    KBDState   *pThis = PDMINS_2_DATA(pDevIns, KBDState *);
     switch (iLUN)
     {
         /* LUN #0: keyboard */
         case 0:
-            rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pData->Keyboard.Base, &pData->Keyboard.pDrvBase, "Keyboard Port");
+            rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Keyboard.Base, &pThis->Keyboard.pDrvBase, "Keyboard Port");
             if (RT_SUCCESS(rc))
             {
-                pData->Keyboard.pDrv = (PDMIKEYBOARDCONNECTOR*)(pData->Keyboard.pDrvBase->pfnQueryInterface(pData->Keyboard.pDrvBase, PDMINTERFACE_KEYBOARD_CONNECTOR));
-                if (!pData->Keyboard.pDrv)
+                pThis->Keyboard.pDrv = (PDMIKEYBOARDCONNECTOR*)(pThis->Keyboard.pDrvBase->pfnQueryInterface(pThis->Keyboard.pDrvBase, PDMINTERFACE_KEYBOARD_CONNECTOR));
+                if (!pThis->Keyboard.pDrv)
                 {
                     AssertLogRelMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Vrc\n", rc));
@@ -1555 +1555 @@
         /* LUN #1: aux/mouse */
         case 1:
-            rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pData->Mouse.Base, &pData->Mouse.pDrvBase, "Aux (Mouse) Port");
+            rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Mouse.Base, &pThis->Mouse.pDrvBase, "Aux (Mouse) Port");
             if (RT_SUCCESS(rc))
             {
-                pData->Mouse.pDrv = (PDMIMOUSECONNECTOR*)(pData->Mouse.pDrvBase->pfnQueryInterface(pData->Mouse.pDrvBase, PDMINTERFACE_MOUSE_CONNECTOR));
-                if (!pData->Mouse.pDrv)
+                pThis->Mouse.pDrv = (PDMIMOUSECONNECTOR*)(pThis->Mouse.pDrvBase->pfnQueryInterface(pThis->Mouse.pDrvBase, PDMINTERFACE_MOUSE_CONNECTOR));
+                if (!pThis->Mouse.pDrv)
                 {
                     AssertLogRelMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Vrc\n", rc));
@@ -1603 +1603 @@
      * Reset the interfaces and update the controller state.
      */
-    KBDState   *pData = PDMINS_2_DATA(pDevIns, KBDState *);
+    KBDState   *pThis = PDMINS_2_DATA(pDevIns, KBDState *);
     switch (iLUN)
     {
         /* LUN #0: keyboard */
         case 0:
-            pData->Keyboard.pDrv = NULL;
-            pData->Keyboard.pDrvBase = NULL;
+            pThis->Keyboard.pDrv = NULL;
+            pThis->Keyboard.pDrvBase = NULL;
             break;
 
         /* LUN #1: aux/mouse */
         case 1:
-            pData->Mouse.pDrv = NULL;
-            pData->Mouse.pDrvBase = NULL;
+            pThis->Mouse.pDrv = NULL;
+            pThis->Mouse.pDrvBase = NULL;
             break;
 
@@ -1630 +1630 @@
 static DECLCALLBACK(void) kdbRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    KBDState   *pData = PDMINS_2_DATA(pDevIns, KBDState *);
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    KBDState   *pThis = PDMINS_2_DATA(pDevIns, KBDState *);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
 }
 
@@ -1650 +1650 @@
 static DECLCALLBACK(int) kbdConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    KBDState   *pData = PDMINS_2_DATA(pDevIns, KBDState *);
+    KBDState   *pThis = PDMINS_2_DATA(pDevIns, KBDState *);
     int         rc;
     bool        fGCEnabled;
@@ -1673 +1673 @@
      * Initialize the interfaces.
      */
-    pData->pDevInsR3 = pDevIns;
-    pData->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->Keyboard.Base.pfnQueryInterface  = kbdKeyboardQueryInterface;
-    pData->Keyboard.Port.pfnPutEvent        = kbdKeyboardPutEvent;
-
-    pData->Mouse.Base.pfnQueryInterface     = kbdMouseQueryInterface;
-    pData->Mouse.Port.pfnPutEvent           = kbdMousePutEvent;
+    pThis->pDevInsR3 = pDevIns;
+    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->Keyboard.Base.pfnQueryInterface  = kbdKeyboardQueryInterface;
+    pThis->Keyboard.Port.pfnPutEvent        = kbdKeyboardPutEvent;
+
+    pThis->Mouse.Base.pfnQueryInterface     = kbdMouseQueryInterface;
+    pThis->Mouse.Port.pfnPutEvent           = kbdMousePutEvent;
 
     /*
@@ -1709 +1709 @@
             return rc;
     }
-    rc = PDMDevHlpSSMRegister(pDevIns, g_DevicePS2KeyboardMouse.szDeviceName, iInstance, PCKBD_SAVED_STATE_VERSION, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, g_DevicePS2KeyboardMouse.szDeviceName, iInstance, PCKBD_SAVED_STATE_VERSION, sizeof(*pThis),
                               NULL, kbdSaveExec, NULL,
                               NULL, kbdLoadExec, NULL);

trunk/src/VBox/Devices/Input/DrvKeyboardQueue.cpp

@@ -164 +164 @@
 static DECLCALLBACK(bool) drvKbdQueueConsumer(PPDMDRVINS pDrvIns, PPDMQUEUEITEMCORE pItemCore)
 {
-    PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
     PDRVKBDQUEUEITEM    pItem = (PDRVKBDQUEUEITEM)pItemCore;
-    int rc = pData->pUpPort->pfnPutEvent(pData->pUpPort, pItem->u8KeyCode);
+    int rc = pThis->pUpPort->pfnPutEvent(pThis->pUpPort, pItem->u8KeyCode);
     return RT_SUCCESS(rc);
 }
@@ -181 +181 @@
 static DECLCALLBACK(void) drvKbdQueuePowerOn(PPDMDRVINS pDrvIns)
 {
-    PDRVKBDQUEUE    pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
-    pData->fInactive = false;
+    PDRVKBDQUEUE    pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    pThis->fInactive = false;
 }
 
@@ -194 +194 @@
 static DECLCALLBACK(void)  drvKbdQueueReset(PPDMDRVINS pDrvIns)
 {
-    //PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    //PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
     /** @todo purge the queue on reset. */
 }
@@ -207 +207 @@
 static DECLCALLBACK(void)  drvKbdQueueSuspend(PPDMDRVINS pDrvIns)
 {
-    PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
-    pData->fInactive = true;
+    PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    pThis->fInactive = true;
 }
 
@@ -220 +220 @@
 static DECLCALLBACK(void)  drvKbdQueueResume(PPDMDRVINS pDrvIns)
 {
-    PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
-    pData->fInactive = false;
+    PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    pThis->fInactive = false;
 }
 
@@ -232 +232 @@
 static DECLCALLBACK(void) drvKbdQueuePowerOff(PPDMDRVINS pDrvIns)
 {
-    PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
-    pData->fInactive = true;
+    PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    pThis->fInactive = true;
 }
 

trunk/src/VBox/Devices/Input/DrvMouseQueue.cpp

@@ -152 +152 @@
 static DECLCALLBACK(bool) drvMouseQueueConsumer(PPDMDRVINS pDrvIns, PPDMQUEUEITEMCORE pItemCore)
 {
-    PDRVMOUSEQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
+    PDRVMOUSEQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
     PDRVMOUSEQUEUEITEM    pItem = (PDRVMOUSEQUEUEITEM)pItemCore;
-    int rc = pData->pUpPort->pfnPutEvent(pData->pUpPort, pItem->i32DeltaX, pItem->i32DeltaY, pItem->i32DeltaZ, pItem->fButtonStates);
+    int rc = pThis->pUpPort->pfnPutEvent(pThis->pUpPort, pItem->i32DeltaX, pItem->i32DeltaY, pItem->i32DeltaZ, pItem->fButtonStates);
     return RT_SUCCESS(rc);
 }
@@ -169 +169 @@
 static DECLCALLBACK(void) drvMouseQueuePowerOn(PPDMDRVINS pDrvIns)
 {
-    PDRVMOUSEQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
-    pData->fInactive = false;
+    PDRVMOUSEQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
+    pThis->fInactive = false;
 }
 
@@ -182 +182 @@
 static DECLCALLBACK(void)  drvMouseQueueReset(PPDMDRVINS pDrvIns)
 {
-    //PDRVKBDQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
+    //PDRVKBDQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
     /** @todo purge the queue on reset. */
 }
@@ -195 +195 @@
 static DECLCALLBACK(void)  drvMouseQueueSuspend(PPDMDRVINS pDrvIns)
 {
-    PDRVMOUSEQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
-    pData->fInactive = true;
+    PDRVMOUSEQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
+    pThis->fInactive = true;
 }
 
@@ -208 +208 @@
 static DECLCALLBACK(void)  drvMouseQueueResume(PPDMDRVINS pDrvIns)
 {
-    PDRVMOUSEQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
-    pData->fInactive = false;
+    PDRVMOUSEQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
+    pThis->fInactive = false;
 }
 
@@ -220 +220 @@
 static DECLCALLBACK(void) drvMouseQueuePowerOff(PPDMDRVINS pDrvIns)
 {
-    PDRVMOUSEQUEUE        pData = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
-    pData->fInactive = true;
+    PDRVMOUSEQUEUE        pThis = PDMINS_2_DATA(pDrvIns, PDRVMOUSEQUEUE);
+    pThis->fInactive = true;
 }
 

trunk/src/VBox/Devices/Network/DevPCNet.cpp

@@ -332 +332 @@
 #define PCNETSTATE_2_DEVINS(pPCNet)            ((pPCNet)->CTX_SUFF(pDevIns))
 #define PCIDEV_2_PCNETSTATE(pPciDev)           ((PCNetState *)(pPciDev))
-#define PCNET_INST_NR                          (PCNETSTATE_2_DEVINS(pData)->iInstance)
+#define PCNET_INST_NR                          (PCNETSTATE_2_DEVINS(pThis)->iInstance)
 
 /* BUS CONFIGURATION REGISTERS */
@@ -613 +613 @@
 
 #if defined(PCNET_QUEUE_SEND_PACKETS) && defined(IN_RING3)
-static int pcnetSyncTransmit(PCNetState *pData);
-#endif
-static void pcnetPollTimerStart(PCNetState *pData);
+static int pcnetSyncTransmit(PCNetState *pThis);
+#endif
+static void pcnetPollTimerStart(PCNetState *pThis);
 
 /**
@@ -621 +621 @@
  * Make sure we read the own flag first.
  *
- * @param pData         adapter private data
+ * @param pThis         adapter private data
  * @param addr          physical address of the descriptor
  * @param fRetIfNotOwn  return immediately after reading the own flag if we don't own the descriptor
  * @return              true if we own the descriptor, false otherwise
  */
-DECLINLINE(bool) pcnetTmdLoad(PCNetState *pData, TMD *tmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
+DECLINLINE(bool) pcnetTmdLoad(PCNetState *pThis, TMD *tmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     uint8_t    ownbyte;
 
-    if (pData->fPrivIfEnabled)
+    if (pThis->fPrivIfEnabled)
     {
         /* RX/TX descriptors shared between host and guest => direct copy */
-        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                    + (addr - pData->GCTDRA)
-                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
+        uint8_t *pv = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                    + (addr - pThis->GCTDRA)
+                    + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
         if (!(pv[7] & 0x80) && fRetIfNotOwn)
             return false;
@@ -642 +642 @@
         return true;
     }
-    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pThis) == 0))
     {
         uint16_t xda[4];
@@ -655 +655 @@
         ((uint32_t *)tmd)[3] = 0;
     }
-    else if (RT_LIKELY(BCR_SWSTYLE(pData) != 3))
+    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
     {
         PDMDevHlpPhysRead(pDevIns, addr+7, &ownbyte, 1);
@@ -689 +689 @@
  * Make sure that all data are transmitted before we clear the own flag.
  */
-DECLINLINE(void) pcnetTmdStorePassHost(PCNetState *pData, TMD *tmd, RTGCPHYS32 addr)
-{
-    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatTmdStore), a);
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
-    if (pData->fPrivIfEnabled)
+DECLINLINE(void) pcnetTmdStorePassHost(PCNetState *pThis, TMD *tmd, RTGCPHYS32 addr)
+{
+    STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatTmdStore), a);
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
+    if (pThis->fPrivIfEnabled)
     {
         /* RX/TX descriptors shared between host and guest => direct copy */
-        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                    + (addr - pData->GCTDRA)
-                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
+        uint8_t *pv = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                    + (addr - pThis->GCTDRA)
+                    + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offTxDescriptors;
         memcpy(pv, tmd, 16);
         pv[7] &= ~0x80;
     }
-    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pThis) == 0))
     {
         uint16_t xda[4];
@@ -714 +714 @@
         PDMDevHlpPhysWrite(pDevIns, addr+3, (uint8_t*)xda + 3, 1);
     }
-    else if (RT_LIKELY(BCR_SWSTYLE(pData) != 3))
+    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
     {
         ((uint32_t*)tmd)[1] |=  0x80000000;
@@ -733 +733 @@
         PDMDevHlpPhysWrite(pDevIns, addr+7, (uint8_t*)xda + 7, 1);
     }
-    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatTmdStore), a);
+    STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatTmdStore), a);
 }
 
@@ -740 +740 @@
  * Make sure we read the own flag first.
  *
- * @param pData         adapter private data
+ * @param pThis         adapter private data
  * @param addr          physical address of the descriptor
  * @param fRetIfNotOwn  return immediately after reading the own flag if we don't own the descriptor
  * @return              true if we own the descriptor, false otherwise
  */
-DECLINLINE(int) pcnetRmdLoad(PCNetState *pData, RMD *rmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
+DECLINLINE(int) pcnetRmdLoad(PCNetState *pThis, RMD *rmd, RTGCPHYS32 addr, bool fRetIfNotOwn)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     uint8_t    ownbyte;
 
-    if (pData->fPrivIfEnabled)
+    if (pThis->fPrivIfEnabled)
     {
         /* RX/TX descriptors shared between host and guest => direct copy */
-        uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                    + (addr - pData->GCRDRA)
-                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+        uint8_t *pb = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                    + (addr - pThis->GCRDRA)
+                    + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
         if (!(pb[7] & 0x80) && fRetIfNotOwn)
             return false;
@@ -761 +761 @@
         return true;
     }
-    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pThis) == 0))
     {
         uint16_t rda[4];
@@ -773 +773 @@
         ((uint32_t *)rmd)[3] = 0;
     }
-    else if (RT_LIKELY(BCR_SWSTYLE(pData) != 3))
+    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
     {
         PDMDevHlpPhysRead(pDevIns, addr+7, &ownbyte, 1);
@@ -807 +807 @@
  * Make sure that all data are transmitted before we clear the own flag.
  */
-DECLINLINE(void) pcnetRmdStorePassHost(PCNetState *pData, RMD *rmd, RTGCPHYS32 addr)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
-    if (pData->fPrivIfEnabled)
+DECLINLINE(void) pcnetRmdStorePassHost(PCNetState *pThis, RMD *rmd, RTGCPHYS32 addr)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
+    if (pThis->fPrivIfEnabled)
     {
         /* RX/TX descriptors shared between host and guest => direct copy */
-        uint8_t *pv = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                    + (addr - pData->GCRDRA)
-                    + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+        uint8_t *pv = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                    + (addr - pThis->GCRDRA)
+                    + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
         memcpy(pv, rmd, 16);
         pv[7] &= ~0x80;
     }
-    else if (RT_UNLIKELY(BCR_SWSTYLE(pData) == 0))
+    else if (RT_UNLIKELY(BCR_SWSTYLE(pThis) == 0))
     {
         uint16_t rda[4];
@@ -831 +831 @@
         PDMDevHlpPhysWrite(pDevIns, addr+3, (uint8_t*)rda + 3, 1);
     }
-    else if (RT_LIKELY(BCR_SWSTYLE(pData) != 3))
+    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
     {
         ((uint32_t*)rmd)[1] |=  0x80000000;
@@ -897 +897 @@
  * @note Changing this layout will break SSM for guests using the private guest interface!
  */
-static void pcnetInitSharedMemory(PCNetState *pData)
+static void pcnetInitSharedMemory(PCNetState *pThis)
 {
     /* Clear the entire block for pcnetReset usage. */
-    memset(pData->pSharedMMIOR3, 0, PCNET_GUEST_SHARED_MEMORY_SIZE);
-
-    pData->pSharedMMIOR3->u32Version = PCNET_GUEST_INTERFACE_VERSION;
+    memset(pThis->pSharedMMIOR3, 0, PCNET_GUEST_SHARED_MEMORY_SIZE);
+
+    pThis->pSharedMMIOR3->u32Version = PCNET_GUEST_INTERFACE_VERSION;
     uint32_t off = 2048; /* Leave some space for more fields within the header */
 
@@ -908 +908 @@
      * The Descriptor arrays.
      */
-    pData->pSharedMMIOR3->V.V1.offTxDescriptors = off;
+    pThis->pSharedMMIOR3->V.V1.offTxDescriptors = off;
     off = RT_ALIGN(off + PCNET_GUEST_TX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
 
-    pData->pSharedMMIOR3->V.V1.offRxDescriptors = off;
+    pThis->pSharedMMIOR3->V.V1.offRxDescriptors = off;
     off = RT_ALIGN(off + PCNET_GUEST_RX_DESCRIPTOR_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
 
@@ -923 +923 @@
 #if 0
     /* Don't allocate TX buffers since Windows guests cannot use it */
-    pData->pSharedMMIOR3->V.V1.offTxBuffers = off;
+    pThis->pSharedMMIOR3->V.V1.offTxBuffers = off;
     off = RT_ALIGN(off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_TX_DESCRIPTORS, 32);
 #endif
 
-    pData->pSharedMMIOR3->V.V1.offRxBuffers = off;
-    pData->pSharedMMIOR3->fFlags = PCNET_GUEST_FLAGS_ADMIT_HOST;
+    pThis->pSharedMMIOR3->V.V1.offRxBuffers = off;
+    pThis->pSharedMMIOR3->fFlags = PCNET_GUEST_FLAGS_ADMIT_HOST;
     off = RT_ALIGN(off + PCNET_GUEST_NIC_BUFFER_SIZE * PCNET_GUEST_MAX_RX_DESCRIPTORS, 32);
     AssertRelease(off <= PCNET_GUEST_SHARED_MEMORY_SIZE);
 
     /* Update the header with the final size. */
-    pData->pSharedMMIOR3->cbUsed = off;
+    pThis->pSharedMMIOR3->cbUsed = off;
 }
 
@@ -1031 +1031 @@
 };
 
-DECLINLINE(int) padr_match(PCNetState *pData, const uint8_t *buf, size_t size)
+DECLINLINE(int) padr_match(PCNetState *pThis, const uint8_t *buf, size_t size)
 {
     struct ether_header *hdr = (struct ether_header *)buf;
     int     result;
 #if (defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)) && !defined(PCNET_DEBUG_MATCH)
-    result = !CSR_DRCVPA(pData) && !memcmp(hdr->ether_dhost, pData->aCSR + 12, 6);
+    result = !CSR_DRCVPA(pThis) && !memcmp(hdr->ether_dhost, pThis->aCSR + 12, 6);
 #else
     uint8_t padr[6];
-    padr[0] = pData->aCSR[12] & 0xff;
-    padr[1] = pData->aCSR[12] >> 8;
-    padr[2] = pData->aCSR[13] & 0xff;
-    padr[3] = pData->aCSR[13] >> 8;
-    padr[4] = pData->aCSR[14] & 0xff;
-    padr[5] = pData->aCSR[14] >> 8;
-    result = !CSR_DRCVPA(pData) && !memcmp(hdr->ether_dhost, padr, 6);
+    padr[0] = pThis->aCSR[12] & 0xff;
+    padr[1] = pThis->aCSR[12] >> 8;
+    padr[2] = pThis->aCSR[13] & 0xff;
+    padr[3] = pThis->aCSR[13] >> 8;
+    padr[4] = pThis->aCSR[14] & 0xff;
+    padr[5] = pThis->aCSR[14] >> 8;
+    result = !CSR_DRCVPA(pThis) && !memcmp(hdr->ether_dhost, padr, 6);
 #endif
 
@@ -1058 +1058 @@
 }
 
-DECLINLINE(int) padr_bcast(PCNetState *pData, const uint8_t *buf, size_t size)
+DECLINLINE(int) padr_bcast(PCNetState *pThis, const uint8_t *buf, size_t size)
 {
     static uint8_t aBCAST[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
     struct ether_header *hdr = (struct ether_header *)buf;
-    int result = !CSR_DRCVBC(pData) && !memcmp(hdr->ether_dhost, aBCAST, 6);
+    int result = !CSR_DRCVBC(pThis) && !memcmp(hdr->ether_dhost, aBCAST, 6);
 #ifdef PCNET_DEBUG_MATCH
     Log(("#%d padr_bcast result=%d\n", PCNET_INST_NR, result));
@@ -1069 +1069 @@
 }
 
-static int ladr_match(PCNetState *pData, const uint8_t *buf, size_t size)
+static int ladr_match(PCNetState *pThis, const uint8_t *buf, size_t size)
 {
     struct ether_header *hdr = (struct ether_header *)buf;
-    if (RT_UNLIKELY(hdr->ether_dhost[0] & 0x01) && ((uint64_t *)&pData->aCSR[8])[0] != 0LL)
+    if (RT_UNLIKELY(hdr->ether_dhost[0] & 0x01) && ((uint64_t *)&pThis->aCSR[8])[0] != 0LL)
     {
         int index;
 #if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
         index = lnc_mchash(hdr->ether_dhost) >> 26;
-        return ((uint8_t*)(pData->aCSR + 8))[index >> 3] & (1 << (index & 7));
+        return ((uint8_t*)(pThis->aCSR + 8))[index >> 3] & (1 << (index & 7));
 #else
         uint8_t ladr[8];
-        ladr[0] = pData->aCSR[8] & 0xff;
-        ladr[1] = pData->aCSR[8] >> 8;
-        ladr[2] = pData->aCSR[9] & 0xff;
-        ladr[3] = pData->aCSR[9] >> 8;
-        ladr[4] = pData->aCSR[10] & 0xff;
-        ladr[5] = pData->aCSR[10] >> 8;
-        ladr[6] = pData->aCSR[11] & 0xff;
-        ladr[7] = pData->aCSR[11] >> 8;
+        ladr[0] = pThis->aCSR[8] & 0xff;
+        ladr[1] = pThis->aCSR[8] >> 8;
+        ladr[2] = pThis->aCSR[9] & 0xff;
+        ladr[3] = pThis->aCSR[9] >> 8;
+        ladr[4] = pThis->aCSR[10] & 0xff;
+        ladr[5] = pThis->aCSR[10] >> 8;
+        ladr[6] = pThis->aCSR[11] & 0xff;
+        ladr[7] = pThis->aCSR[11] >> 8;
         index = lnc_mchash(hdr->ether_dhost) >> 26;
         return (ladr[index >> 3] & (1 << (index & 7)));
@@ -1100 +1100 @@
  * Get the receive descriptor ring address with a given index.
  */
-DECLINLINE(RTGCPHYS32) pcnetRdraAddr(PCNetState *pData, int idx)
-{
-    return pData->GCRDRA + ((CSR_RCVRL(pData) - idx) << pData->iLog2DescSize);
+DECLINLINE(RTGCPHYS32) pcnetRdraAddr(PCNetState *pThis, int idx)
+{
+    return pThis->GCRDRA + ((CSR_RCVRL(pThis) - idx) << pThis->iLog2DescSize);
 }
 
@@ -1108 +1108 @@
  * Get the transmit descriptor ring address with a given index.
  */
-DECLINLINE(RTGCPHYS32) pcnetTdraAddr(PCNetState *pData, int idx)
-{
-    return pData->GCTDRA + ((CSR_XMTRL(pData) - idx) << pData->iLog2DescSize);
+DECLINLINE(RTGCPHYS32) pcnetTdraAddr(PCNetState *pThis, int idx)
+{
+    return pThis->GCTDRA + ((CSR_XMTRL(pThis) - idx) << pThis->iLog2DescSize);
 }
 
@@ -1137 +1137 @@
 #define htons(x)    ( (((x) & 0xff00) >> 8) | (((x) & 0x00ff) << 8) )
 
-static void     pcnetPollRxTx(PCNetState *pData);
-static void     pcnetPollTimer(PCNetState *pData);
-static void     pcnetUpdateIrq(PCNetState *pData);
-static uint32_t pcnetBCRReadU16(PCNetState *pData, uint32_t u32RAP);
-static int      pcnetBCRWriteU16(PCNetState *pData, uint32_t u32RAP, uint32_t val);
+static void     pcnetPollRxTx(PCNetState *pThis);
+static void     pcnetPollTimer(PCNetState *pThis);
+static void     pcnetUpdateIrq(PCNetState *pThis);
+static uint32_t pcnetBCRReadU16(PCNetState *pThis, uint32_t u32RAP);
+static int      pcnetBCRWriteU16(PCNetState *pThis, uint32_t u32RAP, uint32_t val);
 
 
@@ -1148 +1148 @@
 
 /**
- * #PF Virtual Handler callback for Guest write access to the ring descriptor page(pData)
+ * #PF Virtual Handler callback for Guest write access to the ring descriptor page(pThis)
  *
  * @return  VBox status code (appropriate for trap handling and GC return).
@@ -1161 +1161 @@
                                      RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
 {
-    PCNetState *pData   = (PCNetState *)pvUser;
+    PCNetState *pThis   = (PCNetState *)pvUser;
 
     Log(("#%d pcnetHandleRingWriteGC: write to %#010x\n", PCNET_INST_NR, GCPhysFault));
 
     uint32_t cb;
-    int rc = CTXALLSUFF(pData->pfnEMInterpretInstruction)(pVM, pRegFrame, pvFault, &cb);
+    int rc = CTXALLSUFF(pThis->pfnEMInterpretInstruction)(pVM, pRegFrame, pvFault, &cb);
     if (RT_SUCCESS(rc) && cb)
     {
-        if (    (GCPhysFault >= pData->GCTDRA && GCPhysFault + cb < pcnetTdraAddr(pData, 0))
+        if (    (GCPhysFault >= pThis->GCTDRA && GCPhysFault + cb < pcnetTdraAddr(pThis, 0))
 #ifdef PCNET_MONITOR_RECEIVE_RING
-            ||  (GCPhysFault >= pData->GCRDRA && GCPhysFault + cb < pcnetRdraAddr(pData, 0))
+            ||  (GCPhysFault >= pThis->GCRDRA && GCPhysFault + cb < pcnetRdraAddr(pThis, 0))
 #endif
            )
         {
-            uint32_t offsetTDRA = (GCPhysFault - pData->GCTDRA);
-
-            int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+            uint32_t offsetTDRA = (GCPhysFault - pThis->GCTDRA);
+
+            int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
             if (RT_SUCCESS(rc))
             {
-                STAM_COUNTER_INC(&CTXALLSUFF(pData->StatRingWrite)); ;
+                STAM_COUNTER_INC(&CTXALLSUFF(pThis->StatRingWrite)); ;
 
                 /* Check if we can do something now */
-                pcnetPollRxTx(pData);
-                pcnetUpdateIrq(pData);
-
-                PDMCritSectLeave(&pData->CritSect);
+                pcnetPollRxTx(pThis);
+                pcnetUpdateIrq(pThis);
+
+                PDMCritSectLeave(&pThis->CritSect);
                 return VINF_SUCCESS;
             }
@@ -1192 +1192 @@
         else
         {
-            STAM_COUNTER_INC(&CTXALLSUFF(pData->StatRingWriteOutside)); ;
+            STAM_COUNTER_INC(&CTXALLSUFF(pThis->StatRingWriteOutside)); ;
             return VINF_SUCCESS;    /* outside of the ring range */
         }
     }
-    STAM_COUNTER_INC(&CTXALLSUFF(pData->StatRingWriteFailed)); ;
+    STAM_COUNTER_INC(&CTXALLSUFF(pThis->StatRingWriteFailed)); ;
     return VINF_IOM_HC_MMIO_WRITE; /* handle in ring3 */
 }
@@ -1222 +1222 @@
 {
     PPDMDEVINS  pDevIns = (PPDMDEVINS)pvUser;
-    PCNetState *pData   = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis   = PDMINS_2_DATA(pDevIns, PCNetState *);
 
     Log(("#%d pcnetHandleRingWrite: write to %#010x\n", PCNET_INST_NR, GCPhys));
 #ifdef VBOX_WITH_STATISTICS
-    STAM_COUNTER_INC(&CTXSUFF(pData->StatRingWrite));
-    if (GCPhys >= pData->GCRDRA && GCPhys < pcnetRdraAddr(pData, 0))
-        STAM_COUNTER_INC(&pData->StatRCVRingWrite);
-    else if (GCPhys >= pData->GCTDRA && GCPhys < pcnetTdraAddr(pData, 0))
-        STAM_COUNTER_INC(&pData->StatTXRingWrite);
+    STAM_COUNTER_INC(&CTXSUFF(pThis->StatRingWrite));
+    if (GCPhys >= pThis->GCRDRA && GCPhys < pcnetRdraAddr(pThis, 0))
+        STAM_COUNTER_INC(&pThis->StatRCVRingWrite);
+    else if (GCPhys >= pThis->GCTDRA && GCPhys < pcnetTdraAddr(pThis, 0))
+        STAM_COUNTER_INC(&pThis->StatTXRingWrite);
 #endif
     /* Perform the actual write */
@@ -1236 +1236 @@
 
     /* Writes done by our code don't require polling of course */
-    if (PDMCritSectIsOwner(&pData->CritSect) == false)
-    {
-        if (    (GCPhys >= pData->GCTDRA && GCPhys + cbBuf < pcnetTdraAddr(pData, 0))
+    if (PDMCritSectIsOwner(&pThis->CritSect) == false)
+    {
+        if (    (GCPhys >= pThis->GCTDRA && GCPhys + cbBuf < pcnetTdraAddr(pThis, 0))
 #ifdef PCNET_MONITOR_RECEIVE_RING
-            ||  (GCPhys >= pData->GCRDRA && GCPhys + cbBuf < pcnetRdraAddr(pData, 0))
+            ||  (GCPhys >= pThis->GCRDRA && GCPhys + cbBuf < pcnetRdraAddr(pThis, 0))
 #endif
            )
         {
-            int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+            int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
             AssertReleaseRC(rc);
             /* Check if we can do something now */
-            pcnetPollRxTx(pData);
-            pcnetUpdateIrq(pData);
-            PDMCritSectLeave(&pData->CritSect);
+            pcnetPollRxTx(pThis);
+            pcnetUpdateIrq(pThis);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -1257 +1257 @@
 #endif /* PCNET_NO_POLLING */
 
-static void pcnetSoftReset(PCNetState *pData)
+static void pcnetSoftReset(PCNetState *pThis)
 {
     Log(("#%d pcnetSoftReset:\n", PCNET_INST_NR));
 
-    pData->u32Lnkst = 0x40;
-    pData->GCRDRA   = 0;
-    pData->GCTDRA   = 0;
-    pData->u32RAP   = 0;
-
-    pData->aBCR[BCR_BSBC] &= ~0x0080;
-
-    pData->aCSR[0]   = 0x0004;
-    pData->aCSR[3]   = 0x0000;
-    pData->aCSR[4]   = 0x0115;
-    pData->aCSR[5]   = 0x0000;
-    pData->aCSR[6]   = 0x0000;
-    pData->aCSR[8]   = 0;
-    pData->aCSR[9]   = 0;
-    pData->aCSR[10]  = 0;
-    pData->aCSR[11]  = 0;
-    pData->aCSR[12]  = RT_LE2H_U16(((uint16_t *)&pData->aPROM[0])[0]);
-    pData->aCSR[13]  = RT_LE2H_U16(((uint16_t *)&pData->aPROM[0])[1]);
-    pData->aCSR[14]  = RT_LE2H_U16(((uint16_t *)&pData->aPROM[0])[2]);
-    pData->aCSR[15] &= 0x21c4;
-    CSR_RCVRC(pData) = 1;
-    CSR_XMTRC(pData) = 1;
-    CSR_RCVRL(pData) = 1;
-    CSR_XMTRL(pData) = 1;
-    pData->aCSR[80]  = 0x1410;
-    pData->aCSR[88]  = pData->fAm79C973 ? CSR_VERSION_LOW_79C973 : CSR_VERSION_LOW_79C970A;
-    pData->aCSR[89]  = CSR_VERSION_HIGH;
-    pData->aCSR[94]  = 0x0000;
-    pData->aCSR[100] = 0x0200;
-    pData->aCSR[103] = 0x0105;
-    pData->aCSR[103] = 0x0105;
-    CSR_MISSC(pData) = 0;
-    pData->aCSR[114] = 0x0000;
-    pData->aCSR[122] = 0x0000;
-    pData->aCSR[124] = 0x0000;
+    pThis->u32Lnkst = 0x40;
+    pThis->GCRDRA   = 0;
+    pThis->GCTDRA   = 0;
+    pThis->u32RAP   = 0;
+
+    pThis->aBCR[BCR_BSBC] &= ~0x0080;
+
+    pThis->aCSR[0]   = 0x0004;
+    pThis->aCSR[3]   = 0x0000;
+    pThis->aCSR[4]   = 0x0115;
+    pThis->aCSR[5]   = 0x0000;
+    pThis->aCSR[6]   = 0x0000;
+    pThis->aCSR[8]   = 0;
+    pThis->aCSR[9]   = 0;
+    pThis->aCSR[10]  = 0;
+    pThis->aCSR[11]  = 0;
+    pThis->aCSR[12]  = RT_LE2H_U16(((uint16_t *)&pThis->aPROM[0])[0]);
+    pThis->aCSR[13]  = RT_LE2H_U16(((uint16_t *)&pThis->aPROM[0])[1]);
+    pThis->aCSR[14]  = RT_LE2H_U16(((uint16_t *)&pThis->aPROM[0])[2]);
+    pThis->aCSR[15] &= 0x21c4;
+    CSR_RCVRC(pThis) = 1;
+    CSR_XMTRC(pThis) = 1;
+    CSR_RCVRL(pThis) = 1;
+    CSR_XMTRL(pThis) = 1;
+    pThis->aCSR[80]  = 0x1410;
+    pThis->aCSR[88]  = pThis->fAm79C973 ? CSR_VERSION_LOW_79C973 : CSR_VERSION_LOW_79C970A;
+    pThis->aCSR[89]  = CSR_VERSION_HIGH;
+    pThis->aCSR[94]  = 0x0000;
+    pThis->aCSR[100] = 0x0200;
+    pThis->aCSR[103] = 0x0105;
+    pThis->aCSR[103] = 0x0105;
+    CSR_MISSC(pThis) = 0;
+    pThis->aCSR[114] = 0x0000;
+    pThis->aCSR[122] = 0x0000;
+    pThis->aCSR[124] = 0x0000;
 }
 
@@ -1304 +1304 @@
  * - csr5 (only written by pcnetSoftReset(), pcnetStop or by the driver guest)
  */
-static void pcnetUpdateIrq(PCNetState *pData)
+static void pcnetUpdateIrq(PCNetState *pThis)
 {
     register int      iISR = 0;
-    register uint16_t csr0 = pData->aCSR[0];
+    register uint16_t csr0 = pThis->aCSR[0];
 
     csr0 &= ~0x0080; /* clear INTR */
 
-    STAM_PROFILE_ADV_START(&pData->StatInterrupt, a);
+    STAM_PROFILE_ADV_START(&pThis->StatInterrupt, a);
 
     /* Linux guests set csr4=0x0915
@@ -1317 +1317 @@
 
 #if 1
-    if (    ( (csr0               & ~pData->aCSR[3]) & 0x5f00)
-         || (((pData->aCSR[4]>>1) & ~pData->aCSR[4]) & 0x0115)
-         || (((pData->aCSR[5]>>1) &  pData->aCSR[5]) & 0x0048))
+    if (    ( (csr0               & ~pThis->aCSR[3]) & 0x5f00)
+         || (((pThis->aCSR[4]>>1) & ~pThis->aCSR[4]) & 0x0115)
+         || (((pThis->aCSR[5]>>1) &  pThis->aCSR[5]) & 0x0048))
 #else
-    if (  ( !(pData->aCSR[3] & 0x4000) && !!(csr0           & 0x4000)) /* BABL */
-        ||( !(pData->aCSR[3] & 0x1000) && !!(csr0           & 0x1000)) /* MISS */
-        ||( !(pData->aCSR[3] & 0x0100) && !!(csr0           & 0x0100)) /* IDON */
-        ||( !(pData->aCSR[3] & 0x0200) && !!(csr0           & 0x0200)) /* TINT */
-        ||( !(pData->aCSR[3] & 0x0400) && !!(csr0           & 0x0400)) /* RINT */
-        ||( !(pData->aCSR[3] & 0x0800) && !!(csr0           & 0x0800)) /* MERR */
-        ||( !(pData->aCSR[4] & 0x0001) && !!(pData->aCSR[4] & 0x0002)) /* JAB */
-        ||( !(pData->aCSR[4] & 0x0004) && !!(pData->aCSR[4] & 0x0008)) /* TXSTRT */
-        ||( !(pData->aCSR[4] & 0x0010) && !!(pData->aCSR[4] & 0x0020)) /* RCVO */
-        ||( !(pData->aCSR[4] & 0x0100) && !!(pData->aCSR[4] & 0x0200)) /* MFCO */
-        ||(!!(pData->aCSR[5] & 0x0040) && !!(pData->aCSR[5] & 0x0080)) /* EXDINT */
-        ||(!!(pData->aCSR[5] & 0x0008) && !!(pData->aCSR[5] & 0x0010)) /* MPINT */)
+    if (  ( !(pThis->aCSR[3] & 0x4000) && !!(csr0           & 0x4000)) /* BABL */
+        ||( !(pThis->aCSR[3] & 0x1000) && !!(csr0           & 0x1000)) /* MISS */
+        ||( !(pThis->aCSR[3] & 0x0100) && !!(csr0           & 0x0100)) /* IDON */
+        ||( !(pThis->aCSR[3] & 0x0200) && !!(csr0           & 0x0200)) /* TINT */
+        ||( !(pThis->aCSR[3] & 0x0400) && !!(csr0           & 0x0400)) /* RINT */
+        ||( !(pThis->aCSR[3] & 0x0800) && !!(csr0           & 0x0800)) /* MERR */
+        ||( !(pThis->aCSR[4] & 0x0001) && !!(pThis->aCSR[4] & 0x0002)) /* JAB */
+        ||( !(pThis->aCSR[4] & 0x0004) && !!(pThis->aCSR[4] & 0x0008)) /* TXSTRT */
+        ||( !(pThis->aCSR[4] & 0x0010) && !!(pThis->aCSR[4] & 0x0020)) /* RCVO */
+        ||( !(pThis->aCSR[4] & 0x0100) && !!(pThis->aCSR[4] & 0x0200)) /* MFCO */
+        ||(!!(pThis->aCSR[5] & 0x0040) && !!(pThis->aCSR[5] & 0x0080)) /* EXDINT */
+        ||(!!(pThis->aCSR[5] & 0x0008) && !!(pThis->aCSR[5] & 0x0010)) /* MPINT */)
 #endif
     {
@@ -1340 +1340 @@
 
 #ifdef VBOX
-    if (pData->aCSR[4] & 0x0080) /* UINTCMD */
-    {
-        pData->aCSR[4] &= ~0x0080; /* clear UINTCMD */
-        pData->aCSR[4] |=  0x0040; /* set UINT */
+    if (pThis->aCSR[4] & 0x0080) /* UINTCMD */
+    {
+        pThis->aCSR[4] &= ~0x0080; /* clear UINTCMD */
+        pThis->aCSR[4] |=  0x0040; /* set UINT */
         Log(("#%d user int\n", PCNET_INST_NR));
     }
-    if (pData->aCSR[4] & csr0 & 0x0040 /* CSR_INEA */)
+    if (pThis->aCSR[4] & csr0 & 0x0040 /* CSR_INEA */)
     {
         csr0 |=  0x0080; /* set INTR */
@@ -1352 +1352 @@
     }
 #else /* !VBOX */
-    if (!!(pData->aCSR[4] & 0x0080) && CSR_INEA(pData)) /* UINTCMD */
-    {
-        pData->aCSR[4] &= ~0x0080;
-        pData->aCSR[4] |=  0x0040; /* set UINT */
+    if (!!(pThis->aCSR[4] & 0x0080) && CSR_INEA(pThis)) /* UINTCMD */
+    {
+        pThis->aCSR[4] &= ~0x0080;
+        pThis->aCSR[4] |=  0x0040; /* set UINT */
         csr0           |=  0x0080; /* set INTR */
         iISR = 1;
@@ -1363 +1363 @@
 
 #if 1
-    if (((pData->aCSR[5]>>1) & pData->aCSR[5]) & 0x0500)
+    if (((pThis->aCSR[5]>>1) & pThis->aCSR[5]) & 0x0500)
 #else
-    if (   (!!(pData->aCSR[5] & 0x0400) && !!(pData->aCSR[5] & 0x0800)) /* SINT */
-         ||(!!(pData->aCSR[5] & 0x0100) && !!(pData->aCSR[5] & 0x0200)) /* SLPINT */)
+    if (   (!!(pThis->aCSR[5] & 0x0400) && !!(pThis->aCSR[5] & 0x0800)) /* SINT */
+         ||(!!(pThis->aCSR[5] & 0x0100) && !!(pThis->aCSR[5] & 0x0200)) /* SLPINT */)
 #endif
     {
@@ -1373 +1373 @@
     }
 
-    if ((pData->aCSR[7] & 0x0C00) == 0x0C00) /* STINT + STINTE */
+    if ((pThis->aCSR[7] & 0x0C00) == 0x0C00) /* STINT + STINTE */
         iISR = 1;
 
-    pData->aCSR[0] = csr0;
+    pThis->aCSR[0] = csr0;
 
     Log2(("#%d set irq iISR=%d\n", PCNET_INST_NR, iISR));
 
     /* normal path is to _not_ change the IRQ status */
-    if (RT_UNLIKELY(iISR != pData->iISR))
+    if (RT_UNLIKELY(iISR != pThis->iISR))
     {
         Log(("#%d INTA=%d\n", PCNET_INST_NR, iISR));
-        PDMDevHlpPCISetIrqNoWait(PCNETSTATE_2_DEVINS(pData), 0, iISR);
-        pData->iISR = iISR;
-    }
-    STAM_PROFILE_ADV_STOP(&pData->StatInterrupt, a);
+        PDMDevHlpPCISetIrqNoWait(PCNETSTATE_2_DEVINS(pThis), 0, iISR);
+        pThis->iISR = iISR;
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->StatInterrupt, a);
 }
 
@@ -1393 +1393 @@
  * Enable/disable the private guest interface.
  */
-static void pcnetEnablePrivateIf(PCNetState *pData)
-{
-    bool fPrivIfEnabled =       pData->pSharedMMIOR3
-                          && !!(pData->CTX_SUFF(pSharedMMIO)->fFlags & PCNET_GUEST_FLAGS_ADMIT_GUEST);
-    if (fPrivIfEnabled != pData->fPrivIfEnabled)
-    {
-        pData->fPrivIfEnabled = fPrivIfEnabled;
+static void pcnetEnablePrivateIf(PCNetState *pThis)
+{
+    bool fPrivIfEnabled =       pThis->pSharedMMIOR3
+                          && !!(pThis->CTX_SUFF(pSharedMMIO)->fFlags & PCNET_GUEST_FLAGS_ADMIT_GUEST);
+    if (fPrivIfEnabled != pThis->fPrivIfEnabled)
+    {
+        pThis->fPrivIfEnabled = fPrivIfEnabled;
         LogRel(("PCNet#%d: %s private interface\n", PCNET_INST_NR, fPrivIfEnabled ? "Enabling" : "Disabling"));
     }
@@ -1406 +1406 @@
 #ifdef IN_RING3
 #ifdef PCNET_NO_POLLING
-static void pcnetUpdateRingHandlers(PCNetState *pData)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
+static void pcnetUpdateRingHandlers(PCNetState *pThis)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     int rc;
 
-    Log(("pcnetUpdateRingHandlers TD %VGp size %#x -> %VGp size %#x\n", pData->TDRAPhysOld, pData->cbTDRAOld, pData->GCTDRA, pcnetTdraAddr(pData, 0)));
-    Log(("pcnetUpdateRingHandlers RX %VGp size %#x -> %VGp size %#x\n", pData->RDRAPhysOld, pData->cbRDRAOld, pData->GCRDRA, pcnetRdraAddr(pData, 0)));
+    Log(("pcnetUpdateRingHandlers TD %VGp size %#x -> %VGp size %#x\n", pThis->TDRAPhysOld, pThis->cbTDRAOld, pThis->GCTDRA, pcnetTdraAddr(pThis, 0)));
+    Log(("pcnetUpdateRingHandlers RX %VGp size %#x -> %VGp size %#x\n", pThis->RDRAPhysOld, pThis->cbRDRAOld, pThis->GCRDRA, pcnetRdraAddr(pThis, 0)));
 
     /** @todo unregister order not correct! */
 
 #ifdef PCNET_MONITOR_RECEIVE_RING
-    if (pData->GCRDRA != pData->RDRAPhysOld || CSR_RCVRL(pData) != pData->cbRDRAOld)
-    {
-        if (pData->RDRAPhysOld != 0)
+    if (pThis->GCRDRA != pThis->RDRAPhysOld || CSR_RCVRL(pThis) != pThis->cbRDRAOld)
+    {
+        if (pThis->RDRAPhysOld != 0)
             PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns),
-                                        pData->RDRAPhysOld & ~PAGE_OFFSET_MASK);
+                                        pThis->RDRAPhysOld & ~PAGE_OFFSET_MASK);
 
         rc = PGMR3HandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
                                           PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
-                                          pData->GCRDRA & ~PAGE_OFFSET_MASK,
-                                          RT_ALIGN(pcnetRdraAddr(pData, 0), PAGE_SIZE) - 1,
+                                          pThis->GCRDRA & ~PAGE_OFFSET_MASK,
+                                          RT_ALIGN(pcnetRdraAddr(pThis, 0), PAGE_SIZE) - 1,
                                           pcnetHandleRingWrite, pDevIns,
                                           g_DevicePCNet.szR0Mod, "pcnetHandleRingWrite",
-                                          pData->pDevInsHC->pvInstanceDataHC,
+                                          pThis->pDevInsHC->pvInstanceDataHC,
                                           g_DevicePCNet.szGCMod, "pcnetHandleRingWrite",
-                                          pData->pDevInsHC->pvInstanceDataGC,
+                                          pThis->pDevInsHC->pvInstanceDataGC,
                                           "PCNet receive ring write access handler");
         AssertRC(rc);
 
-        pData->RDRAPhysOld = pData->GCRDRA;
-        pData->cbRDRAOld   = pcnetRdraAddr(pData, 0);
+        pThis->RDRAPhysOld = pThis->GCRDRA;
+        pThis->cbRDRAOld   = pcnetRdraAddr(pThis, 0);
     }
 #endif /* PCNET_MONITOR_RECEIVE_RING */
@@ -1446 +1446 @@
      * 3) TDRA & RDRA overlap partly with different physical pages
      */
-    RTGCPHYS32 RDRAPageStart = pData->GCRDRA & ~PAGE_OFFSET_MASK;
-    RTGCPHYS32 RDRAPageEnd   = (pcnetRdraAddr(pData, 0) - 1) & ~PAGE_OFFSET_MASK;
-    RTGCPHYS32 TDRAPageStart = pData->GCTDRA & ~PAGE_OFFSET_MASK;
-    RTGCPHYS32 TDRAPageEnd   = (pcnetTdraAddr(pData, 0) - 1) & ~PAGE_OFFSET_MASK;
+    RTGCPHYS32 RDRAPageStart = pThis->GCRDRA & ~PAGE_OFFSET_MASK;
+    RTGCPHYS32 RDRAPageEnd   = (pcnetRdraAddr(pThis, 0) - 1) & ~PAGE_OFFSET_MASK;
+    RTGCPHYS32 TDRAPageStart = pThis->GCTDRA & ~PAGE_OFFSET_MASK;
+    RTGCPHYS32 TDRAPageEnd   = (pcnetTdraAddr(pThis, 0) - 1) & ~PAGE_OFFSET_MASK;
 
     if (    RDRAPageStart > TDRAPageEnd
@@ -1456 +1456 @@
 #endif /* PCNET_MONITOR_RECEIVE_RING */
         /* 1) */
-        if (pData->GCTDRA != pData->TDRAPhysOld || CSR_XMTRL(pData) != pData->cbTDRAOld)
+        if (pThis->GCTDRA != pThis->TDRAPhysOld || CSR_XMTRL(pThis) != pThis->cbTDRAOld)
         {
-            if (pData->TDRAPhysOld != 0)
+            if (pThis->TDRAPhysOld != 0)
                 PGMHandlerPhysicalDeregister(PDMDevHlpGetVM(pDevIns),
-                                             pData->TDRAPhysOld & ~PAGE_OFFSET_MASK);
+                                             pThis->TDRAPhysOld & ~PAGE_OFFSET_MASK);
 
             rc = PGMR3HandlerPhysicalRegister(PDMDevHlpGetVM(pDevIns),
                                               PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
-                                              pData->GCTDRA & ~PAGE_OFFSET_MASK,
-                                              RT_ALIGN(pcnetTdraAddr(pData, 0), PAGE_SIZE) - 1,
+                                              pThis->GCTDRA & ~PAGE_OFFSET_MASK,
+                                              RT_ALIGN(pcnetTdraAddr(pThis, 0), PAGE_SIZE) - 1,
                                               pcnetHandleRingWrite, pDevIns,
                                               g_DevicePCNet.szR0Mod, "pcnetHandleRingWrite",
-                                              pData->pDevInsHC->pvInstanceDataHC,
+                                              pThis->pDevInsHC->pvInstanceDataHC,
                                               g_DevicePCNet.szGCMod, "pcnetHandleRingWrite",
-                                              pData->pDevInsHC->pvInstanceDataGC,
+                                              pThis->pDevInsHC->pvInstanceDataGC,
                                               "PCNet transmit ring write access handler");
             AssertRC(rc);
 
-            pData->TDRAPhysOld = pData->GCTDRA;
-            pData->cbTDRAOld   = pcnetTdraAddr(pData, 0);
+            pThis->TDRAPhysOld = pThis->GCTDRA;
+            pThis->cbTDRAOld   = pcnetTdraAddr(pThis, 0);
         }
 #ifdef PCNET_MONITOR_RECEIVE_RING
@@ -1494 +1494 @@
 #endif /* PCNET_NO_POLLING */
 
-static void pcnetInit(PCNetState *pData)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
-    Log(("#%d pcnetInit: init_addr=%#010x\n", PCNET_INST_NR, PHYSADDR(pData, CSR_IADR(pData))));
+static void pcnetInit(PCNetState *pThis)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
+    Log(("#%d pcnetInit: init_addr=%#010x\n", PCNET_INST_NR, PHYSADDR(pThis, CSR_IADR(pThis))));
 
     /** @todo Documentation says that RCVRL and XMTRL are stored as two's complement!
      *        Software is allowed to write these registers directly. */
 #define PCNET_INIT() do { \
-        PDMDevHlpPhysRead(pDevIns, PHYSADDR(pData, CSR_IADR(pData)),         \
+        PDMDevHlpPhysRead(pDevIns, PHYSADDR(pThis, CSR_IADR(pThis)),         \
                           (uint8_t *)&initblk, sizeof(initblk));             \
-        pData->aCSR[15]  = RT_LE2H_U16(initblk.mode);                        \
-        CSR_RCVRL(pData) = (initblk.rlen < 9) ? (1 << initblk.rlen) : 512;   \
-        CSR_XMTRL(pData) = (initblk.tlen < 9) ? (1 << initblk.tlen) : 512;   \
-        pData->aCSR[ 6]  = (initblk.tlen << 12) | (initblk.rlen << 8);       \
-        pData->aCSR[ 8]  = RT_LE2H_U16(initblk.ladrf1);                      \
-        pData->aCSR[ 9]  = RT_LE2H_U16(initblk.ladrf2);                      \
-        pData->aCSR[10]  = RT_LE2H_U16(initblk.ladrf3);                      \
-        pData->aCSR[11]  = RT_LE2H_U16(initblk.ladrf4);                      \
-        pData->aCSR[12]  = RT_LE2H_U16(initblk.padr1);                       \
-        pData->aCSR[13]  = RT_LE2H_U16(initblk.padr2);                       \
-        pData->aCSR[14]  = RT_LE2H_U16(initblk.padr3);                       \
-        pData->GCRDRA    = PHYSADDR(pData, initblk.rdra);                    \
-        pData->GCTDRA    = PHYSADDR(pData, initblk.tdra);                    \
+        pThis->aCSR[15]  = RT_LE2H_U16(initblk.mode);                        \
+        CSR_RCVRL(pThis) = (initblk.rlen < 9) ? (1 << initblk.rlen) : 512;   \
+        CSR_XMTRL(pThis) = (initblk.tlen < 9) ? (1 << initblk.tlen) : 512;   \
+        pThis->aCSR[ 6]  = (initblk.tlen << 12) | (initblk.rlen << 8);       \
+        pThis->aCSR[ 8]  = RT_LE2H_U16(initblk.ladrf1);                      \
+        pThis->aCSR[ 9]  = RT_LE2H_U16(initblk.ladrf2);                      \
+        pThis->aCSR[10]  = RT_LE2H_U16(initblk.ladrf3);                      \
+        pThis->aCSR[11]  = RT_LE2H_U16(initblk.ladrf4);                      \
+        pThis->aCSR[12]  = RT_LE2H_U16(initblk.padr1);                       \
+        pThis->aCSR[13]  = RT_LE2H_U16(initblk.padr2);                       \
+        pThis->aCSR[14]  = RT_LE2H_U16(initblk.padr3);                       \
+        pThis->GCRDRA    = PHYSADDR(pThis, initblk.rdra);                    \
+        pThis->GCTDRA    = PHYSADDR(pThis, initblk.tdra);                    \
 } while (0)
 
-    pcnetEnablePrivateIf(pData);
-
-    if (BCR_SSIZE32(pData))
+    pcnetEnablePrivateIf(pThis);
+
+    if (BCR_SSIZE32(pThis))
     {
         struct INITBLK32 initblk;
-        pData->GCUpperPhys = 0;
+        pThis->GCUpperPhys = 0;
         PCNET_INIT();
         Log(("#%d initblk.rlen=%#04x, initblk.tlen=%#04x\n",
@@ -1532 +1532 @@
     {
         struct INITBLK16 initblk;
-        pData->GCUpperPhys = (0xff00 & (uint32_t)pData->aCSR[2]) << 16;
+        pThis->GCUpperPhys = (0xff00 & (uint32_t)pThis->aCSR[2]) << 16;
         PCNET_INIT();
         Log(("#%d initblk.rlen=%#04x, initblk.tlen=%#04x\n",
@@ -1541 +1541 @@
 
     size_t cbRxBuffers = 0;
-    for (int i = CSR_RCVRL(pData); i >= 1; i--)
+    for (int i = CSR_RCVRL(pThis); i >= 1; i--)
     {
         RMD        rmd;
-        RTGCPHYS32 addr = pcnetRdraAddr(pData, i);
+        RTGCPHYS32 addr = pcnetRdraAddr(pThis, i);
         /* At this time it is not guaranteed that the buffers are already initialized. */
-        if (pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, addr), false))
+        if (pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, addr), false))
             cbRxBuffers += 4096-rmd.rmd1.bcnt;
     }
@@ -1558 +1558 @@
      * short in RX buffers we notify this condition.
      */
-    pData->fSignalRxMiss = (cbRxBuffers == 0 || cbRxBuffers >= 32*_1K);
-
-    if (pData->pDrv)
-        pData->pDrv->pfnSetPromiscuousMode(pData->pDrv, CSR_PROM(pData));
-
-    CSR_RCVRC(pData) = CSR_RCVRL(pData);
-    CSR_XMTRC(pData) = CSR_XMTRL(pData);
+    pThis->fSignalRxMiss = (cbRxBuffers == 0 || cbRxBuffers >= 32*_1K);
+
+    if (pThis->pDrv)
+        pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv, CSR_PROM(pThis));
+
+    CSR_RCVRC(pThis) = CSR_RCVRL(pThis);
+    CSR_XMTRC(pThis) = CSR_XMTRL(pThis);
 
 #ifdef PCNET_NO_POLLING
-    pcnetUpdateRingHandlers(pData);
+    pcnetUpdateRingHandlers(pThis);
 #endif
 
     /* Reset cached RX and TX states */
-    CSR_CRST(pData) = CSR_CRBC(pData) = CSR_NRST(pData) = CSR_NRBC(pData) = 0;
-    CSR_CXST(pData) = CSR_CXBC(pData) = CSR_NXST(pData) = CSR_NXBC(pData) = 0;
+    CSR_CRST(pThis) = CSR_CRBC(pThis) = CSR_NRST(pThis) = CSR_NRBC(pThis) = 0;
+    CSR_CXST(pThis) = CSR_CXBC(pThis) = CSR_NXST(pThis) = CSR_NXBC(pThis) = 0;
 
     LogRel(("PCNet#%d: Init: ss32=%d GCRDRA=%#010x[%d] GCTDRA=%#010x[%d]%s\n",
-            PCNET_INST_NR, BCR_SSIZE32(pData),
-            pData->GCRDRA, CSR_RCVRL(pData), pData->GCTDRA, CSR_XMTRL(pData),
-            !pData->fSignalRxMiss ? " (CSR0_MISS disabled)" : ""));
-
-    pData->aCSR[0] |=  0x0101;       /* Initialization done */
-    pData->aCSR[0] &= ~0x0004;       /* clear STOP bit */
+            PCNET_INST_NR, BCR_SSIZE32(pThis),
+            pThis->GCRDRA, CSR_RCVRL(pThis), pThis->GCTDRA, CSR_XMTRL(pThis),
+            !pThis->fSignalRxMiss ? " (CSR0_MISS disabled)" : ""));
+
+    pThis->aCSR[0] |=  0x0101;       /* Initialization done */
+    pThis->aCSR[0] &= ~0x0004;       /* clear STOP bit */
 }
 #endif /* IN_RING3 */
@@ -1587 +1587 @@
  * Start RX/TX operation.
  */
-static void pcnetStart(PCNetState *pData)
+static void pcnetStart(PCNetState *pThis)
 {
     Log(("#%d pcnetStart:\n", PCNET_INST_NR));
-    if (!CSR_DTX(pData))
-        pData->aCSR[0] |= 0x0010;    /* set TXON */
-    if (!CSR_DRX(pData))
-        pData->aCSR[0] |= 0x0020;    /* set RXON */
-    pcnetEnablePrivateIf(pData);
-    pData->aCSR[0] &= ~0x0004;       /* clear STOP bit */
-    pData->aCSR[0] |=  0x0002;       /* STRT */
-    pcnetPollTimerStart(pData);      /* start timer if it was stopped */
+    if (!CSR_DTX(pThis))
+        pThis->aCSR[0] |= 0x0010;    /* set TXON */
+    if (!CSR_DRX(pThis))
+        pThis->aCSR[0] |= 0x0020;    /* set RXON */
+    pcnetEnablePrivateIf(pThis);
+    pThis->aCSR[0] &= ~0x0004;       /* clear STOP bit */
+    pThis->aCSR[0] |=  0x0002;       /* STRT */
+    pcnetPollTimerStart(pThis);      /* start timer if it was stopped */
 }
 
@@ -1603 +1603 @@
  * Stop RX/TX operation.
  */
-static void pcnetStop(PCNetState *pData)
+static void pcnetStop(PCNetState *pThis)
 {
     Log(("#%d pcnetStop:\n", PCNET_INST_NR));
-    pData->aCSR[0] &= ~0x7feb;
-    pData->aCSR[0] |=  0x0014;
-    pData->aCSR[4] &= ~0x02c2;
-    pData->aCSR[5] &= ~0x0011;
-    pcnetEnablePrivateIf(pData);
-    pcnetPollTimer(pData);
+    pThis->aCSR[0] &= ~0x7feb;
+    pThis->aCSR[0] |=  0x0014;
+    pThis->aCSR[4] &= ~0x02c2;
+    pThis->aCSR[5] &= ~0x0011;
+    pcnetEnablePrivateIf(pThis);
+    pcnetPollTimer(pThis);
 }
 
@@ -1617 +1617 @@
 static DECLCALLBACK(void) pcnetWakeupReceive(PPDMDEVINS pDevIns)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-    STAM_COUNTER_INC(&pData->StatRxOverflowWakeup);
-    if (pData->hEventOutOfRxSpace != NIL_RTSEMEVENT)
-        RTSemEventSignal(pData->hEventOutOfRxSpace);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+    STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup);
+    if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT)
+        RTSemEventSignal(pThis->hEventOutOfRxSpace);
 }
 
@@ -1638 +1638 @@
  * @param  fSkipCurrent       if true, don't scan the current RDTE.
  */
-static void pcnetRdtePoll(PCNetState *pData, bool fSkipCurrent=false)
-{
-    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatRdtePoll), a);
+static void pcnetRdtePoll(PCNetState *pThis, bool fSkipCurrent=false)
+{
+    STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatRdtePoll), a);
     /* assume lack of a next receive descriptor */
-    CSR_NRST(pData) = 0;
-
-    if (RT_LIKELY(pData->GCRDRA))
+    CSR_NRST(pThis) = 0;
+
+    if (RT_LIKELY(pThis->GCRDRA))
     {
         /*
@@ -1650 +1650 @@
          */
         RMD        rmd;
-        int        i = CSR_RCVRC(pData);
+        int        i = CSR_RCVRC(pThis);
         RTGCPHYS32 addr;
 
         if (i < 1)
-            i = CSR_RCVRL(pData);
+            i = CSR_RCVRL(pThis);
 
         if (!fSkipCurrent)
         {
-            addr = pcnetRdraAddr(pData, i);
-            CSR_CRDA(pData) = CSR_CRBA(pData) = 0;
-            CSR_CRBC(pData) = CSR_CRST(pData) = 0;
-            if (!pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, addr), true))
+            addr = pcnetRdraAddr(pThis, i);
+            CSR_CRDA(pThis) = CSR_CRBA(pThis) = 0;
+            CSR_CRBC(pThis) = CSR_CRST(pThis) = 0;
+            if (!pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, addr), true))
             {
-                STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatRdtePoll), a);
+                STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatRdtePoll), a);
                 return;
             }
             if (RT_LIKELY(!IS_RMD_BAD(rmd)))
             {
-                CSR_CRDA(pData) = addr;                        /* Receive Descriptor Address */
-                CSR_CRBA(pData) = rmd.rmd0.rbadr;              /* Receive Buffer Address */
-                CSR_CRBC(pData) = rmd.rmd1.bcnt;               /* Receive Byte Count */
-                CSR_CRST(pData) = ((uint32_t *)&rmd)[1] >> 16; /* Receive Status */
-                if (pData->fMaybeOutOfSpace)
+                CSR_CRDA(pThis) = addr;                        /* Receive Descriptor Address */
+                CSR_CRBA(pThis) = rmd.rmd0.rbadr;              /* Receive Buffer Address */
+                CSR_CRBC(pThis) = rmd.rmd1.bcnt;               /* Receive Byte Count */
+                CSR_CRST(pThis) = ((uint32_t *)&rmd)[1] >> 16; /* Receive Status */
+                if (pThis->fMaybeOutOfSpace)
                 {
 #ifdef IN_RING3
-                    pcnetWakeupReceive(PCNETSTATE_2_DEVINS(pData));
+                    pcnetWakeupReceive(PCNETSTATE_2_DEVINS(pThis));
 #else
-                    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pCanRxQueue));
+                    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pThis->CTX_SUFF(pCanRxQueue));
                     if (pItem)
-                        PDMQueueInsert(pData->CTX_SUFF(pCanRxQueue), pItem);
+                        PDMQueueInsert(pThis->CTX_SUFF(pCanRxQueue), pItem);
 #endif
                 }
@@ -1685 +1685 @@
             else
             {
-                STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatRdtePoll), a);
+                STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatRdtePoll), a);
                 /* This is not problematic since we don't own the descriptor */
                 LogRel(("PCNet#%d: BAD RMD ENTRIES AT %#010x (i=%d)\n",
@@ -1697 +1697 @@
          */
         if (--i < 1)
-            i = CSR_RCVRL(pData);
-        addr = pcnetRdraAddr(pData, i);
-        CSR_NRDA(pData) = CSR_NRBA(pData) = 0;
-        CSR_NRBC(pData) = 0;
-        if (!pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, addr), true))
+            i = CSR_RCVRL(pThis);
+        addr = pcnetRdraAddr(pThis, i);
+        CSR_NRDA(pThis) = CSR_NRBA(pThis) = 0;
+        CSR_NRBC(pThis) = 0;
+        if (!pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, addr), true))
         {
-            STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatRdtePoll), a);
+            STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatRdtePoll), a);
             return;
         }
         if (RT_LIKELY(!IS_RMD_BAD(rmd)))
         {
-            CSR_NRDA(pData) = addr;                         /* Receive Descriptor Address */
-            CSR_NRBA(pData) = rmd.rmd0.rbadr;               /* Receive Buffer Address */
-            CSR_NRBC(pData) = rmd.rmd1.bcnt;                /* Receive Byte Count */
-            CSR_NRST(pData) = ((uint32_t *)&rmd)[1] >> 16;  /* Receive Status */
+            CSR_NRDA(pThis) = addr;                         /* Receive Descriptor Address */
+            CSR_NRBA(pThis) = rmd.rmd0.rbadr;               /* Receive Buffer Address */
+            CSR_NRBC(pThis) = rmd.rmd1.bcnt;                /* Receive Byte Count */
+            CSR_NRST(pThis) = ((uint32_t *)&rmd)[1] >> 16;  /* Receive Status */
         }
         else
         {
-            STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatRdtePoll), a);
+            STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatRdtePoll), a);
             /* This is not problematic since we don't own the descriptor */
             LogRel(("PCNet#%d: BAD RMD ENTRIES + AT %#010x (i=%d)\n",
@@ -1728 +1728 @@
     else
     {
-        CSR_CRDA(pData) = CSR_CRBA(pData) = CSR_NRDA(pData) = CSR_NRBA(pData) = 0;
-        CSR_CRBC(pData) = CSR_NRBC(pData) = CSR_CRST(pData) = 0;
-    }
-    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatRdtePoll), a);
+        CSR_CRDA(pThis) = CSR_CRBA(pThis) = CSR_NRDA(pThis) = CSR_NRBA(pThis) = 0;
+        CSR_CRBC(pThis) = CSR_NRBC(pThis) = CSR_CRST(pThis) = 0;
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatRdtePoll), a);
 }
 
@@ -1738 +1738 @@
  * @return true if transmit descriptors available
  */
-static int pcnetTdtePoll(PCNetState *pData, TMD *tmd)
-{
-    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatTdtePoll), a);
-    if (RT_LIKELY(pData->GCTDRA))
-    {
-        RTGCPHYS32 cxda = pcnetTdraAddr(pData, CSR_XMTRC(pData));
-
-        if (!pcnetTmdLoad(pData, tmd, PHYSADDR(pData, cxda), true))
+static int pcnetTdtePoll(PCNetState *pThis, TMD *tmd)
+{
+    STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatTdtePoll), a);
+    if (RT_LIKELY(pThis->GCTDRA))
+    {
+        RTGCPHYS32 cxda = pcnetTdraAddr(pThis, CSR_XMTRC(pThis));
+
+        if (!pcnetTmdLoad(pThis, tmd, PHYSADDR(pThis, cxda), true))
         {
-            STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatTdtePoll), a);
+            STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatTdtePoll), a);
             return 0;
         }
@@ -1753 +1753 @@
         if (RT_UNLIKELY(tmd->tmd1.ones != 15))
         {
-            STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatTdtePoll), a);
+            STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatTdtePoll), a);
             LogRel(("PCNet#%d: BAD TMD XDA=%#010x\n",
-                    PCNET_INST_NR, PHYSADDR(pData, cxda)));
+                    PCNET_INST_NR, PHYSADDR(pThis, cxda)));
             return 0;
         }
 
         /* previous xmit descriptor */
-        CSR_PXDA(pData) = CSR_CXDA(pData);
-        CSR_PXBC(pData) = CSR_CXBC(pData);
-        CSR_PXST(pData) = CSR_CXST(pData);
+        CSR_PXDA(pThis) = CSR_CXDA(pThis);
+        CSR_PXBC(pThis) = CSR_CXBC(pThis);
+        CSR_PXST(pThis) = CSR_CXST(pThis);
 
         /* set current trasmit decriptor. */
-        CSR_CXDA(pData) = cxda;
-        CSR_CXBC(pData) = tmd->tmd1.bcnt;
-        CSR_CXST(pData) = ((uint32_t *)tmd)[1] >> 16;
-        STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatTdtePoll), a);
-        return CARD_IS_OWNER(CSR_CXST(pData));
+        CSR_CXDA(pThis) = cxda;
+        CSR_CXBC(pThis) = tmd->tmd1.bcnt;
+        CSR_CXST(pThis) = ((uint32_t *)tmd)[1] >> 16;
+        STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatTdtePoll), a);
+        return CARD_IS_OWNER(CSR_CXST(pThis));
     }
     else
     {
         /** @todo consistency with previous receive descriptor */
-        CSR_CXDA(pData) = 0;
-        CSR_CXBC(pData) = CSR_CXST(pData) = 0;
-        STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatTdtePoll), a);
+        CSR_CXDA(pThis) = 0;
+        CSR_CXBC(pThis) = CSR_CXST(pThis) = 0;
+        STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatTdtePoll), a);
         return 0;
     }
@@ -1787 +1787 @@
  * Write data into guest receive buffers.
  */
-static void pcnetReceiveNoSync(PCNetState *pData, const uint8_t *buf, size_t size)
-{
-    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pData);
+static void pcnetReceiveNoSync(PCNetState *pThis, const uint8_t *buf, size_t size)
+{
+    PPDMDEVINS pDevIns = PCNETSTATE_2_DEVINS(pThis);
     int is_padr = 0, is_bcast = 0, is_ladr = 0;
     unsigned i;
     int pkt_size;
 
-    if (RT_UNLIKELY(CSR_DRX(pData) || CSR_STOP(pData) || CSR_SPND(pData) || !size))
+    if (RT_UNLIKELY(CSR_DRX(pThis) || CSR_STOP(pThis) || CSR_SPND(pThis) || !size))
         return;
 
@@ -1808 +1808 @@
      * Perform address matching.
      */
-    if (   CSR_PROM(pData)
-        || (is_padr  = padr_match(pData, buf, size))
-        || (is_bcast = padr_bcast(pData, buf, size))
-        || (is_ladr  = ladr_match(pData, buf, size)))
-    {
-        if (HOST_IS_OWNER(CSR_CRST(pData)))
-            pcnetRdtePoll(pData);
-        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pData))))
+    if (   CSR_PROM(pThis)
+        || (is_padr  = padr_match(pThis, buf, size))
+        || (is_bcast = padr_bcast(pThis, buf, size))
+        || (is_ladr  = ladr_match(pThis, buf, size)))
+    {
+        if (HOST_IS_OWNER(CSR_CRST(pThis)))
+            pcnetRdtePoll(pThis);
+        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pThis))))
         {
             /* Not owned by controller. This should not be possible as
              * we already called pcnetCanReceive(). */
             LogRel(("PCNet#%d: no buffer: RCVRC=%d\n",
-                    PCNET_INST_NR, CSR_RCVRC(pData)));
+                    PCNET_INST_NR, CSR_RCVRC(pThis)));
             /* Dump the status of all RX descriptors */
-            const unsigned  cb = 1 << pData->iLog2DescSize;
-            RTGCPHYS32      GCPhys = pData->GCRDRA;
-            i = CSR_RCVRL(pData);
+            const unsigned  cb = 1 << pThis->iLog2DescSize;
+            RTGCPHYS32      GCPhys = pThis->GCRDRA;
+            i = CSR_RCVRL(pThis);
             while (i-- > 0)
             {
                 RMD rmd;
-                pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, GCPhys), false);
+                pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
                 LogRel(("  %#010x\n", rmd.rmd1));
                 GCPhys += cb;
             }
-            pData->aCSR[0] |= 0x1000; /* Set MISS flag */
-            CSR_MISSC(pData)++;
+            pThis->aCSR[0] |= 0x1000; /* Set MISS flag */
+            CSR_MISSC(pThis)++;
         }
         else
         {
-            uint8_t   *src = &pData->abRecvBuf[8];
-            RTGCPHYS32 crda = CSR_CRDA(pData);
+            uint8_t   *src = &pThis->abRecvBuf[8];
+            RTGCPHYS32 crda = CSR_CRDA(pThis);
             RTGCPHYS32 next_crda;
             RMD      rmd, next_rmd;
@@ -1844 +1844 @@
 
             memcpy(src, buf, size);
-            if (!CSR_ASTRP_RCV(pData))
+            if (!CSR_ASTRP_RCV(pThis))
             {
                 uint32_t fcs = ~0;
@@ -1863 +1863 @@
 #endif
 
-            pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, crda), false);
-            /*if (!CSR_LAPPEN(pData))*/
+            pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, crda), false);
+            /*if (!CSR_LAPPEN(pThis))*/
                 rmd.rmd1.stp = 1;
 
             size_t count = RT_MIN(4096 - (size_t)rmd.rmd1.bcnt, size);
-            RTGCPHYS32 rbadr = PHYSADDR(pData, rmd.rmd0.rbadr);
+            RTGCPHYS32 rbadr = PHYSADDR(pThis, rmd.rmd0.rbadr);
 #if 0
-            if (pData->fPrivIfEnabled)
+            if (pThis->fPrivIfEnabled)
             {
-                uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                            + rbadr - pData->GCRDRA + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+                uint8_t *pb = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                            + rbadr - pThis->GCRDRA + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
                 memcpy(pb, src, count);
             }
@@ -1884 +1884 @@
 
             /* Read current receive descriptor index */
-            i = CSR_RCVRC(pData);
+            i = CSR_RCVRC(pThis);
 
             while (size > 0)
@@ -1890 +1890 @@
                 /* Read the entire next descriptor as we're likely to need it. */
                 if (--i < 1)
-                    i = CSR_RCVRL(pData);
-                next_crda = pcnetRdraAddr(pData, i);
+                    i = CSR_RCVRL(pThis);
+                next_crda = pcnetRdraAddr(pThis, i);
 
                 /* Check next descriptor's own bit. If we don't own it, we have
                  * to quit and write error status into the last descriptor we own.
                  */
-                if (!pcnetRmdLoad(pData, &next_rmd, PHYSADDR(pData, next_crda), true))
+                if (!pcnetRmdLoad(pThis, &next_rmd, PHYSADDR(pThis, next_crda), true))
                     break;
 
                 /* Write back current descriptor, clear the own bit. */
-                pcnetRmdStorePassHost(pData, &rmd, PHYSADDR(pData, crda));
+                pcnetRmdStorePassHost(pThis, &rmd, PHYSADDR(pThis, crda));
 
                 /* Switch to the next descriptor */
@@ -1907 +1907 @@
 
                 count = RT_MIN(4096 - (size_t)rmd.rmd1.bcnt, size);
-                RTGCPHYS32 rbadr = PHYSADDR(pData, rmd.rmd0.rbadr);
+                RTGCPHYS32 rbadr = PHYSADDR(pThis, rmd.rmd0.rbadr);
 #if 0
-                if (pData->fPrivIfEnabled)
+                if (pThis->fPrivIfEnabled)
                 {
-                    uint8_t *pb = (uint8_t*)pData->CTX_SUFF(pSharedMMIO)
-                                + rbadr - pData->GCRDRA + pData->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
+                    uint8_t *pb = (uint8_t*)pThis->CTX_SUFF(pSharedMMIO)
+                                + rbadr - pThis->GCRDRA + pThis->CTX_SUFF(pSharedMMIO)->V.V1.offRxDescriptors;
                     memcpy(pb, src, count);
                 }
@@ -1926 +1926 @@
             {
                 rmd.rmd1.enp  = 1;
-                rmd.rmd1.pam  = !CSR_PROM(pData) && is_padr;
-                rmd.rmd1.lafm = !CSR_PROM(pData) && is_ladr;
-                rmd.rmd1.bam  = !CSR_PROM(pData) && is_bcast;
+                rmd.rmd1.pam  = !CSR_PROM(pThis) && is_padr;
+                rmd.rmd1.lafm = !CSR_PROM(pThis) && is_ladr;
+                rmd.rmd1.bam  = !CSR_PROM(pThis) && is_bcast;
                 rmd.rmd2.mcnt = pkt_size;
 
-                STAM_REL_COUNTER_ADD(&pData->StatReceiveBytes, pkt_size);
+                STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, pkt_size);
             }
             else
@@ -1942 +1942 @@
 
             /* write back, clear the own bit */
-            pcnetRmdStorePassHost(pData, &rmd, PHYSADDR(pData, crda));
-
-            pData->aCSR[0] |= 0x0400;
+            pcnetRmdStorePassHost(pThis, &rmd, PHYSADDR(pThis, crda));
+
+            pThis->aCSR[0] |= 0x0400;
 
             Log(("#%d RCVRC=%d CRDA=%#010x BLKS=%d\n", PCNET_INST_NR,
-                 CSR_RCVRC(pData), PHYSADDR(pData, CSR_CRDA(pData)), pktcount));
+                 CSR_RCVRC(pThis), PHYSADDR(pThis, CSR_CRDA(pThis)), pktcount));
 #ifdef PCNET_DEBUG_RMD
             PRINT_RMD(&rmd);
@@ -1954 +1954 @@
             while (pktcount--)
             {
-                if (CSR_RCVRC(pData) < 2)
-                    CSR_RCVRC(pData) = CSR_RCVRL(pData);
+                if (CSR_RCVRC(pThis) < 2)
+                    CSR_RCVRC(pThis) = CSR_RCVRL(pThis);
                 else
-                    CSR_RCVRC(pData)--;
+                    CSR_RCVRC(pThis)--;
             }
             /* guest driver is owner: force repoll of current and next RDTEs */
-            CSR_CRST(pData) = 0;
+            CSR_CRST(pThis) = 0;
         }
     }
@@ -1966 +1966 @@
     /* see description of TXDPOLL:
      * ``transmit polling will take place following receive activities'' */
-    pcnetPollRxTx(pData);
-    pcnetUpdateIrq(pData);
+    pcnetPollRxTx(pThis);
+    pcnetUpdateIrq(pThis);
 }
 
@@ -1976 +1976 @@
  * @returns false if the link is down.
  */
-DECLINLINE(bool) pcnetIsLinkUp(PCNetState *pData)
-{
-    return pData->pDrv && !pData->fLinkTempDown && pData->fLinkUp;
+DECLINLINE(bool) pcnetIsLinkUp(PCNetState *pThis)
+{
+    return pThis->pDrv && !pThis->fLinkTempDown && pThis->fLinkUp;
 }
 
@@ -1993 +1993 @@
 static DECLCALLBACK(bool) pcnetXmitQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     NOREF(pItem);
 
     /* Clear counter .*/
-    ASMAtomicAndU32(&pData->cPendingSends, 0);
+    ASMAtomicAndU32(&pThis->cPendingSends, 0);
 #ifdef PCNET_QUEUE_SEND_PACKETS
-    int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertReleaseRC(rc);
-    pcnetSyncTransmit(pData);
-    PDMCritSectLeave(&pData->CritSect);
+    pcnetSyncTransmit(pThis);
+    PDMCritSectLeave(&pThis->CritSect);
 #else
-    int rc = RTSemEventSignal(pData->hSendEventSem);
+    int rc = RTSemEventSignal(pThis->hSendEventSem);
     AssertRC(rc);
 #endif
@@ -2015 +2015 @@
  * This is done as a precaution against mess left over by on
  */
-DECLINLINE(void) pcnetXmitScrapFrame(PCNetState *pData)
-{
-    pData->pvSendFrame = NULL;
-    pData->cbSendFrame = 0;
+DECLINLINE(void) pcnetXmitScrapFrame(PCNetState *pThis)
+{
+    pThis->pvSendFrame = NULL;
+    pThis->cbSendFrame = 0;
 }
 
@@ -2025 +2025 @@
  * Reads the first part of a frame
  */
-DECLINLINE(void) pcnetXmitRead1st(PCNetState *pData, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame)
-{
-    Assert(PDMCritSectIsOwner(&pData->CritSect));
-    Assert(cbFrame < sizeof(pData->abSendBuf));
+DECLINLINE(void) pcnetXmitRead1st(PCNetState *pThis, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame)
+{
+    Assert(PDMCritSectIsOwner(&pThis->CritSect));
+    Assert(cbFrame < sizeof(pThis->abSendBuf));
 
 #ifdef PCNET_QUEUE_SEND_PACKETS
-    AssertRelease(pData->cXmitRingBufPending < PCNET_MAX_XMIT_SLOTS-1);
-    pData->pvSendFrame = pData->apXmitRingBuffer[pData->iXmitRingBufProd];
+    AssertRelease(pThis->cXmitRingBufPending < PCNET_MAX_XMIT_SLOTS-1);
+    pThis->pvSendFrame = pThis->apXmitRingBuffer[pThis->iXmitRingBufProd];
 #else
-    pData->pvSendFrame = pData->abSendBuf;
-#endif
-    PDMDevHlpPhysRead(pData->CTX_SUFF(pDevIns), GCPhysFrame, pData->pvSendFrame, cbFrame);
-    pData->cbSendFrame = cbFrame;
+    pThis->pvSendFrame = pThis->abSendBuf;
+#endif
+    PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame, pThis->pvSendFrame, cbFrame);
+    pThis->cbSendFrame = cbFrame;
 }
 
@@ -2044 +2044 @@
  * Reads more into the current frame.
  */
-DECLINLINE(void) pcnetXmitReadMore(PCNetState *pData, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame)
-{
-    Assert(pData->cbSendFrame + cbFrame <= MAX_FRAME);
-    PDMDevHlpPhysRead(pData->CTX_SUFF(pDevIns), GCPhysFrame, pData->pvSendFrame + pData->cbSendFrame, cbFrame);
-    pData->cbSendFrame += cbFrame;
+DECLINLINE(void) pcnetXmitReadMore(PCNetState *pThis, RTGCPHYS32 GCPhysFrame, const unsigned cbFrame)
+{
+    Assert(pThis->cbSendFrame + cbFrame <= MAX_FRAME);
+    PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhysFrame, pThis->pvSendFrame + pThis->cbSendFrame, cbFrame);
+    pThis->cbSendFrame += cbFrame;
 }
 
@@ -2056 +2056 @@
  * If we've reached the maxium number of frames, they will be flushed.
  */
-DECLINLINE(int) pcnetXmitCompleteFrame(PCNetState *pData)
+DECLINLINE(int) pcnetXmitCompleteFrame(PCNetState *pThis)
 {
 #ifdef PCNET_QUEUE_SEND_PACKETS
-    Assert(PDMCritSectIsOwner(&pData->CritSect));
-    AssertRelease(pData->cXmitRingBufPending < PCNET_MAX_XMIT_SLOTS-1);
-    Assert(!pData->cbXmitRingBuffer[pData->iXmitRingBufProd]);
-
-    pData->cbXmitRingBuffer[pData->iXmitRingBufProd] = (uint16_t)pData->cbSendFrame;
-    pData->iXmitRingBufProd = (pData->iXmitRingBufProd+1) & PCNET_MAX_XMIT_SLOTS_MASK;
-    ASMAtomicIncS32(&pData->cXmitRingBufPending);
-
-    int rc = RTSemEventSignal(pData->hSendEventSem);
+    Assert(PDMCritSectIsOwner(&pThis->CritSect));
+    AssertRelease(pThis->cXmitRingBufPending < PCNET_MAX_XMIT_SLOTS-1);
+    Assert(!pThis->cbXmitRingBuffer[pThis->iXmitRingBufProd]);
+
+    pThis->cbXmitRingBuffer[pThis->iXmitRingBufProd] = (uint16_t)pThis->cbSendFrame;
+    pThis->iXmitRingBufProd = (pThis->iXmitRingBufProd+1) & PCNET_MAX_XMIT_SLOTS_MASK;
+    ASMAtomicIncS32(&pThis->cXmitRingBufPending);
+
+    int rc = RTSemEventSignal(pThis->hSendEventSem);
     AssertRC(rc);
 
@@ -2074 +2074 @@
     /* Don't hold the critical section while transmitting data. */
     /** @note also avoids deadlocks with NAT as it can call us right back. */
-    PDMCritSectLeave(&pData->CritSect);
-
-    STAM_PROFILE_ADV_START(&pData->StatTransmitSend, a);
-    if (pData->cbSendFrame > 70) /* unqualified guess */
-        pData->Led.Asserted.s.fWriting = pData->Led.Actual.s.fWriting = 1;
-
-    pData->pDrv->pfnSend(pData->pDrv, pData->pvSendFrame, pData->cbSendFrame);
-    STAM_REL_COUNTER_ADD(&pData->StatTransmitBytes, pData->cbSendFrame);
-    pData->Led.Actual.s.fWriting = 0;
-    STAM_PROFILE_ADV_STOP(&pData->StatTransmitSend, a);
-
-    return PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    PDMCritSectLeave(&pThis->CritSect);
+
+    STAM_PROFILE_ADV_START(&pThis->StatTransmitSend, a);
+    if (pThis->cbSendFrame > 70) /* unqualified guess */
+        pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
+
+    pThis->pDrv->pfnSend(pThis->pDrv, pThis->pvSendFrame, pThis->cbSendFrame);
+    STAM_REL_COUNTER_ADD(&pThis->StatTransmitBytes, pThis->cbSendFrame);
+    pThis->Led.Actual.s.fWriting = 0;
+    STAM_PROFILE_ADV_STOP(&pThis->StatTransmitSend, a);
+
+    return PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
 #endif
 }
@@ -2093 +2093 @@
  * Fails a TMD with a link down error.
  */
-static void pcnetXmitFailTMDLinkDown(PCNetState *pData, TMD *pTmd)
+static void pcnetXmitFailTMDLinkDown(PCNetState *pThis, TMD *pTmd)
 {
     /* make carrier error - hope this is correct. */
-    pData->cLinkDownReported++;
+    pThis->cLinkDownReported++;
     pTmd->tmd2.lcar = pTmd->tmd1.err = 1;
-    pData->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR */
-    pData->Led.Asserted.s.fError = pData->Led.Actual.s.fError = 1;
+    pThis->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR */
+    pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
     Log(("#%d pcnetTransmit: Signaling send error. swstyle=%#x\n",
-         PCNET_INST_NR, pData->aBCR[BCR_SWS]));
+         PCNET_INST_NR, pThis->aBCR[BCR_SWS]));
 }
 
@@ -2107 +2107 @@
  * Fails a TMD with a generic error.
  */
-static void pcnetXmitFailTMDGeneric(PCNetState *pData, TMD *pTmd)
+static void pcnetXmitFailTMDGeneric(PCNetState *pThis, TMD *pTmd)
 {
     /* make carrier error - hope this is correct. */
     pTmd->tmd2.lcar = pTmd->tmd1.err = 1;
-    pData->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR */
-    pData->Led.Asserted.s.fError = pData->Led.Actual.s.fError = 1;
+    pThis->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR */
+    pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
     Log(("#%d pcnetTransmit: Signaling send error. swstyle=%#x\n",
-         PCNET_INST_NR, pData->aBCR[BCR_SWS]));
+         PCNET_INST_NR, pThis->aBCR[BCR_SWS]));
 }
 
@@ -2121 +2121 @@
  * Transmit a loopback frame.
  */
-DECLINLINE(void) pcnetXmitLoopbackFrame(PCNetState *pData)
-{
-    pData->Led.Asserted.s.fReading = pData->Led.Actual.s.fReading = 1;
-    if (HOST_IS_OWNER(CSR_CRST(pData)))
-        pcnetRdtePoll(pData);
-
-    Assert(pData->pvSendFrame);
-    pcnetReceiveNoSync(pData, (const uint8_t *)pData->pvSendFrame, pData->cbSendFrame);
-    pcnetXmitScrapFrame(pData);
-    pData->Led.Actual.s.fReading = 0;
+DECLINLINE(void) pcnetXmitLoopbackFrame(PCNetState *pThis)
+{
+    pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
+    if (HOST_IS_OWNER(CSR_CRST(pThis)))
+        pcnetRdtePoll(pThis);
+
+    Assert(pThis->pvSendFrame);
+    pcnetReceiveNoSync(pThis, (const uint8_t *)pThis->pvSendFrame, pThis->cbSendFrame);
+    pcnetXmitScrapFrame(pThis);
+    pThis->Led.Actual.s.fReading = 0;
 }
 
@@ -2136 +2136 @@
  * Flushes queued frames.
  */
-DECLINLINE(void) pcnetXmitFlushFrames(PCNetState *pData)
-{
-    pcnetXmitQueueConsumer(pData->CTX_SUFF(pDevIns), NULL);
+DECLINLINE(void) pcnetXmitFlushFrames(PCNetState *pThis)
+{
+    pcnetXmitQueueConsumer(pThis->CTX_SUFF(pDevIns), NULL);
 }
 
@@ -2148 +2148 @@
  * Try to transmit frames
  */
-static void pcnetTransmit(PCNetState *pData)
-{
-    if (RT_UNLIKELY(!CSR_TXON(pData)))
-    {
-        pData->aCSR[0] &= ~0x0008; /* Clear TDMD */
+static void pcnetTransmit(PCNetState *pThis)
+{
+    if (RT_UNLIKELY(!CSR_TXON(pThis)))
+    {
+        pThis->aCSR[0] &= ~0x0008; /* Clear TDMD */
         return;
     }
@@ -2160 +2160 @@
      */
     TMD tmd;
-    if (!pcnetTdtePoll(pData, &tmd))
+    if (!pcnetTdtePoll(pThis, &tmd))
         return;
 
@@ -2166 +2166 @@
      * Clear TDMD.
      */
-    pData->aCSR[0] &= ~0x0008;
+    pThis->aCSR[0] &= ~0x0008;
 
     /*
@@ -2172 +2172 @@
      */
 #ifdef IN_RING3
-    pcnetXmitFlushFrames(pData);
+    pcnetXmitFlushFrames(pThis);
 #else
 # if 1
-    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pXmitQueue));
+    PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pThis->CTX_SUFF(pXmitQueue));
     if (RT_UNLIKELY(pItem))
-        PDMQueueInsert(pData->CTX_SUFF(pXmitQueue), pItem);
+        PDMQueueInsert(pThis->CTX_SUFF(pXmitQueue), pItem);
 # else
-    if (ASMAtomicIncU32(&pData->cPendingSends) < 16)
-    {
-        PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pData->CTX_SUFF(pXmitQueue));
+    if (ASMAtomicIncU32(&pThis->cPendingSends) < 16)
+    {
+        PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pThis->CTX_SUFF(pXmitQueue));
         if (RT_UNLIKELY(pItem))
-            PDMQueueInsert(pData->CTX_SUFF(pXmitQueue), pItem);
+            PDMQueueInsert(pThis->CTX_SUFF(pXmitQueue), pItem);
     }
     else
-        PDMQueueFlush(pData->CTX_SUFF(pXmitQueue));
+        PDMQueueFlush(pThis->CTX_SUFF(pXmitQueue));
 # endif
 #endif
@@ -2197 +2197 @@
  */
 #ifdef PCNET_QUEUE_SEND_PACKETS
-static int pcnetAsyncTransmit(PCNetState *pData)
-{
-    Assert(PDMCritSectIsOwner(&pData->CritSect));
+static int pcnetAsyncTransmit(PCNetState *pThis)
+{
+    Assert(PDMCritSectIsOwner(&pThis->CritSect));
     size_t cb;
 
-    while ((pData->cXmitRingBufPending > 0))
-    {
-        cb = pData->cbXmitRingBuffer[pData->iXmitRingBufCons];
+    while ((pThis->cXmitRingBufPending > 0))
+    {
+        cb = pThis->cbXmitRingBuffer[pThis->iXmitRingBufCons];
 
         /* Don't hold the critical section while transmitting data. */
         /** @note also avoids deadlocks with NAT as it can call us right back. */
-        PDMCritSectLeave(&pData->CritSect);
-
-        STAM_PROFILE_ADV_START(&pData->StatTransmitSend, a);
+        PDMCritSectLeave(&pThis->CritSect);
+
+        STAM_PROFILE_ADV_START(&pThis->StatTransmitSend, a);
         if (cb > 70) /* unqualified guess */
-            pData->Led.Asserted.s.fWriting = pData->Led.Actual.s.fWriting = 1;
-
-        pData->pDrv->pfnSend(pData->pDrv, pData->apXmitRingBuffer[pData->iXmitRingBufCons], cb);
-        STAM_REL_COUNTER_ADD(&pData->StatTransmitBytes, cb);
-        pData->Led.Actual.s.fWriting = 0;
-        STAM_PROFILE_ADV_STOP(&pData->StatTransmitSend, a);
-
-        int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+            pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1;
+
+        pThis->pDrv->pfnSend(pThis->pDrv, pThis->apXmitRingBuffer[pThis->iXmitRingBufCons], cb);
+        STAM_REL_COUNTER_ADD(&pThis->StatTransmitBytes, cb);
+        pThis->Led.Actual.s.fWriting = 0;
+        STAM_PROFILE_ADV_STOP(&pThis->StatTransmitSend, a);
+
+        int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
         AssertReleaseRC(rc);
 
-        pData->cbXmitRingBuffer[pData->iXmitRingBufCons] = 0;
-        pData->iXmitRingBufCons = (pData->iXmitRingBufCons+1) & PCNET_MAX_XMIT_SLOTS_MASK;
-        ASMAtomicDecS32(&pData->cXmitRingBufPending);
+        pThis->cbXmitRingBuffer[pThis->iXmitRingBufCons] = 0;
+        pThis->iXmitRingBufCons = (pThis->iXmitRingBufCons+1) & PCNET_MAX_XMIT_SLOTS_MASK;
+        ASMAtomicDecS32(&pThis->cXmitRingBufPending);
     }
     return VINF_SUCCESS;
 }
 
-static int pcnetSyncTransmit(PCNetState *pData)
+static int pcnetSyncTransmit(PCNetState *pThis)
 #else
-static int pcnetAsyncTransmit(PCNetState *pData)
+static int pcnetAsyncTransmit(PCNetState *pThis)
 #endif
 {
     unsigned cFlushIrq = 0;
 
-    Assert(PDMCritSectIsOwner(&pData->CritSect));
-
-    if (RT_UNLIKELY(!CSR_TXON(pData)))
-    {
-        pData->aCSR[0] &= ~0x0008; /* Clear TDMD */
+    Assert(PDMCritSectIsOwner(&pThis->CritSect));
+
+    if (RT_UNLIKELY(!CSR_TXON(pThis)))
+    {
+        pThis->aCSR[0] &= ~0x0008; /* Clear TDMD */
         return VINF_SUCCESS;
     }
@@ -2247 +2247 @@
      * Iterate the transmit descriptors.
      */
-    STAM_PROFILE_ADV_START(&pData->StatTransmit, a);
+    STAM_PROFILE_ADV_START(&pThis->StatTransmit, a);
     do
     {
@@ -2254 +2254 @@
 #endif
         TMD tmd;
-        if (!pcnetTdtePoll(pData, &tmd))
+        if (!pcnetTdtePoll(pThis, &tmd))
             break;
 
         /* Don't continue sending packets when the link is down. */
-        if (RT_UNLIKELY(   !pcnetIsLinkUp(pData)
-                        &&  pData->cLinkDownReported > PCNET_MAX_LINKDOWN_REPORTED)
+        if (RT_UNLIKELY(   !pcnetIsLinkUp(pThis)
+                        &&  pThis->cLinkDownReported > PCNET_MAX_LINKDOWN_REPORTED)
             )
             break;
 
 #ifdef PCNET_DEBUG_TMD
-        Log2(("#%d TMDLOAD %#010x\n", PCNET_INST_NR, PHYSADDR(pData, CSR_CXDA(pData))));
+        Log2(("#%d TMDLOAD %#010x\n", PCNET_INST_NR, PHYSADDR(pThis, CSR_CXDA(pThis))));
         PRINT_TMD(&tmd);
 #endif
-        pcnetXmitScrapFrame(pData);
+        pcnetXmitScrapFrame(pThis);
 
         /*
@@ -2275 +2275 @@
         {
             const unsigned cb = 4096 - tmd.tmd1.bcnt;
-            Log(("#%d pcnetTransmit: stp&enp: cb=%d xmtrc=%#x\n", PCNET_INST_NR, cb, CSR_XMTRC(pData)));
-
-            if (RT_LIKELY(pcnetIsLinkUp(pData) || CSR_LOOP(pData)))
+            Log(("#%d pcnetTransmit: stp&enp: cb=%d xmtrc=%#x\n", PCNET_INST_NR, cb, CSR_XMTRC(pThis)));
+
+            if (RT_LIKELY(pcnetIsLinkUp(pThis) || CSR_LOOP(pThis)))
             {
                 /* From the manual: ``A zero length buffer is acceptable as
@@ -2285 +2285 @@
                 if (RT_LIKELY(cb <= MAX_FRAME))
                 {
-                    pcnetXmitRead1st(pData, PHYSADDR(pData, tmd.tmd0.tbadr), cb);
-                    if (CSR_LOOP(pData))
-                        pcnetXmitLoopbackFrame(pData);
+                    pcnetXmitRead1st(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb);
+                    if (CSR_LOOP(pThis))
+                        pcnetXmitLoopbackFrame(pThis);
                     else
                     {
-                        int rc = pcnetXmitCompleteFrame(pData);
+                        int rc = pcnetXmitCompleteFrame(pThis);
                         AssertRCReturn(rc, rc);
                     }
@@ -2308 +2308 @@
                      * buffer.'' */
                     LogRel(("PCNet#%d: pcnetAsyncTransmit: illegal 4kb frame -> ignoring\n", PCNET_INST_NR));
-                    pcnetTmdStorePassHost(pData, &tmd, PHYSADDR(pData, CSR_CXDA(pData)));
+                    pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
                     break;
                 }
@@ -2317 +2317 @@
                     LogRel(("PCNet#%d: pcnetAsyncTransmit: illegal 4kb frame -> signalling error\n", PCNET_INST_NR));
 
-                    pcnetXmitFailTMDGeneric(pData, &tmd);
+                    pcnetXmitFailTMDGeneric(pThis, &tmd);
                 }
             }
             else
-                pcnetXmitFailTMDLinkDown(pData, &tmd);
+                pcnetXmitFailTMDLinkDown(pThis, &tmd);
 
             /* Write back the TMD and pass it to the host (clear own bit). */
-            pcnetTmdStorePassHost(pData, &tmd, PHYSADDR(pData, CSR_CXDA(pData)));
+            pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
 
             /* advance the ring counter register */
-            if (CSR_XMTRC(pData) < 2)
-                CSR_XMTRC(pData) = CSR_XMTRL(pData);
+            if (CSR_XMTRC(pThis) < 2)
+                CSR_XMTRC(pThis) = CSR_XMTRL(pThis);
             else
-                CSR_XMTRC(pData)--;
+                CSR_XMTRC(pThis)--;
         }
         else if (tmd.tmd1.stp)
@@ -2339 +2339 @@
             bool fDropFrame = false;
             unsigned cb = 4096 - tmd.tmd1.bcnt;
-            pcnetXmitRead1st(pData, PHYSADDR(pData, tmd.tmd0.tbadr), cb);
+            pcnetXmitRead1st(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb);
             for (;;)
             {
@@ -2346 +2346 @@
                  */
 #ifdef LOG_ENABLED
-                const uint32_t iStart = CSR_XMTRC(pData);
-#endif
-                const uint32_t GCPhysPrevTmd = PHYSADDR(pData, CSR_CXDA(pData));
-                if (CSR_XMTRC(pData) < 2)
-                    CSR_XMTRC(pData) = CSR_XMTRL(pData);
+                const uint32_t iStart = CSR_XMTRC(pThis);
+#endif
+                const uint32_t GCPhysPrevTmd = PHYSADDR(pThis, CSR_CXDA(pThis));
+                if (CSR_XMTRC(pThis) < 2)
+                    CSR_XMTRC(pThis) = CSR_XMTRL(pThis);
                 else
-                    CSR_XMTRC(pData)--;
+                    CSR_XMTRC(pThis)--;
 
                 TMD dummy;
-                if (!pcnetTdtePoll(pData, &dummy))
+                if (!pcnetTdtePoll(pThis, &dummy))
                 {
                     /*
@@ -2361 +2361 @@
                      */
                     tmd.tmd2.buff = tmd.tmd2.uflo = tmd.tmd1.err = 1;
-                    pData->aCSR[0] |= 0x0200;        /* set TINT */
-                    if (!CSR_DXSUFLO(pData))         /* stop on xmit underflow */
-                        pData->aCSR[0] &= ~0x0010;   /* clear TXON */
-                    pcnetTmdStorePassHost(pData, &tmd, GCPhysPrevTmd);
+                    pThis->aCSR[0] |= 0x0200;        /* set TINT */
+                    if (!CSR_DXSUFLO(pThis))         /* stop on xmit underflow */
+                        pThis->aCSR[0] &= ~0x0010;   /* clear TXON */
+                    pcnetTmdStorePassHost(pThis, &tmd, GCPhysPrevTmd);
                     AssertMsgFailed(("pcnetTransmit: Underflow!!!\n"));
                     break;
@@ -2370 +2370 @@
 
                 /* release & save the previous tmd, pass it to the host */
-                pcnetTmdStorePassHost(pData, &tmd, GCPhysPrevTmd);
+                pcnetTmdStorePassHost(pThis, &tmd, GCPhysPrevTmd);
 
                 /*
@@ -2378 +2378 @@
                 cBuffers++;
 #endif
-                pcnetTmdLoad(pData, &tmd, PHYSADDR(pData, CSR_CXDA(pData)), false);
+                pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
                 cb = 4096 - tmd.tmd1.bcnt;
-                if (    pData->cbSendFrame + cb < MAX_FRAME
+                if (    pThis->cbSendFrame + cb < MAX_FRAME
                     &&  !fDropFrame)
-                    pcnetXmitReadMore(pData, PHYSADDR(pData, tmd.tmd0.tbadr), cb);
+                    pcnetXmitReadMore(pThis, PHYSADDR(pThis, tmd.tmd0.tbadr), cb);
                 else
                 {
                     AssertMsg(fDropFrame, ("pcnetTransmit: Frame is too big!!! %d bytes\n",
-                                pData->cbSendFrame + cb));
+                                pThis->cbSendFrame + cb));
                     fDropFrame = true;
                 }
@@ -2392 +2392 @@
                 {
                     Log(("#%d pcnetTransmit: stp: cb=%d xmtrc=%#x-%#x\n", PCNET_INST_NR,
-                                pData->cbSendFrame, iStart, CSR_XMTRC(pData)));
-                    if (pcnetIsLinkUp(pData) && !fDropFrame)
+                                pThis->cbSendFrame, iStart, CSR_XMTRC(pThis)));
+                    if (pcnetIsLinkUp(pThis) && !fDropFrame)
                     {
-                        int rc = pcnetXmitCompleteFrame(pData);
+                        int rc = pcnetXmitCompleteFrame(pThis);
                         AssertRCReturn(rc, rc);
                     }
-                    else if (CSR_LOOP(pData) && !fDropFrame)
-                        pcnetXmitLoopbackFrame(pData);
+                    else if (CSR_LOOP(pThis) && !fDropFrame)
+                        pcnetXmitLoopbackFrame(pThis);
                     else
                     {
                         if (!fDropFrame)
-                            pcnetXmitFailTMDLinkDown(pData, &tmd);
-                        pcnetXmitScrapFrame(pData);
+                            pcnetXmitFailTMDLinkDown(pThis, &tmd);
+                        pcnetXmitScrapFrame(pThis);
                     }
 
                     /* Write back the TMD, pass it to the host */
-                    pcnetTmdStorePassHost(pData, &tmd, PHYSADDR(pData, CSR_CXDA(pData)));
+                    pcnetTmdStorePassHost(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)));
 
                     /* advance the ring counter register */
-                    if (CSR_XMTRC(pData) < 2)
-                        CSR_XMTRC(pData) = CSR_XMTRL(pData);
+                    if (CSR_XMTRC(pThis) < 2)
+                        CSR_XMTRC(pThis) = CSR_XMTRL(pThis);
                     else
-                        CSR_XMTRC(pData)--;
+                        CSR_XMTRC(pThis)--;
                     break;
                 }
@@ -2430 +2430 @@
         }
         /* Update TDMD, TXSTRT and TINT. */
-        pData->aCSR[0] &= ~0x0008;       /* clear TDMD */
-
-        pData->aCSR[4] |=  0x0008;       /* set TXSTRT */
-        if (    !CSR_TOKINTD(pData)      /* Transmit OK Interrupt Disable, no infl. on errors. */
-            ||  (CSR_LTINTEN(pData) && tmd.tmd1.ltint)
+        pThis->aCSR[0] &= ~0x0008;       /* clear TDMD */
+
+        pThis->aCSR[4] |=  0x0008;       /* set TXSTRT */
+        if (    !CSR_TOKINTD(pThis)      /* Transmit OK Interrupt Disable, no infl. on errors. */
+            ||  (CSR_LTINTEN(pThis) && tmd.tmd1.ltint)
             ||  tmd.tmd1.err)
         {
@@ -2442 +2442 @@
         /** @todo should we continue after an error (tmd.tmd1.err) or not? */
 
-        STAM_COUNTER_INC(&pData->aStatXmitChainCounts[RT_MIN(cBuffers,
-                                                      RT_ELEMENTS(pData->aStatXmitChainCounts)) - 1]);
-    } while (CSR_TXON(pData));          /* transfer on */
+        STAM_COUNTER_INC(&pThis->aStatXmitChainCounts[RT_MIN(cBuffers,
+                                                      RT_ELEMENTS(pThis->aStatXmitChainCounts)) - 1]);
+    } while (CSR_TXON(pThis));          /* transfer on */
 
     if (cFlushIrq)
     {
-        STAM_COUNTER_INC(&pData->aStatXmitFlush[RT_MIN(cFlushIrq, RT_ELEMENTS(pData->aStatXmitFlush)) - 1]);
-        pData->aCSR[0] |= 0x0200;    /* set TINT */
-        pcnetUpdateIrq(pData);
-    }
-
-    STAM_PROFILE_ADV_STOP(&pData->StatTransmit, a);
+        STAM_COUNTER_INC(&pThis->aStatXmitFlush[RT_MIN(cFlushIrq, RT_ELEMENTS(pThis->aStatXmitFlush)) - 1]);
+        pThis->aCSR[0] |= 0x0200;    /* set TINT */
+        pcnetUpdateIrq(pThis);
+    }
+
+    STAM_PROFILE_ADV_STOP(&pThis->StatTransmit, a);
 
     return VINF_SUCCESS;
@@ -2468 +2468 @@
 static DECLCALLBACK(int) pcnetAsyncSendThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
 
     /*
@@ -2493 +2493 @@
          * to leave the running state.
          */
-        int rc = RTSemEventWait(pData->hSendEventSem, RT_INDEFINITE_WAIT);
+        int rc = RTSemEventWait(pThis->hSendEventSem, RT_INDEFINITE_WAIT);
         AssertRCReturn(rc, rc);
         if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
@@ -2502 +2502 @@
          * suspended while waiting for the critical section.
          */
-        rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+        rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
         AssertReleaseRCReturn(rc, rc);
 
         if (pThread->enmState == PDMTHREADSTATE_RUNNING)
         {
-            rc = pcnetAsyncTransmit(pData);
+            rc = pcnetAsyncTransmit(pThis);
             AssertReleaseRC(rc);
         }
 
-        PDMCritSectLeave(&pData->CritSect);
+        PDMCritSectLeave(&pThis->CritSect);
     }
 
@@ -2528 +2528 @@
 static DECLCALLBACK(int) pcnetAsyncSendThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-    return RTSemEventSignal(pData->hSendEventSem);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+    return RTSemEventSignal(pThis->hSendEventSem);
 }
 
@@ -2537 +2537 @@
  * Poll for changes in RX and TX descriptor rings.
  */
-static void pcnetPollRxTx(PCNetState *pData)
-{
-    if (CSR_RXON(pData))
-        if (HOST_IS_OWNER(CSR_CRST(pData)))     /* Only poll RDTEs if none available */
-            pcnetRdtePoll(pData);
-
-    if (CSR_TDMD(pData) || (CSR_TXON(pData) && !CSR_DPOLL(pData)))
-        pcnetTransmit(pData);
+static void pcnetPollRxTx(PCNetState *pThis)
+{
+    if (CSR_RXON(pThis))
+        if (HOST_IS_OWNER(CSR_CRST(pThis)))     /* Only poll RDTEs if none available */
+            pcnetRdtePoll(pThis);
+
+    if (CSR_TDMD(pThis) || (CSR_TXON(pThis) && !CSR_DPOLL(pThis)))
+        pcnetTransmit(pThis);
 }
 
@@ -2553 +2553 @@
  * @thread EMT, TAP.
  */
-static void pcnetPollTimerStart(PCNetState *pData)
-{
-    TMTimerSetMillies(pData->CTX_SUFF(pTimerPoll), 2);
+static void pcnetPollTimerStart(PCNetState *pThis)
+{
+    TMTimerSetMillies(pThis->CTX_SUFF(pTimerPoll), 2);
 }
 
@@ -2563 +2563 @@
  * @thread EMT.
  */
-static void pcnetPollTimer(PCNetState *pData)
-{
-    STAM_PROFILE_ADV_START(&pData->StatPollTimer, a);
+static void pcnetPollTimer(PCNetState *pThis)
+{
+    STAM_PROFILE_ADV_START(&pThis->StatPollTimer, a);
 
 #ifdef LOG_ENABLED
     TMD dummy;
-    if (CSR_STOP(pData) || CSR_SPND(pData))
+    if (CSR_STOP(pThis) || CSR_SPND(pThis))
         Log2(("#%d pcnetPollTimer time=%#010llx CSR_STOP=%d CSR_SPND=%d\n",
-             PCNET_INST_NR, RTTimeMilliTS(), CSR_STOP(pData), CSR_SPND(pData)));
+             PCNET_INST_NR, RTTimeMilliTS(), CSR_STOP(pThis), CSR_SPND(pThis)));
     else
         Log2(("#%d pcnetPollTimer time=%#010llx TDMD=%d TXON=%d POLL=%d TDTE=%d TDRA=%#x\n",
-             PCNET_INST_NR, RTTimeMilliTS(), CSR_TDMD(pData), CSR_TXON(pData),
-             !CSR_DPOLL(pData), pcnetTdtePoll(pData, &dummy), pData->GCTDRA));
+             PCNET_INST_NR, RTTimeMilliTS(), CSR_TDMD(pThis), CSR_TXON(pThis),
+             !CSR_DPOLL(pThis), pcnetTdtePoll(pThis, &dummy), pThis->GCTDRA));
     Log2(("#%d pcnetPollTimer: CSR_CXDA=%#x CSR_XMTRL=%d CSR_XMTRC=%d\n",
-          PCNET_INST_NR, CSR_CXDA(pData), CSR_XMTRL(pData), CSR_XMTRC(pData)));
+          PCNET_INST_NR, CSR_CXDA(pThis), CSR_XMTRL(pThis), CSR_XMTRC(pThis)));
 #endif
 #ifdef PCNET_DEBUG_TMD
-    if (CSR_CXDA(pData))
+    if (CSR_CXDA(pThis))
     {
         TMD tmd;
-        pcnetTmdLoad(pData, &tmd, PHYSADDR(pData, CSR_CXDA(pData)), false);
-        Log2(("#%d pcnetPollTimer: TMDLOAD %#010x\n", PCNET_INST_NR, PHYSADDR(pData, CSR_CXDA(pData))));
+        pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, CSR_CXDA(pThis)), false);
+        Log2(("#%d pcnetPollTimer: TMDLOAD %#010x\n", PCNET_INST_NR, PHYSADDR(pThis, CSR_CXDA(pThis))));
         PRINT_TMD(&tmd);
     }
 #endif
-    if (CSR_TDMD(pData))
-        pcnetTransmit(pData);
-
-    pcnetUpdateIrq(pData);
+    if (CSR_TDMD(pThis))
+        pcnetTransmit(pThis);
+
+    pcnetUpdateIrq(pThis);
 
     /* If the receive thread is waiting for new descriptors, poll TX/RX even if polling
      * disabled. We wouldn't need to poll for new TX descriptors in that case but it will
      * not hurt as waiting for RX descriptors should occur very seldom */
-    if (RT_LIKELY(   !CSR_STOP(pData)
-                  && !CSR_SPND(pData)
-                  && (   !CSR_DPOLL(pData)
-                      || pData->fMaybeOutOfSpace)))
+    if (RT_LIKELY(   !CSR_STOP(pThis)
+                  && !CSR_SPND(pThis)
+                  && (   !CSR_DPOLL(pThis)
+                      || pThis->fMaybeOutOfSpace)))
     {
         /* We ensure that we poll at least every 2ms (500Hz) but not more often than
@@ -2608 +2608 @@
          * interval is the default polling interval of the PCNet card (65536/33MHz). */
 #ifdef PCNET_NO_POLLING
-        pcnetPollRxTx(pData);
+        pcnetPollRxTx(pThis);
 #else
-        uint64_t u64Now = TMTimerGet(pData->CTX_SUFF(pTimerPoll));
-        if (RT_UNLIKELY(u64Now - pData->u64LastPoll > 200000))
+        uint64_t u64Now = TMTimerGet(pThis->CTX_SUFF(pTimerPoll));
+        if (RT_UNLIKELY(u64Now - pThis->u64LastPoll > 200000))
         {
-            pData->u64LastPoll = u64Now;
-            pcnetPollRxTx(pData);
+            pThis->u64LastPoll = u64Now;
+            pcnetPollRxTx(pThis);
         }
-        if (!TMTimerIsActive(pData->CTX_SUFF(pTimerPoll)))
-            pcnetPollTimerStart(pData);
-#endif
-    }
-    STAM_PROFILE_ADV_STOP(&pData->StatPollTimer, a);
-}
-
-
-static int pcnetCSRWriteU16(PCNetState *pData, uint32_t u32RAP, uint32_t val)
+        if (!TMTimerIsActive(pThis->CTX_SUFF(pTimerPoll)))
+            pcnetPollTimerStart(pThis);
+#endif
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->StatPollTimer, a);
+}
+
+
+static int pcnetCSRWriteU16(PCNetState *pThis, uint32_t u32RAP, uint32_t val)
 {
     int      rc  = VINF_SUCCESS;
@@ -2634 +2634 @@
         case 0:
             {
-                uint16_t csr0 = pData->aCSR[0];
+                uint16_t csr0 = pThis->aCSR[0];
                 /* Clear any interrupt flags.
                  * Don't clear an interrupt flag which was not seen by the guest yet. */
-                csr0 &= ~(val  &  0x7f00  & pData->u16CSR0LastSeenByGuest);
+                csr0 &= ~(val  &  0x7f00  & pThis->u16CSR0LastSeenByGuest);
                 csr0  =  (csr0 & ~0x0040) | (val  & 0x0048);
                 val   =  (val  &  0x007f) | (csr0 & 0x7f00);
@@ -2645 +2645 @@
                     val &= ~3;
 
-                Log(("#%d CSR0: old=%#06x new=%#06x\n", PCNET_INST_NR, pData->aCSR[0], csr0));
+                Log(("#%d CSR0: old=%#06x new=%#06x\n", PCNET_INST_NR, pThis->aCSR[0], csr0));
 
 #ifndef IN_RING3
@@ -2654 +2654 @@
                 }
 #endif
-                pData->aCSR[0] = csr0;
-
-                if (!CSR_STOP(pData) && (val & 4))
-                    pcnetStop(pData);
+                pThis->aCSR[0] = csr0;
+
+                if (!CSR_STOP(pThis) && (val & 4))
+                    pcnetStop(pThis);
 
 #ifdef IN_RING3
-                if (!CSR_INIT(pData) && (val & 1))
-                    pcnetInit(pData);
-#endif
-
-                if (!CSR_STRT(pData) && (val & 2))
-                    pcnetStart(pData);
-
-                if (CSR_TDMD(pData))
-                    pcnetTransmit(pData);
+                if (!CSR_INIT(pThis) && (val & 1))
+                    pcnetInit(pThis);
+#endif
+
+                if (!CSR_STRT(pThis) && (val & 2))
+                    pcnetStart(pThis);
+
+                if (CSR_TDMD(pThis))
+                    pcnetTransmit(pThis);
 
                 return rc;
@@ -2710 +2710 @@
         case 74: /* XMTRC */
         case 112: /* MISSC */
-            if (CSR_STOP(pData) || CSR_SPND(pData))
+            if (CSR_STOP(pThis) || CSR_SPND(pThis))
                 break;
         case 3: /* Interrupt Mask and Deferral Control */
             break;
         case 4: /* Test and Features Control */
-            pData->aCSR[4] &= ~(val & 0x026a);
+            pThis->aCSR[4] &= ~(val & 0x026a);
             val &= ~0x026a;
-            val |= pData->aCSR[4] & 0x026a;
+            val |= pThis->aCSR[4] & 0x026a;
             break;
         case 5: /* Extended Control and Interrupt 1 */
-            pData->aCSR[5] &= ~(val & 0x0a90);
+            pThis->aCSR[5] &= ~(val & 0x0a90);
             val &= ~0x0a90;
-            val |= pData->aCSR[5] & 0x0a90;
+            val |= pThis->aCSR[5] & 0x0a90;
             break;
         case 7: /* Extended Control and Interrupt 2 */
             {
-                uint16_t csr7 = pData->aCSR[7];
+                uint16_t csr7 = pThis->aCSR[7];
                 csr7 &=        ~0x0400 ;
                 csr7 &= ~(val & 0x0800);
                 csr7 |=  (val & 0x0400);
-                pData->aCSR[7] = csr7;
+                pThis->aCSR[7] = csr7;
                 return rc;
             }
         case 15: /* Mode */
-            if ((pData->aCSR[15] & 0x8000) != (val & 0x8000) && pData->pDrv)
+            if ((pThis->aCSR[15] & 0x8000) != (val & 0x8000) && pThis->pDrv)
             {
                 Log(("#%d: promiscuous mode changed to %d\n", PCNET_INST_NR, !!(val & 0x8000)));
@@ -2741 +2741 @@
 #else
                 /* check for promiscuous mode change */
-                if (pData->pDrv)
-                    pData->pDrv->pfnSetPromiscuousMode(pData->pDrv, !!(val & 0x8000));
+                if (pThis->pDrv)
+                    pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv, !!(val & 0x8000));
 #endif
             }
             break;
         case 16: /* IADRL */
-            return pcnetCSRWriteU16(pData, 1, val);
+            return pcnetCSRWriteU16(pThis, 1, val);
         case 17: /* IADRH */
-            return pcnetCSRWriteU16(pData, 2, val);
+            return pcnetCSRWriteU16(pThis, 2, val);
 
         /*
@@ -2757 +2757 @@
         case 24: /* BADRL */
         case 25: /* BADRU */
-            if (!CSR_STOP(pData) && !CSR_SPND(pData))
+            if (!CSR_STOP(pThis) && !CSR_SPND(pThis))
             {
                 Log(("#%d: WRITE CSR%d, %#06x !!\n", PCNET_INST_NR, u32RAP, val));
@@ -2763 +2763 @@
             }
             if (u32RAP == 24)
-                pData->GCRDRA = (pData->GCRDRA & 0xffff0000) | (val & 0x0000ffff);
+                pThis->GCRDRA = (pThis->GCRDRA & 0xffff0000) | (val & 0x0000ffff);
             else
-                pData->GCRDRA = (pData->GCRDRA & 0x0000ffff) | ((val & 0x0000ffff) << 16);
-            Log(("#%d: WRITE CSR%d, %#06x => GCRDRA=%08x (alt init)\n", PCNET_INST_NR, u32RAP, val, pData->GCRDRA));
+                pThis->GCRDRA = (pThis->GCRDRA & 0x0000ffff) | ((val & 0x0000ffff) << 16);
+            Log(("#%d: WRITE CSR%d, %#06x => GCRDRA=%08x (alt init)\n", PCNET_INST_NR, u32RAP, val, pThis->GCRDRA));
             break;
 
@@ -2775 +2775 @@
         case 30: /* BADXL */
         case 31: /* BADXU */
-            if (!CSR_STOP(pData) && !CSR_SPND(pData))
+            if (!CSR_STOP(pThis) && !CSR_SPND(pThis))
             {
                 Log(("#%d: WRITE CSR%d, %#06x !!\n", PCNET_INST_NR, u32RAP, val));
@@ -2781 +2781 @@
             }
             if (u32RAP == 30)
-                pData->GCTDRA = (pData->GCTDRA & 0xffff0000) | (val & 0x0000ffff);
+                pThis->GCTDRA = (pThis->GCTDRA & 0xffff0000) | (val & 0x0000ffff);
             else
-                pData->GCTDRA = (pData->GCTDRA & 0x0000ffff) | ((val & 0x0000ffff) << 16);
-            Log(("#%d: WRITE CSR%d, %#06x => GCTDRA=%08x (alt init)\n", PCNET_INST_NR, u32RAP, val, pData->GCTDRA));
+                pThis->GCTDRA = (pThis->GCTDRA & 0x0000ffff) | ((val & 0x0000ffff) << 16);
+            Log(("#%d: WRITE CSR%d, %#06x => GCTDRA=%08x (alt init)\n", PCNET_INST_NR, u32RAP, val, pThis->GCTDRA));
             break;
 
         case 58: /* Software Style */
-            rc = pcnetBCRWriteU16(pData, BCR_SWS, val);
+            rc = pcnetBCRWriteU16(pThis, BCR_SWS, val);
             break;
 
@@ -2799 +2799 @@
         case 78: /* XMTRL */ /** @todo call pcnetUpdateRingHandlers */
                              /** @todo transmit ring length is stored in two's complement! */
-            if (!CSR_STOP(pData) && !CSR_SPND(pData))
+            if (!CSR_STOP(pThis) && !CSR_SPND(pThis))
             {
                 Log(("#%d: WRITE CSR%d, %#06x !!\n", PCNET_INST_NR, u32RAP, val));
@@ -2811 +2811 @@
              * HACK ALERT! Set the counter registers too.
              */
-            pData->aCSR[u32RAP - 4] = val;
+            pThis->aCSR[u32RAP - 4] = val;
             break;
 
@@ -2817 +2817 @@
             return rc;
     }
-    pData->aCSR[u32RAP] = val;
+    pThis->aCSR[u32RAP] = val;
     return rc;
 }
@@ -2836 +2836 @@
 }
 
-static uint32_t pcnetCSRReadU16(PCNetState *pData, uint32_t u32RAP)
+static uint32_t pcnetCSRReadU16(PCNetState *pThis, uint32_t u32RAP)
 {
     uint32_t val;
@@ -2842 +2842 @@
     {
         case 0:
-            pcnetUpdateIrq(pData);
-            val = pData->aCSR[0];
+            pcnetUpdateIrq(pThis);
+            val = pThis->aCSR[0];
             val |= (val & 0x7800) ? 0x8000 : 0;
-            pData->u16CSR0LastSeenByGuest = val;
+            pThis->u16CSR0LastSeenByGuest = val;
             break;
         case 16:
-            return pcnetCSRReadU16(pData, 1);
+            return pcnetCSRReadU16(pThis, 1);
         case 17:
-            return pcnetCSRReadU16(pData, 2);
+            return pcnetCSRReadU16(pThis, 2);
         case 58:
-            return pcnetBCRReadU16(pData, BCR_SWS);
+            return pcnetBCRReadU16(pThis, BCR_SWS);
         case 68:    /* Custom register to pass link speed to driver */
-            return pcnetLinkSpd(pData->u32LinkSpeed);
+            return pcnetLinkSpd(pThis->u32LinkSpeed);
         case 88:
-            val = pData->aCSR[89];
+            val = pThis->aCSR[89];
             val <<= 16;
-            val |= pData->aCSR[88];
+            val |= pThis->aCSR[88];
             break;
         default:
-            val = pData->aCSR[u32RAP];
+            val = pThis->aCSR[u32RAP];
     }
 #ifdef PCNET_DEBUG_CSR
@@ -2869 +2869 @@
 }
 
-static int pcnetBCRWriteU16(PCNetState *pData, uint32_t u32RAP, uint32_t val)
+static int pcnetBCRWriteU16(PCNetState *pThis, uint32_t u32RAP, uint32_t val)
 {
     int rc = VINF_SUCCESS;
@@ -2879 +2879 @@
     {
         case BCR_SWS:
-            if (!(CSR_STOP(pData) || CSR_SPND(pData)))
+            if (!(CSR_STOP(pThis) || CSR_SPND(pThis)))
                 return rc;
             val &= ~0x0300;
@@ -2889 +2889 @@
                 case 0:
                     val |= 0x0200; /* 16 bit */
-                    pData->iLog2DescSize = 3;
-                    pData->GCUpperPhys   = (0xff00 & (uint32_t)pData->aCSR[2]) << 16;
+                    pThis->iLog2DescSize = 3;
+                    pThis->GCUpperPhys   = (0xff00 & (uint32_t)pThis->aCSR[2]) << 16;
                     break;
                 case 1:
                     val |= 0x0100; /* 32 bit */
-                    pData->iLog2DescSize = 4;
-                    pData->GCUpperPhys   = 0;
+                    pThis->iLog2DescSize = 4;
+                    pThis->GCUpperPhys   = 0;
                     break;
                 case 2:
                 case 3:
                     val |= 0x0300; /* 32 bit */
-                    pData->iLog2DescSize = 4;
-                    pData->GCUpperPhys   = 0;
+                    pThis->iLog2DescSize = 4;
+                    pThis->GCUpperPhys   = 0;
                     break;
             }
             Log(("#%d BCR_SWS=%#06x\n", PCNET_INST_NR, val));
-            pData->aCSR[58] = val;
+            pThis->aCSR[58] = val;
             /* fall through */
         case BCR_LNKST:
@@ -2918 +2918 @@
         case BCR_MIICAS:
         case BCR_MIIADDR:
-            pData->aBCR[u32RAP] = val;
+            pThis->aBCR[u32RAP] = val;
             break;
 
         case BCR_STVAL:
             val &= 0xffff;
-            pData->aBCR[BCR_STVAL] = val;
-            if (pData->fAm79C973)
-                TMTimerSetNano(pData->CTX_SUFF(pTimerSoftInt), 12800U * val);
+            pThis->aBCR[BCR_STVAL] = val;
+            if (pThis->fAm79C973)
+                TMTimerSetNano(pThis->CTX_SUFF(pTimerSoftInt), 12800U * val);
             break;
 
         case BCR_MIIMDR:
-            pData->aMII[pData->aBCR[BCR_MIIADDR] & 0x1f] = val;
+            pThis->aMII[pThis->aBCR[BCR_MIIADDR] & 0x1f] = val;
 #ifdef PCNET_DEBUG_MII
-            Log(("#%d pcnet: mii write %d <- %#x\n", PCNET_INST_NR, pData->aBCR[BCR_MIIADDR] & 0x1f, val));
+            Log(("#%d pcnet: mii write %d <- %#x\n", PCNET_INST_NR, pThis->aBCR[BCR_MIIADDR] & 0x1f, val));
 #endif
             break;
@@ -2941 +2941 @@
 }
 
-static uint32_t pcnetMIIReadU16(PCNetState *pData, uint32_t miiaddr)
+static uint32_t pcnetMIIReadU16(PCNetState *pThis, uint32_t miiaddr)
 {
     uint32_t val;
     bool autoneg, duplex, fast;
-    STAM_COUNTER_INC(&pData->StatMIIReads);
-
-    autoneg = (pData->aBCR[BCR_MIICAS] & 0x20) != 0;
-    duplex  = (pData->aBCR[BCR_MIICAS] & 0x10) != 0;
-    fast    = (pData->aBCR[BCR_MIICAS] & 0x08) != 0;
+    STAM_COUNTER_INC(&pThis->StatMIIReads);
+
+    autoneg = (pThis->aBCR[BCR_MIICAS] & 0x20) != 0;
+    duplex  = (pThis->aBCR[BCR_MIICAS] & 0x10) != 0;
+    fast    = (pThis->aBCR[BCR_MIICAS] & 0x08) != 0;
 
     switch (miiaddr)
@@ -2972 +2972 @@
                 | 0x0004    /* Link up. */
                 | 0x0001;   /* Extended Capability, i.e. registers 4+ valid. */
-            if (!pData->fLinkUp || pData->fLinkTempDown) {
+            if (!pThis->fLinkUp || pThis->fLinkTempDown) {
                 val &= ~(0x0020 | 0x0004);
-                pData->cLinkDownReported++;
+                pThis->cLinkDownReported++;
             }
             if (!autoneg) {
@@ -3018 +3018 @@
         case 5:
             /* Link partner ability register. */
-            if (pData->fLinkUp && !pData->fLinkTempDown)
+            if (pThis->fLinkUp && !pThis->fLinkTempDown)
                 val =   0x8000  /* Next page bit. */
                       | 0x4000  /* Link partner acked us. */
@@ -3027 +3027 @@
             {
                 val = 0;
-                pData->cLinkDownReported++;
+                pThis->cLinkDownReported++;
             }
             break;
@@ -3033 +3033 @@
         case 6:
             /* Auto negotiation expansion register. */
-            if (pData->fLinkUp && !pData->fLinkTempDown)
+            if (pThis->fLinkUp && !pThis->fLinkTempDown)
                 val =   0x0008  /* Link partner supports npage. */
                       | 0x0004  /* Enable npage words. */
@@ -3040 +3040 @@
             {
                 val = 0;
-                pData->cLinkDownReported++;
+                pThis->cLinkDownReported++;
             }
             break;
@@ -3055 +3055 @@
 }
 
-static uint32_t pcnetBCRReadU16(PCNetState *pData, uint32_t u32RAP)
+static uint32_t pcnetBCRReadU16(PCNetState *pThis, uint32_t u32RAP)
 {
     uint32_t val;
@@ -3065 +3065 @@
         case BCR_LED2:
         case BCR_LED3:
-            val = pData->aBCR[u32RAP] & ~0x8000;
+            val = pThis->aBCR[u32RAP] & ~0x8000;
             /* Clear LNKSTE if we're not connected or if we've just loaded a VM state. */
-            if (!pData->pDrv || pData->fLinkTempDown || !pData->fLinkUp)
+            if (!pThis->pDrv || pThis->fLinkTempDown || !pThis->fLinkUp)
             {
                 if (u32RAP == 4)
-                    pData->cLinkDownReported++;
+                    pThis->cLinkDownReported++;
                 val &= ~0x40;
             }
-            val |= (val & 0x017f & pData->u32Lnkst) ? 0x8000 : 0;
+            val |= (val & 0x017f & pThis->u32Lnkst) ? 0x8000 : 0;
             break;
 
         case BCR_MIIMDR:
-            if (pData->fAm79C973 && (pData->aBCR[BCR_MIIADDR] >> 5 & 0x1f) == 0)
+            if (pThis->fAm79C973 && (pThis->aBCR[BCR_MIIADDR] >> 5 & 0x1f) == 0)
             {
-                uint32_t miiaddr = pData->aBCR[BCR_MIIADDR] & 0x1f;
-                val = pcnetMIIReadU16(pData, miiaddr);
+                uint32_t miiaddr = pThis->aBCR[BCR_MIIADDR] & 0x1f;
+                val = pcnetMIIReadU16(pThis, miiaddr);
             }
             else
@@ -3087 +3087 @@
 
         default:
-            val = u32RAP < BCR_MAX_RAP ? pData->aBCR[u32RAP] : 0;
+            val = u32RAP < BCR_MAX_RAP ? pThis->aBCR[u32RAP] : 0;
             break;
     }
@@ -3097 +3097 @@
 
 #ifdef IN_RING3 /* move down */
-static void pcnetHardReset(PCNetState *pData)
+static void pcnetHardReset(PCNetState *pThis)
 {
     int      i;
@@ -3103 +3103 @@
 
     /* Initialize the PROM */
-    Assert(sizeof(pData->MacConfigured) == 6);
-    memcpy(pData->aPROM, &pData->MacConfigured, sizeof(pData->MacConfigured));
-    pData->aPROM[ 8] = 0x00;
-    pData->aPROM[ 9] = 0x11;
-    pData->aPROM[12] = pData->aPROM[13] = 0x00;
-    pData->aPROM[14] = pData->aPROM[15] = 0x57;
+    Assert(sizeof(pThis->MacConfigured) == 6);
+    memcpy(pThis->aPROM, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
+    pThis->aPROM[ 8] = 0x00;
+    pThis->aPROM[ 9] = 0x11;
+    pThis->aPROM[12] = pThis->aPROM[13] = 0x00;
+    pThis->aPROM[14] = pThis->aPROM[15] = 0x57;
 
     for (i = 0, checksum = 0; i < 16; i++)
-        checksum += pData->aPROM[i];
-    *(uint16_t *)&pData->aPROM[12] = RT_H2LE_U16(checksum);
-
-    pData->aBCR[BCR_MSRDA] = 0x0005;
-    pData->aBCR[BCR_MSWRA] = 0x0005;
-    pData->aBCR[BCR_MC   ] = 0x0002;
-    pData->aBCR[BCR_LNKST] = 0x00c0;
-    pData->aBCR[BCR_LED1 ] = 0x0084;
-    pData->aBCR[BCR_LED2 ] = 0x0088;
-    pData->aBCR[BCR_LED3 ] = 0x0090;
-    pData->aBCR[BCR_FDC  ] = 0x0000;
-    pData->aBCR[BCR_BSBC ] = 0x9001;
-    pData->aBCR[BCR_EECAS] = 0x0002;
-    pData->aBCR[BCR_STVAL] = 0xffff;
-    pData->aCSR[58       ] = /* CSR58 is an alias for BCR20 */
-    pData->aBCR[BCR_SWS  ] = 0x0200;
-    pData->iLog2DescSize   = 3;
-    pData->aBCR[BCR_PLAT ] = 0xff06;
-    pData->aBCR[BCR_MIIADDR ] = 0;  /* Internal PHY on Am79C973 would be (0x1e << 5) */
-    pData->aBCR[BCR_PCIVID] = PCIDevGetVendorId(&pData->PciDev);
-    pData->aBCR[BCR_PCISID] = PCIDevGetSubSystemId(&pData->PciDev);
-    pData->aBCR[BCR_PCISVID] = PCIDevGetSubSystemVendorId(&pData->PciDev);
-
-    pcnetSoftReset(pData);
+        checksum += pThis->aPROM[i];
+    *(uint16_t *)&pThis->aPROM[12] = RT_H2LE_U16(checksum);
+
+    pThis->aBCR[BCR_MSRDA] = 0x0005;
+    pThis->aBCR[BCR_MSWRA] = 0x0005;
+    pThis->aBCR[BCR_MC   ] = 0x0002;
+    pThis->aBCR[BCR_LNKST] = 0x00c0;
+    pThis->aBCR[BCR_LED1 ] = 0x0084;
+    pThis->aBCR[BCR_LED2 ] = 0x0088;
+    pThis->aBCR[BCR_LED3 ] = 0x0090;
+    pThis->aBCR[BCR_FDC  ] = 0x0000;
+    pThis->aBCR[BCR_BSBC ] = 0x9001;
+    pThis->aBCR[BCR_EECAS] = 0x0002;
+    pThis->aBCR[BCR_STVAL] = 0xffff;
+    pThis->aCSR[58       ] = /* CSR58 is an alias for BCR20 */
+    pThis->aBCR[BCR_SWS  ] = 0x0200;
+    pThis->iLog2DescSize   = 3;
+    pThis->aBCR[BCR_PLAT ] = 0xff06;
+    pThis->aBCR[BCR_MIIADDR ] = 0;  /* Internal PHY on Am79C973 would be (0x1e << 5) */
+    pThis->aBCR[BCR_PCIVID] = PCIDevGetVendorId(&pThis->PciDev);
+    pThis->aBCR[BCR_PCISID] = PCIDevGetSubSystemId(&pThis->PciDev);
+    pThis->aBCR[BCR_PCISVID] = PCIDevGetSubSystemVendorId(&pThis->PciDev);
+
+    pcnetSoftReset(pThis);
 }
 #endif /* IN_RING3 */
 
-static void pcnetAPROMWriteU8(PCNetState *pData, uint32_t addr, uint32_t val)
+static void pcnetAPROMWriteU8(PCNetState *pThis, uint32_t addr, uint32_t val)
 {
     addr &= 0x0f;
@@ -3144 +3144 @@
     Log(("#%d pcnetAPROMWriteU8: addr=%#010x val=%#04x\n", PCNET_INST_NR, addr, val));
     /* Check APROMWE bit to enable write access */
-    if (pcnetBCRReadU16(pData, 2) & 0x80)
-        pData->aPROM[addr] = val;
-}
-
-static uint32_t pcnetAPROMReadU8(PCNetState *pData, uint32_t addr)
-{
-    uint32_t val = pData->aPROM[addr &= 0x0f];
+    if (pcnetBCRReadU16(pThis, 2) & 0x80)
+        pThis->aPROM[addr] = val;
+}
+
+static uint32_t pcnetAPROMReadU8(PCNetState *pThis, uint32_t addr)
+{
+    uint32_t val = pThis->aPROM[addr &= 0x0f];
     Log(("#%d pcnetAPROMReadU8: addr=%#010x val=%#04x\n", PCNET_INST_NR, addr, val));
     return val;
 }
 
-static int pcnetIoportWriteU16(PCNetState *pData, uint32_t addr, uint32_t val)
+static int pcnetIoportWriteU16(PCNetState *pThis, uint32_t addr, uint32_t val)
 {
     int rc = VINF_SUCCESS;
@@ -3163 +3163 @@
          addr, val));
 #endif
-    if (RT_LIKELY(!BCR_DWIO(pData)))
+    if (RT_LIKELY(!BCR_DWIO(pThis)))
     {
         switch (addr & 0x0f)
         {
             case 0x00: /* RDP */
-                pcnetPollTimer(pData);
-                rc = pcnetCSRWriteU16(pData, pData->u32RAP, val);
-                pcnetUpdateIrq(pData);
+                pcnetPollTimer(pThis);
+                rc = pcnetCSRWriteU16(pThis, pThis->u32RAP, val);
+                pcnetUpdateIrq(pThis);
                 break;
             case 0x02: /* RAP */
-                pData->u32RAP = val & 0x7f;
+                pThis->u32RAP = val & 0x7f;
                 break;
             case 0x06: /* BDP */
-                rc = pcnetBCRWriteU16(pData, pData->u32RAP, val);
+                rc = pcnetBCRWriteU16(pThis, pThis->u32RAP, val);
                 break;
         }
@@ -3186 +3186 @@
 }
 
-static uint32_t pcnetIoportReadU16(PCNetState *pData, uint32_t addr, int *pRC)
+static uint32_t pcnetIoportReadU16(PCNetState *pThis, uint32_t addr, int *pRC)
 {
     uint32_t val = ~0U;
@@ -3192 +3192 @@
     *pRC = VINF_SUCCESS;
 
-    if (RT_LIKELY(!BCR_DWIO(pData)))
+    if (RT_LIKELY(!BCR_DWIO(pThis)))
     {
         switch (addr & 0x0f)
@@ -3199 +3199 @@
                 /** @note if we're not polling, then the guest will tell us when to poll by setting TDMD in CSR0 */
                 /** Polling is then useless here and possibly expensive. */
-                if (!CSR_DPOLL(pData))
-                    pcnetPollTimer(pData);
-
-                val = pcnetCSRReadU16(pData, pData->u32RAP);
-                if (pData->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
+                if (!CSR_DPOLL(pThis))
+                    pcnetPollTimer(pThis);
+
+                val = pcnetCSRReadU16(pThis, pThis->u32RAP);
+                if (pThis->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
                     goto skip_update_irq;
                 break;
             case 0x02: /* RAP */
-                val = pData->u32RAP;
+                val = pThis->u32RAP;
                 goto skip_update_irq;
             case 0x04: /* RESET */
-                pcnetSoftReset(pData);
+                pcnetSoftReset(pThis);
                 val = 0;
                 break;
             case 0x06: /* BDP */
-                val = pcnetBCRReadU16(pData, pData->u32RAP);
+                val = pcnetBCRReadU16(pThis, pThis->u32RAP);
                 break;
         }
@@ -3221 +3221 @@
         Log(("#%d pcnetIoportReadU16: addr=%#010x val=%#06x BCR_DWIO !!\n", PCNET_INST_NR, addr, val & 0xffff));
 
-    pcnetUpdateIrq(pData);
+    pcnetUpdateIrq(pThis);
 
 skip_update_irq:
@@ -3230 +3230 @@
 }
 
-static int pcnetIoportWriteU32(PCNetState *pData, uint32_t addr, uint32_t val)
+static int pcnetIoportWriteU32(PCNetState *pThis, uint32_t addr, uint32_t val)
 {
     int rc = VINF_SUCCESS;
@@ -3238 +3238 @@
          addr, val));
 #endif
-    if (RT_LIKELY(BCR_DWIO(pData)))
+    if (RT_LIKELY(BCR_DWIO(pThis)))
     {
         switch (addr & 0x0f)
         {
             case 0x00: /* RDP */
-                pcnetPollTimer(pData);
-                rc = pcnetCSRWriteU16(pData, pData->u32RAP, val & 0xffff);
-                pcnetUpdateIrq(pData);
+                pcnetPollTimer(pThis);
+                rc = pcnetCSRWriteU16(pThis, pThis->u32RAP, val & 0xffff);
+                pcnetUpdateIrq(pThis);
                 break;
             case 0x04: /* RAP */
-                pData->u32RAP = val & 0x7f;
+                pThis->u32RAP = val & 0x7f;
                 break;
             case 0x0c: /* BDP */
-                rc = pcnetBCRWriteU16(pData, pData->u32RAP, val & 0xffff);
+                rc = pcnetBCRWriteU16(pThis, pThis->u32RAP, val & 0xffff);
                 break;
         }
@@ -3258 +3258 @@
     {
         /* switch device to dword I/O mode */
-        pcnetBCRWriteU16(pData, BCR_BSBC, pcnetBCRReadU16(pData, BCR_BSBC) | 0x0080);
+        pcnetBCRWriteU16(pThis, BCR_BSBC, pcnetBCRReadU16(pThis, BCR_BSBC) | 0x0080);
 #ifdef PCNET_DEBUG_IO
         Log2(("device switched into dword i/o mode\n"));
@@ -3269 +3269 @@
 }
 
-static uint32_t pcnetIoportReadU32(PCNetState *pData, uint32_t addr, int *pRC)
+static uint32_t pcnetIoportReadU32(PCNetState *pThis, uint32_t addr, int *pRC)
 {
     uint32_t val = ~0U;
@@ -3275 +3275 @@
     *pRC = VINF_SUCCESS;
 
-    if (RT_LIKELY(BCR_DWIO(pData)))
+    if (RT_LIKELY(BCR_DWIO(pThis)))
     {
         switch (addr & 0x0f)
@@ -3282 +3282 @@
                 /** @note if we're not polling, then the guest will tell us when to poll by setting TDMD in CSR0 */
                 /** Polling is then useless here and possibly expensive. */
-                if (!CSR_DPOLL(pData))
-                    pcnetPollTimer(pData);
-
-                val = pcnetCSRReadU16(pData, pData->u32RAP);
-                if (pData->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
+                if (!CSR_DPOLL(pThis))
+                    pcnetPollTimer(pThis);
+
+                val = pcnetCSRReadU16(pThis, pThis->u32RAP);
+                if (pThis->u32RAP == 0)  // pcnetUpdateIrq() already called by pcnetCSRReadU16()
                     goto skip_update_irq;
                 break;
             case 0x04: /* RAP */
-                val = pData->u32RAP;
+                val = pThis->u32RAP;
                 goto skip_update_irq;
             case 0x08: /* RESET */
-                pcnetSoftReset(pData);
+                pcnetSoftReset(pThis);
                 val = 0;
                 break;
             case 0x0c: /* BDP */
-                val = pcnetBCRReadU16(pData, pData->u32RAP);
+                val = pcnetBCRReadU16(pThis, pThis->u32RAP);
                 break;
         }
@@ -3303 +3303 @@
     else
         Log(("#%d pcnetIoportReadU32: addr=%#010x val=%#010x !BCR_DWIO !!\n", PCNET_INST_NR, addr, val));
-    pcnetUpdateIrq(pData);
+    pcnetUpdateIrq(pThis);
 
 skip_update_irq:
@@ -3312 +3312 @@
 }
 
-static void pcnetMMIOWriteU8(PCNetState *pData, RTGCPHYS addr, uint32_t val)
+static void pcnetMMIOWriteU8(PCNetState *pThis, RTGCPHYS addr, uint32_t val)
 {
 #ifdef PCNET_DEBUG_IO
@@ -3318 +3318 @@
 #endif
     if (!(addr & 0x10))
-        pcnetAPROMWriteU8(pData, addr, val);
-}
-
-static uint32_t pcnetMMIOReadU8(PCNetState *pData, RTGCPHYS addr)
+        pcnetAPROMWriteU8(pThis, addr, val);
+}
+
+static uint32_t pcnetMMIOReadU8(PCNetState *pThis, RTGCPHYS addr)
 {
     uint32_t val = ~0U;
     if (!(addr & 0x10))
-        val = pcnetAPROMReadU8(pData, addr);
+        val = pcnetAPROMReadU8(pThis, addr);
 #ifdef PCNET_DEBUG_IO
     Log2(("#%d pcnetMMIOReadU8: addr=%#010x val=%#04x\n", PCNET_INST_NR, addr, val & 0xff));
@@ -3332 +3332 @@
 }
 
-static void pcnetMMIOWriteU16(PCNetState *pData, RTGCPHYS addr, uint32_t val)
+static void pcnetMMIOWriteU16(PCNetState *pThis, RTGCPHYS addr, uint32_t val)
 {
 #ifdef PCNET_DEBUG_IO
@@ -3338 +3338 @@
 #endif
     if (addr & 0x10)
-        pcnetIoportWriteU16(pData, addr & 0x0f, val);
+        pcnetIoportWriteU16(pThis, addr & 0x0f, val);
     else
     {
-        pcnetAPROMWriteU8(pData, addr,   val     );
-        pcnetAPROMWriteU8(pData, addr+1, val >> 8);
-    }
-}
-
-static uint32_t pcnetMMIOReadU16(PCNetState *pData, RTGCPHYS addr)
+        pcnetAPROMWriteU8(pThis, addr,   val     );
+        pcnetAPROMWriteU8(pThis, addr+1, val >> 8);
+    }
+}
+
+static uint32_t pcnetMMIOReadU16(PCNetState *pThis, RTGCPHYS addr)
 {
     uint32_t val = ~0U;
@@ -3352 +3352 @@
 
     if (addr & 0x10)
-        val = pcnetIoportReadU16(pData, addr & 0x0f, &rc);
+        val = pcnetIoportReadU16(pThis, addr & 0x0f, &rc);
     else
     {
-        val = pcnetAPROMReadU8(pData, addr+1);
+        val = pcnetAPROMReadU8(pThis, addr+1);
         val <<= 8;
-        val |= pcnetAPROMReadU8(pData, addr);
+        val |= pcnetAPROMReadU8(pThis, addr);
     }
 #ifdef PCNET_DEBUG_IO
@@ -3365 +3365 @@
 }
 
-static void pcnetMMIOWriteU32(PCNetState *pData, RTGCPHYS addr, uint32_t val)
+static void pcnetMMIOWriteU32(PCNetState *pThis, RTGCPHYS addr, uint32_t val)
 {
 #ifdef PCNET_DEBUG_IO
@@ -3371 +3371 @@
 #endif
     if (addr & 0x10)
-        pcnetIoportWriteU32(pData, addr & 0x0f, val);
+        pcnetIoportWriteU32(pThis, addr & 0x0f, val);
     else
     {
-        pcnetAPROMWriteU8(pData, addr,   val      );
-        pcnetAPROMWriteU8(pData, addr+1, val >>  8);
-        pcnetAPROMWriteU8(pData, addr+2, val >> 16);
-        pcnetAPROMWriteU8(pData, addr+3, val >> 24);
-    }
-}
-
-static uint32_t pcnetMMIOReadU32(PCNetState *pData, RTGCPHYS addr)
+        pcnetAPROMWriteU8(pThis, addr,   val      );
+        pcnetAPROMWriteU8(pThis, addr+1, val >>  8);
+        pcnetAPROMWriteU8(pThis, addr+2, val >> 16);
+        pcnetAPROMWriteU8(pThis, addr+3, val >> 24);
+    }
+}
+
+static uint32_t pcnetMMIOReadU32(PCNetState *pThis, RTGCPHYS addr)
 {
     uint32_t val;
@@ -3387 +3387 @@
 
     if (addr & 0x10)
-        val = pcnetIoportReadU32(pData, addr & 0x0f, &rc);
+        val = pcnetIoportReadU32(pThis, addr & 0x0f, &rc);
     else
     {
-        val  = pcnetAPROMReadU8(pData, addr+3);
+        val  = pcnetAPROMReadU8(pThis, addr+3);
         val <<= 8;
-        val |= pcnetAPROMReadU8(pData, addr+2);
+        val |= pcnetAPROMReadU8(pThis, addr+2);
         val <<= 8;
-        val |= pcnetAPROMReadU8(pData, addr+1);
+        val |= pcnetAPROMReadU8(pThis, addr+1);
         val <<= 8;
-        val |= pcnetAPROMReadU8(pData, addr  );
+        val |= pcnetAPROMReadU8(pThis, addr  );
     }
 #ifdef PCNET_DEBUG_IO
@@ -3419 +3419 @@
                                         RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int        rc;
 
-    STAM_PROFILE_ADV_START(&pData->StatAPROMRead, a);
-    rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+    STAM_PROFILE_ADV_START(&pThis->StatAPROMRead, a);
+    rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
     if (rc == VINF_SUCCESS)
     {
@@ -3429 +3429 @@
         /* FreeBSD is accessing in dwords. */
         if (cb == 1)
-            *pu32 = pcnetAPROMReadU8(pData, Port);
-        else if (cb == 2 && !BCR_DWIO(pData))
-            *pu32 = pcnetAPROMReadU8(pData, Port)
-                  | (pcnetAPROMReadU8(pData, Port + 1) << 8);
-        else if (cb == 4 && BCR_DWIO(pData))
-            *pu32 = pcnetAPROMReadU8(pData, Port)
-                  | (pcnetAPROMReadU8(pData, Port + 1) << 8)
-                  | (pcnetAPROMReadU8(pData, Port + 2) << 16)
-                  | (pcnetAPROMReadU8(pData, Port + 3) << 24);
+            *pu32 = pcnetAPROMReadU8(pThis, Port);
+        else if (cb == 2 && !BCR_DWIO(pThis))
+            *pu32 = pcnetAPROMReadU8(pThis, Port)
+                  | (pcnetAPROMReadU8(pThis, Port + 1) << 8);
+        else if (cb == 4 && BCR_DWIO(pThis))
+            *pu32 = pcnetAPROMReadU8(pThis, Port)
+                  | (pcnetAPROMReadU8(pThis, Port + 1) << 8)
+                  | (pcnetAPROMReadU8(pThis, Port + 2) << 16)
+                  | (pcnetAPROMReadU8(pThis, Port + 3) << 24);
         else
         {
@@ -3443 +3443 @@
             rc = VERR_IOM_IOPORT_UNUSED;
         }
-        PDMCritSectLeave(&pData->CritSect);
-    }
-    STAM_PROFILE_ADV_STOP(&pData->StatAPROMRead, a);
+        PDMCritSectLeave(&pThis->CritSect);
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->StatAPROMRead, a);
     LogFlow(("#%d pcnetIOPortAPromRead: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Vrc\n", PCNET_INST_NR, Port, *pu32, cb, rc));
     return rc;
@@ -3465 +3465 @@
                                          RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int        rc;
 
     if (cb == 1)
     {
-        STAM_PROFILE_ADV_START(&pData->StatAPROMWrite, a);
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+        STAM_PROFILE_ADV_START(&pThis->StatAPROMWrite, a);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
         if (RT_LIKELY(rc == VINF_SUCCESS))
         {
-            pcnetAPROMWriteU8(pData, Port, u32);
-            PDMCritSectLeave(&pData->CritSect);
+            pcnetAPROMWriteU8(pThis, Port, u32);
+            PDMCritSectLeave(&pThis->CritSect);
         }
-        STAM_PROFILE_ADV_STOP(&pData->StatAPROMWrite, a);
+        STAM_PROFILE_ADV_STOP(&pThis->StatAPROMWrite, a);
     }
     else
@@ -3507 +3507 @@
                                    RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int         rc    = VINF_SUCCESS;
 
-    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatIORead), a);
-    rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
+    STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatIORead), a);
+    rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_READ);
     if (RT_LIKELY(rc == VINF_SUCCESS))
     {
         switch (cb)
         {
-            case 2: *pu32 = pcnetIoportReadU16(pData, Port, &rc); break;
-            case 4: *pu32 = pcnetIoportReadU32(pData, Port, &rc); break;
+            case 2: *pu32 = pcnetIoportReadU16(pThis, Port, &rc); break;
+            case 4: *pu32 = pcnetIoportReadU32(pThis, Port, &rc); break;
             default:
                 rc = VERR_IOM_IOPORT_UNUSED;
                 break;
         }
-        PDMCritSectLeave(&pData->CritSect);
-    }
-    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatIORead), a);
+        PDMCritSectLeave(&pThis->CritSect);
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatIORead), a);
     Log2(("#%d pcnetIOPortRead: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Vrc\n", PCNET_INST_NR, Port, *pu32, cb, rc));
 #ifdef LOG_ENABLED
@@ -3548 +3548 @@
                                     RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int         rc    = VINF_SUCCESS;
 
-    STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatIOWrite), a);
-    rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+    STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatIOWrite), a);
+    rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
     if (RT_LIKELY(rc == VINF_SUCCESS))
     {
         switch (cb)
         {
-            case 2: rc = pcnetIoportWriteU16(pData, Port, u32); break;
-            case 4: rc = pcnetIoportWriteU32(pData, Port, u32); break;
+            case 2: rc = pcnetIoportWriteU16(pThis, Port, u32); break;
+            case 4: rc = pcnetIoportWriteU32(pThis, Port, u32); break;
             default:
                 AssertMsgFailed(("Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
@@ -3564 +3564 @@
                 break;
         }
-        PDMCritSectLeave(&pData->CritSect);
-    }
-    STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatIOWrite), a);
+        PDMCritSectLeave(&pThis->CritSect);
+    }
+    STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatIOWrite), a);
     Log2(("#%d pcnetIOPortWrite: Port=%RTiop u32=%#RX32 cb=%d rc=%Vrc\n", PCNET_INST_NR, Port, u32, cb, rc));
 #ifdef LOG_ENABLED
@@ -3590 +3590 @@
                                  RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
 {
-    PCNetState *pData = (PCNetState *)pvUser;
+    PCNetState *pThis = (PCNetState *)pvUser;
     int         rc    = VINF_SUCCESS;
 
@@ -3596 +3596 @@
      * We have to check the range, because we're page aligning the MMIO stuff presently.
      */
-    if (GCPhysAddr - pData->MMIOBase < PCNET_PNPMMIO_SIZE)
-    {
-        STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatMMIORead), a);
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_READ);
+    if (GCPhysAddr - pThis->MMIOBase < PCNET_PNPMMIO_SIZE)
+    {
+        STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatMMIORead), a);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_MMIO_READ);
         if (RT_LIKELY(rc == VINF_SUCCESS))
         {
             switch (cb)
             {
-                case 1:  *(uint8_t  *)pv = pcnetMMIOReadU8 (pData, GCPhysAddr); break;
-                case 2:  *(uint16_t *)pv = pcnetMMIOReadU16(pData, GCPhysAddr); break;
-                case 4:  *(uint32_t *)pv = pcnetMMIOReadU32(pData, GCPhysAddr); break;
+                case 1:  *(uint8_t  *)pv = pcnetMMIOReadU8 (pThis, GCPhysAddr); break;
+                case 2:  *(uint16_t *)pv = pcnetMMIOReadU16(pThis, GCPhysAddr); break;
+                case 4:  *(uint32_t *)pv = pcnetMMIOReadU32(pThis, GCPhysAddr); break;
                 default:
                     AssertMsgFailed(("cb=%d\n", cb));
@@ -3612 +3612 @@
                     break;
             }
-            PDMCritSectLeave(&pData->CritSect);
+            PDMCritSectLeave(&pThis->CritSect);
         }
-        STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatMMIORead), a);
+        STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatMMIORead), a);
     }
     else
@@ -3643 +3643 @@
                                   RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
 {
-    PCNetState *pData = (PCNetState *)pvUser;
+    PCNetState *pThis = (PCNetState *)pvUser;
     int         rc    = VINF_SUCCESS;
 
@@ -3649 +3649 @@
      * We have to check the range, because we're page aligning the MMIO stuff presently.
      */
-    if (GCPhysAddr - pData->MMIOBase < PCNET_PNPMMIO_SIZE)
-    {
-        STAM_PROFILE_ADV_START(&pData->CTXSUFF(StatMMIOWrite), a);
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_MMIO_WRITE);
+    if (GCPhysAddr - pThis->MMIOBase < PCNET_PNPMMIO_SIZE)
+    {
+        STAM_PROFILE_ADV_START(&pThis->CTXSUFF(StatMMIOWrite), a);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_MMIO_WRITE);
         if (RT_LIKELY(rc == VINF_SUCCESS))
         {
             switch (cb)
             {
-                case 1:  pcnetMMIOWriteU8 (pData, GCPhysAddr, *(uint8_t  *)pv); break;
-                case 2:  pcnetMMIOWriteU16(pData, GCPhysAddr, *(uint16_t *)pv); break;
-                case 4:  pcnetMMIOWriteU32(pData, GCPhysAddr, *(uint32_t *)pv); break;
+                case 1:  pcnetMMIOWriteU8 (pThis, GCPhysAddr, *(uint8_t  *)pv); break;
+                case 2:  pcnetMMIOWriteU16(pThis, GCPhysAddr, *(uint16_t *)pv); break;
+                case 4:  pcnetMMIOWriteU32(pThis, GCPhysAddr, *(uint32_t *)pv); break;
                 default:
                     AssertMsgFailed(("cb=%d\n", cb));
@@ -3665 +3665 @@
                     break;
             }
-            PDMCritSectLeave(&pData->CritSect);
+            PDMCritSectLeave(&pThis->CritSect);
         }
         // else rc == VINF_IOM_HC_MMIO_WRITE => handle in ring3
 
-        STAM_PROFILE_ADV_STOP(&pData->CTXSUFF(StatMMIOWrite), a);
+        STAM_PROFILE_ADV_STOP(&pThis->CTXSUFF(StatMMIOWrite), a);
     }
     LogFlow(("#%d pcnetMMIOWrite: pvUser=%p:{%.*Rhxs} cb=%d GCPhysAddr=%RGp rc=%Vrc\n",
@@ -3691 +3691 @@
 static DECLCALLBACK(void) pcnetTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int         rc;
 
-    STAM_PROFILE_ADV_START(&pData->StatTimer, a);
-    rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    STAM_PROFILE_ADV_START(&pThis->StatTimer, a);
+    rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertReleaseRC(rc);
 
-    pcnetPollTimer(pData);
-
-    PDMCritSectLeave(&pData->CritSect);
-    STAM_PROFILE_ADV_STOP(&pData->StatTimer, a);
+    pcnetPollTimer(pThis);
+
+    PDMCritSectLeave(&pThis->CritSect);
+    STAM_PROFILE_ADV_STOP(&pThis->StatTimer, a);
 }
 
@@ -3714 +3714 @@
 static DECLCALLBACK(void) pcnetTimerSoftInt(PPDMDEVINS pDevIns, PTMTIMER pTimer)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-
-    pData->aCSR[7] |= 0x0800; /* STINT */
-    pcnetUpdateIrq(pData);
-    TMTimerSetNano(pData->CTX_SUFF(pTimerSoftInt), 12800U * (pData->aBCR[BCR_STVAL] & 0xffff));
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+
+    pThis->aCSR[7] |= 0x0800; /* STINT */
+    pcnetUpdateIrq(pThis);
+    TMTimerSetNano(pThis->CTX_SUFF(pTimerSoftInt), 12800U * (pThis->aBCR[BCR_STVAL] & 0xffff));
 }
 
@@ -3734 +3734 @@
 static DECLCALLBACK(void) pcnetTimerRestore(PPDMDEVINS pDevIns, PTMTIMER pTimer)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-    int         rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+    int         rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertReleaseRC(rc);
 
     rc = VERR_GENERAL_FAILURE;
-    if (pData->cLinkDownReported <= PCNET_MAX_LINKDOWN_REPORTED)
-        rc = TMTimerSetMillies(pData->pTimerRestore, 1500);
+    if (pThis->cLinkDownReported <= PCNET_MAX_LINKDOWN_REPORTED)
+        rc = TMTimerSetMillies(pThis->pTimerRestore, 1500);
     if (RT_FAILURE(rc))
     {
-        pData->fLinkTempDown = false;
-        if (pData->fLinkUp)
+        pThis->fLinkTempDown = false;
+        if (pThis->fLinkUp)
         {
             LogRel(("PCNet#%d: The link is back up again after the restore.\n",
                     pDevIns->iInstance));
             Log(("#%d pcnetTimerRestore: Clearing ERR and CERR after load. cLinkDownReported=%d\n",
-                 pDevIns->iInstance, pData->cLinkDownReported));
-            pData->aCSR[0] &= ~(RT_BIT(15) | RT_BIT(13)); /* ERR | CERR - probably not 100% correct either... */
-            pData->Led.Actual.s.fError = 0;
+                 pDevIns->iInstance, pThis->cLinkDownReported));
+            pThis->aCSR[0] &= ~(RT_BIT(15) | RT_BIT(13)); /* ERR | CERR - probably not 100% correct either... */
+            pThis->Led.Actual.s.fError = 0;
         }
     }
     else
         Log(("#%d pcnetTimerRestore: cLinkDownReported=%d, wait another 1500ms...\n",
-             pDevIns->iInstance, pData->cLinkDownReported));
-
-    PDMCritSectLeave(&pData->CritSect);
+             pDevIns->iInstance, pThis->cLinkDownReported));
+
+    PDMCritSectLeave(&pThis->CritSect);
 }
 
@@ -3780 +3780 @@
     PPDMDEVINS  pDevIns = pPciDev->pDevIns;
     RTIOPORT    Port    = (RTIOPORT)GCPhysAddress;
-    PCNetState *pData   = PCIDEV_2_PCNETSTATE(pPciDev);
+    PCNetState *pThis   = PCIDEV_2_PCNETSTATE(pPciDev);
 
     Assert(enmType == PCI_ADDRESS_SPACE_IO);
@@ -3794 +3794 @@
         return rc;
 
-    if (pData->fGCEnabled)
+    if (pThis->fGCEnabled)
     {
         rc = PDMDevHlpIOPortRegisterGC(pDevIns, Port, 0x10, 0, "pcnetIOPortAPromWrite",
@@ -3805 +3805 @@
             return rc;
     }
-    if (pData->fR0Enabled)
+    if (pThis->fR0Enabled)
     {
         rc = PDMDevHlpIOPortRegisterR0(pDevIns, Port, 0x10, 0, "pcnetIOPortAPromWrite",
@@ -3817 +3817 @@
     }
 
-    pData->IOPortBase = Port;
+    pThis->IOPortBase = Port;
     return VINF_SUCCESS;
 }
@@ -3837 +3837 @@
                                       RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
 {
-    PCNetState *pData = PCIDEV_2_PCNETSTATE(pPciDev);
+    PCNetState *pThis = PCIDEV_2_PCNETSTATE(pPciDev);
     int         rc;
 
@@ -3844 +3844 @@
 
     /* We use the assigned size here, because we currently only support page aligned MMIO ranges. */
-    rc = PDMDevHlpMMIORegister(pPciDev->pDevIns, GCPhysAddress, cb, pData,
+    rc = PDMDevHlpMMIORegister(pPciDev->pDevIns, GCPhysAddress, cb, pThis,
                                pcnetMMIOWrite, pcnetMMIORead, NULL, "PCNet");
     if (RT_FAILURE(rc))
         return rc;
-    pData->MMIOBase = GCPhysAddress;
+    pThis->MMIOBase = GCPhysAddress;
     return rc;
 }
@@ -3885 +3885 @@
 static DECLCALLBACK(void) pcnetInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     bool        fRcvRing = false;
     bool        fXmtRing = false;
@@ -3904 +3904 @@
                     "pcnet #%d: port=%RTiop mmio=%RGp mac-cfg=%.*Rhxs %s\n",
                     pDevIns->iInstance,
-                    pData->IOPortBase, pData->MMIOBase, sizeof(pData->MacConfigured), &pData->MacConfigured,
-                    pData->fAm79C973 ? "Am79C973" : "Am79C970A", pData->fGCEnabled ? " GC" : "", pData->fR0Enabled ? " R0" : "");
-
-    PDMCritSectEnter(&pData->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
+                    pThis->IOPortBase, pThis->MMIOBase, sizeof(pThis->MacConfigured), &pThis->MacConfigured,
+                    pThis->fAm79C973 ? "Am79C973" : "Am79C970A", pThis->fGCEnabled ? " GC" : "", pThis->fR0Enabled ? " R0" : "");
+
+    PDMCritSectEnter(&pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
 
     pHlp->pfnPrintf(pHlp,
                     "CSR0=%#06x:\n",
-                    pData->aCSR[0]);
+                    pThis->aCSR[0]);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR1=%#06x:\n",
-                    pData->aCSR[1]);
+                    pThis->aCSR[1]);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR2=%#06x:\n",
-                    pData->aCSR[2]);
+                    pThis->aCSR[2]);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR3=%#06x: BSWP=%d EMBA=%d DXMT2PD=%d LAPPEN=%d DXSUFLO=%d IDONM=%d TINTM=%d RINTM=%d MERRM=%d MISSM=%d BABLM=%d\n",
-                    pData->aCSR[3],
-                    !!(pData->aCSR[3] & RT_BIT(2)), !!(pData->aCSR[3] & RT_BIT(3)), !!(pData->aCSR[3] & RT_BIT(4)), CSR_LAPPEN(pData),
-                    CSR_DXSUFLO(pData), !!(pData->aCSR[3] & RT_BIT(8)), !!(pData->aCSR[3] & RT_BIT(9)), !!(pData->aCSR[3] & RT_BIT(10)),
-                    !!(pData->aCSR[3] & RT_BIT(11)), !!(pData->aCSR[3] & RT_BIT(12)), !!(pData->aCSR[3] & RT_BIT(14)));
+                    pThis->aCSR[3],
+                    !!(pThis->aCSR[3] & RT_BIT(2)), !!(pThis->aCSR[3] & RT_BIT(3)), !!(pThis->aCSR[3] & RT_BIT(4)), CSR_LAPPEN(pThis),
+                    CSR_DXSUFLO(pThis), !!(pThis->aCSR[3] & RT_BIT(8)), !!(pThis->aCSR[3] & RT_BIT(9)), !!(pThis->aCSR[3] & RT_BIT(10)),
+                    !!(pThis->aCSR[3] & RT_BIT(11)), !!(pThis->aCSR[3] & RT_BIT(12)), !!(pThis->aCSR[3] & RT_BIT(14)));
 
     pHlp->pfnPrintf(pHlp,
                     "CSR4=%#06x: JABM=%d JAB=%d TXSTRM=%d TXSTRT=%d RCVCOOM=%d RCVCCO=%d UINT=%d UINTCMD=%d\n"
                     "              MFCOM=%d MFCO=%d ASTRP_RCV=%d APAD_XMT=%d DPOLL=%d TIMER=%d EMAPLUS=%d EN124=%d\n",
-                    pData->aCSR[4],
-                    !!(pData->aCSR[4] & RT_BIT( 0)), !!(pData->aCSR[4] & RT_BIT( 1)), !!(pData->aCSR[4] & RT_BIT( 2)), !!(pData->aCSR[4] & RT_BIT( 3)),
-                    !!(pData->aCSR[4] & RT_BIT( 4)), !!(pData->aCSR[4] & RT_BIT( 5)), !!(pData->aCSR[4] & RT_BIT( 6)), !!(pData->aCSR[4] & RT_BIT( 7)),
-                    !!(pData->aCSR[4] & RT_BIT( 8)), !!(pData->aCSR[4] & RT_BIT( 9)), !!(pData->aCSR[4] & RT_BIT(10)), !!(pData->aCSR[4] & RT_BIT(11)),
-                    !!(pData->aCSR[4] & RT_BIT(12)), !!(pData->aCSR[4] & RT_BIT(13)), !!(pData->aCSR[4] & RT_BIT(14)), !!(pData->aCSR[4] & RT_BIT(15)));
+                    pThis->aCSR[4],
+                    !!(pThis->aCSR[4] & RT_BIT( 0)), !!(pThis->aCSR[4] & RT_BIT( 1)), !!(pThis->aCSR[4] & RT_BIT( 2)), !!(pThis->aCSR[4] & RT_BIT( 3)),
+                    !!(pThis->aCSR[4] & RT_BIT( 4)), !!(pThis->aCSR[4] & RT_BIT( 5)), !!(pThis->aCSR[4] & RT_BIT( 6)), !!(pThis->aCSR[4] & RT_BIT( 7)),
+                    !!(pThis->aCSR[4] & RT_BIT( 8)), !!(pThis->aCSR[4] & RT_BIT( 9)), !!(pThis->aCSR[4] & RT_BIT(10)), !!(pThis->aCSR[4] & RT_BIT(11)),
+                    !!(pThis->aCSR[4] & RT_BIT(12)), !!(pThis->aCSR[4] & RT_BIT(13)), !!(pThis->aCSR[4] & RT_BIT(14)), !!(pThis->aCSR[4] & RT_BIT(15)));
 
     pHlp->pfnPrintf(pHlp,
                     "CSR5=%#06x:\n",
-                    pData->aCSR[5]);
+                    pThis->aCSR[5]);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR6=%#06x: RLEN=%#x* TLEN=%#x* [* encoded]\n",
-                    pData->aCSR[6],
-                    (pData->aCSR[6] >> 8) & 0xf, (pData->aCSR[6] >> 12) & 0xf);
+                    pThis->aCSR[6],
+                    (pThis->aCSR[6] >> 8) & 0xf, (pThis->aCSR[6] >> 12) & 0xf);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR8..11=%#06x,%#06x,%#06x,%#06x: LADRF=%#018llx\n",
-                    pData->aCSR[8], pData->aCSR[9], pData->aCSR[10], pData->aCSR[11],
-                      (uint64_t)(pData->aCSR[ 8] & 0xffff)
-                    | (uint64_t)(pData->aCSR[ 9] & 0xffff) << 16
-                    | (uint64_t)(pData->aCSR[10] & 0xffff) << 32
-                    | (uint64_t)(pData->aCSR[11] & 0xffff) << 48);
+                    pThis->aCSR[8], pThis->aCSR[9], pThis->aCSR[10], pThis->aCSR[11],
+                      (uint64_t)(pThis->aCSR[ 8] & 0xffff)
+                    | (uint64_t)(pThis->aCSR[ 9] & 0xffff) << 16
+                    | (uint64_t)(pThis->aCSR[10] & 0xffff) << 32
+                    | (uint64_t)(pThis->aCSR[11] & 0xffff) << 48);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR12..14=%#06x,%#06x,%#06x: PADR=%02x:%02x:%02x:%02x:%02x:%02x (Current MAC Address)\n",
-                    pData->aCSR[12], pData->aCSR[13], pData->aCSR[14],
-                     pData->aCSR[12]       & 0xff,
-                    (pData->aCSR[12] >> 8) & 0xff,
-                     pData->aCSR[13]       & 0xff,
-                    (pData->aCSR[13] >> 8) & 0xff,
-                     pData->aCSR[14]       & 0xff,
-                    (pData->aCSR[14] >> 8) & 0xff);
+                    pThis->aCSR[12], pThis->aCSR[13], pThis->aCSR[14],
+                     pThis->aCSR[12]       & 0xff,
+                    (pThis->aCSR[12] >> 8) & 0xff,
+                     pThis->aCSR[13]       & 0xff,
+                    (pThis->aCSR[13] >> 8) & 0xff,
+                     pThis->aCSR[14]       & 0xff,
+                    (pThis->aCSR[14] >> 8) & 0xff);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR15=%#06x: DXR=%d DTX=%d LOOP=%d DXMTFCS=%d FCOLL=%d DRTY=%d INTL=%d PORTSEL=%d LTR=%d\n"
                     "              MENDECL=%d DAPC=%d DLNKTST=%d DRCVPV=%d DRCVBC=%d PROM=%d\n",
-                    pData->aCSR[15],
-                    !!(pData->aCSR[15] & RT_BIT( 0)), !!(pData->aCSR[15] & RT_BIT( 1)), !!(pData->aCSR[15] & RT_BIT( 2)), !!(pData->aCSR[15] & RT_BIT( 3)),
-                    !!(pData->aCSR[15] & RT_BIT( 4)), !!(pData->aCSR[15] & RT_BIT( 5)), !!(pData->aCSR[15] & RT_BIT( 6)),   (pData->aCSR[15] >> 7) & 3,
-                                                   !!(pData->aCSR[15] & RT_BIT( 9)), !!(pData->aCSR[15] & RT_BIT(10)), !!(pData->aCSR[15] & RT_BIT(11)),
-                    !!(pData->aCSR[15] & RT_BIT(12)), !!(pData->aCSR[15] & RT_BIT(13)), !!(pData->aCSR[15] & RT_BIT(14)), !!(pData->aCSR[15] & RT_BIT(15)));
+                    pThis->aCSR[15],
+                    !!(pThis->aCSR[15] & RT_BIT( 0)), !!(pThis->aCSR[15] & RT_BIT( 1)), !!(pThis->aCSR[15] & RT_BIT( 2)), !!(pThis->aCSR[15] & RT_BIT( 3)),
+                    !!(pThis->aCSR[15] & RT_BIT( 4)), !!(pThis->aCSR[15] & RT_BIT( 5)), !!(pThis->aCSR[15] & RT_BIT( 6)),   (pThis->aCSR[15] >> 7) & 3,
+                                                   !!(pThis->aCSR[15] & RT_BIT( 9)), !!(pThis->aCSR[15] & RT_BIT(10)), !!(pThis->aCSR[15] & RT_BIT(11)),
+                    !!(pThis->aCSR[15] & RT_BIT(12)), !!(pThis->aCSR[15] & RT_BIT(13)), !!(pThis->aCSR[15] & RT_BIT(14)), !!(pThis->aCSR[15] & RT_BIT(15)));
 
     pHlp->pfnPrintf(pHlp,
                     "CSR46=%#06x: POLL=%#06x (Poll Time Counter)\n",
-                    pData->aCSR[46], pData->aCSR[46] & 0xffff);
+                    pThis->aCSR[46], pThis->aCSR[46] & 0xffff);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR47=%#06x: POLLINT=%#06x (Poll Time Interval)\n",
-                    pData->aCSR[47], pData->aCSR[47] & 0xffff);
+                    pThis->aCSR[47], pThis->aCSR[47] & 0xffff);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR58=%#06x: SWSTYLE=%d %s SSIZE32=%d CSRPCNET=%d APERRENT=%d\n",
-                    pData->aCSR[58],
-                    pData->aCSR[58] & 0x7f,
-                    (pData->aCSR[58] & 0x7f) == 0 ? "C-LANCE / PCnet-ISA"
-                    : (pData->aCSR[58] & 0x7f) == 1 ? "ILACC"
-                    : (pData->aCSR[58] & 0x7f) == 2 ? "PCNet-PCI II"
-                    : (pData->aCSR[58] & 0x7f) == 3 ? "PCNet-PCI II controller"
+                    pThis->aCSR[58],
+                    pThis->aCSR[58] & 0x7f,
+                    (pThis->aCSR[58] & 0x7f) == 0 ? "C-LANCE / PCnet-ISA"
+                    : (pThis->aCSR[58] & 0x7f) == 1 ? "ILACC"
+                    : (pThis->aCSR[58] & 0x7f) == 2 ? "PCNet-PCI II"
+                    : (pThis->aCSR[58] & 0x7f) == 3 ? "PCNet-PCI II controller"
                     : "!!reserved!!",
-                    !!(pData->aCSR[58] & RT_BIT(8)), !!(pData->aCSR[58] & RT_BIT(9)), !!(pData->aCSR[58] & RT_BIT(10)));
+                    !!(pThis->aCSR[58] & RT_BIT(8)), !!(pThis->aCSR[58] & RT_BIT(9)), !!(pThis->aCSR[58] & RT_BIT(10)));
 
     pHlp->pfnPrintf(pHlp,
                     "CSR112=%04RX32: MFC=%04x (Missed receive Frame Count)\n",
-                    pData->aCSR[112], pData->aCSR[112] & 0xffff);
+                    pThis->aCSR[112], pThis->aCSR[112] & 0xffff);
 
     pHlp->pfnPrintf(pHlp,
                     "CSR122=%04RX32: RCVALGN=%04x (Receive Frame Align)\n",
-                    pData->aCSR[122], !!(pData->aCSR[122] & RT_BIT(0)));
+                    pThis->aCSR[122], !!(pThis->aCSR[122] & RT_BIT(0)));
 
     pHlp->pfnPrintf(pHlp,
                     "CSR124=%04RX32: RPA=%04x (Runt Packet Accept)\n",
-                    pData->aCSR[122], !!(pData->aCSR[122] & RT_BIT(3)));
+                    pThis->aCSR[122], !!(pThis->aCSR[122] & RT_BIT(3)));
 
 
@@ -4014 +4014 @@
                     "NNRDA=%08RX32\n"
                     ,
-                    CSR_RCVRL(pData), CSR_RCVRC(pData), pData->GCRDRA,
-                    CSR_CRDA(pData), CSR_CRBA(pData), CSR_CRBC(pData), CSR_CRST(pData),
-                    CSR_NRDA(pData), CSR_NRBA(pData), CSR_NRBC(pData), CSR_NRST(pData),
-                    CSR_NNRD(pData));
+                    CSR_RCVRL(pThis), CSR_RCVRC(pThis), pThis->GCRDRA,
+                    CSR_CRDA(pThis), CSR_CRBA(pThis), CSR_CRBC(pThis), CSR_CRST(pThis),
+                    CSR_NRDA(pThis), CSR_NRBA(pThis), CSR_NRBC(pThis), CSR_NRST(pThis),
+                    CSR_NNRD(pThis));
     if (fRcvRing)
     {
-        const unsigned  cb = 1 << pData->iLog2DescSize;
-        RTGCPHYS32      GCPhys = pData->GCRDRA;
-        unsigned        i = CSR_RCVRL(pData);
+        const unsigned  cb = 1 << pThis->iLog2DescSize;
+        RTGCPHYS32      GCPhys = pThis->GCRDRA;
+        unsigned        i = CSR_RCVRL(pThis);
         while (i-- > 0)
         {
             RMD rmd;
-            pcnetRmdLoad(pData, &rmd, PHYSADDR(pData, GCPhys), false);
+            pcnetRmdLoad(pThis, &rmd, PHYSADDR(pThis, GCPhys), false);
             pHlp->pfnPrintf(pHlp,
                             "%04x %RGp:%c%c RBADR=%08RX32 BCNT=%03x MCNT=%03x "
                             "OWN=%d ERR=%d FRAM=%d OFLO=%d CRC=%d BUFF=%d STP=%d ENP=%d BPE=%d "
                             "PAM=%d LAFM=%d BAM=%d RCC=%02x RPC=%02x ONES=%#x ZEROS=%d\n",
-                            i, GCPhys, i + 1 == CSR_RCVRC(pData) ? '*' : ' ', GCPhys == CSR_CRDA(pData) ? '*' : ' ',
+                            i, GCPhys, i + 1 == CSR_RCVRC(pThis) ? '*' : ' ', GCPhys == CSR_CRDA(pThis) ? '*' : ' ',
                             rmd.rmd0.rbadr, 4096 - rmd.rmd1.bcnt, rmd.rmd2.mcnt,
                             rmd.rmd1.own, rmd.rmd1.err, rmd.rmd1.fram, rmd.rmd1.oflo, rmd.rmd1.crc, rmd.rmd1.buff,
@@ -4052 +4052 @@
                     "NNXDA=%08RX32\n"
                     ,
-                    CSR_XMTRL(pData), CSR_XMTRC(pData),
-                    pData->GCTDRA, CSR_BADX(pData),
-                    CSR_PXDA(pData),                  CSR_PXBC(pData), CSR_PXST(pData),
-                    CSR_CXDA(pData), CSR_CXBA(pData), CSR_CXBC(pData), CSR_CXST(pData),
-                    CSR_NXDA(pData), CSR_NXBA(pData), CSR_NXBC(pData), CSR_NXST(pData),
-                    CSR_NNXD(pData));
+                    CSR_XMTRL(pThis), CSR_XMTRC(pThis),
+                    pThis->GCTDRA, CSR_BADX(pThis),
+                    CSR_PXDA(pThis),                  CSR_PXBC(pThis), CSR_PXST(pThis),
+                    CSR_CXDA(pThis), CSR_CXBA(pThis), CSR_CXBC(pThis), CSR_CXST(pThis),
+                    CSR_NXDA(pThis), CSR_NXBA(pThis), CSR_NXBC(pThis), CSR_NXST(pThis),
+                    CSR_NNXD(pThis));
     if (fXmtRing)
     {
-        const unsigned  cb = 1 << pData->iLog2DescSize;
-        RTGCPHYS32      GCPhys = pData->GCTDRA;
-        unsigned        i = CSR_XMTRL(pData);
+        const unsigned  cb = 1 << pThis->iLog2DescSize;
+        RTGCPHYS32      GCPhys = pThis->GCTDRA;
+        unsigned        i = CSR_XMTRL(pThis);
         while (i-- > 0)
         {
             TMD tmd;
-            pcnetTmdLoad(pData, &tmd, PHYSADDR(pData, GCPhys), false);
+            pcnetTmdLoad(pThis, &tmd, PHYSADDR(pThis, GCPhys), false);
             pHlp->pfnPrintf(pHlp,
                             "%04x %RGp:%c%c TBADR=%08RX32 BCNT=%03x OWN=%d "
@@ -4072 +4072 @@
                             "BUFF=%d UFLO=%d EXDEF=%d LCOL=%d LCAR=%d RTRY=%d TDR=%03x TRC=%#x ONES=%#x\n"
                             ,
-                            i, GCPhys, i + 1 == CSR_XMTRC(pData) ? '*' : ' ', GCPhys == CSR_CXDA(pData) ? '*' : ' ',
+                            i, GCPhys, i + 1 == CSR_XMTRC(pThis) ? '*' : ' ', GCPhys == CSR_CXDA(pThis) ? '*' : ' ',
                             tmd.tmd0.tbadr, 4096 - tmd.tmd1.bcnt,
                             tmd.tmd2.tdr,
@@ -4099 +4099 @@
     }
 
-    PDMCritSectLeave(&pData->CritSect);
+    PDMCritSectLeave(&pThis->CritSect);
 }
 
@@ -4112 +4112 @@
 static DECLCALLBACK(int) pcnetSavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-
-    int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+
+    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertRC(rc);
-    PDMCritSectLeave(&pData->CritSect);
+    PDMCritSectLeave(&pThis->CritSect);
 
     return VINF_SUCCESS;
@@ -4131 +4131 @@
 static DECLCALLBACK(int) pcnetSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     int rc = VINF_SUCCESS;
 
-    SSMR3PutBool(pSSMHandle, pData->fLinkUp);
-    SSMR3PutU32(pSSMHandle, pData->u32RAP);
-    SSMR3PutS32(pSSMHandle, pData->iISR);
-    SSMR3PutU32(pSSMHandle, pData->u32Lnkst);
-    SSMR3PutBool(pSSMHandle, pData->fPrivIfEnabled);              /* >= If version 0.9 */
-    SSMR3PutBool(pSSMHandle, pData->fSignalRxMiss);               /* >= If version 0.10 */
-    SSMR3PutGCPhys32(pSSMHandle, pData->GCRDRA);
-    SSMR3PutGCPhys32(pSSMHandle, pData->GCTDRA);
-    SSMR3PutMem(pSSMHandle, pData->aPROM, sizeof(pData->aPROM));
-    SSMR3PutMem(pSSMHandle, pData->aCSR, sizeof(pData->aCSR));
-    SSMR3PutMem(pSSMHandle, pData->aBCR, sizeof(pData->aBCR));
-    SSMR3PutMem(pSSMHandle, pData->aMII, sizeof(pData->aMII));
-    SSMR3PutU16(pSSMHandle, pData->u16CSR0LastSeenByGuest);
-    SSMR3PutU64(pSSMHandle, pData->u64LastPoll);
-    SSMR3PutMem(pSSMHandle, &pData->MacConfigured, sizeof(pData->MacConfigured));
-    SSMR3PutBool(pSSMHandle, pData->fAm79C973);                   /* >= If version 0.8 */
-    SSMR3PutU32(pSSMHandle, pData->u32LinkSpeed);
+    SSMR3PutBool(pSSMHandle, pThis->fLinkUp);
+    SSMR3PutU32(pSSMHandle, pThis->u32RAP);
+    SSMR3PutS32(pSSMHandle, pThis->iISR);
+    SSMR3PutU32(pSSMHandle, pThis->u32Lnkst);
+    SSMR3PutBool(pSSMHandle, pThis->fPrivIfEnabled);              /* >= If version 0.9 */
+    SSMR3PutBool(pSSMHandle, pThis->fSignalRxMiss);               /* >= If version 0.10 */
+    SSMR3PutGCPhys32(pSSMHandle, pThis->GCRDRA);
+    SSMR3PutGCPhys32(pSSMHandle, pThis->GCTDRA);
+    SSMR3PutMem(pSSMHandle, pThis->aPROM, sizeof(pThis->aPROM));
+    SSMR3PutMem(pSSMHandle, pThis->aCSR, sizeof(pThis->aCSR));
+    SSMR3PutMem(pSSMHandle, pThis->aBCR, sizeof(pThis->aBCR));
+    SSMR3PutMem(pSSMHandle, pThis->aMII, sizeof(pThis->aMII));
+    SSMR3PutU16(pSSMHandle, pThis->u16CSR0LastSeenByGuest);
+    SSMR3PutU64(pSSMHandle, pThis->u64LastPoll);
+    SSMR3PutMem(pSSMHandle, &pThis->MacConfigured, sizeof(pThis->MacConfigured));
+    SSMR3PutBool(pSSMHandle, pThis->fAm79C973);                   /* >= If version 0.8 */
+    SSMR3PutU32(pSSMHandle, pThis->u32LinkSpeed);
 #ifdef PCNET_NO_POLLING
     return VINF_SUCCESS;
 #else
-    rc = TMR3TimerSave(pData->CTX_SUFF(pTimerPoll), pSSMHandle);
+    rc = TMR3TimerSave(pThis->CTX_SUFF(pTimerPoll), pSSMHandle);
     if (RT_FAILURE(rc))
         return rc;
 #endif
-    if (pData->fAm79C973)
-        rc = TMR3TimerSave(pData->CTX_SUFF(pTimerSoftInt), pSSMHandle);
+    if (pThis->fAm79C973)
+        rc = TMR3TimerSave(pThis->CTX_SUFF(pTimerSoftInt), pSSMHandle);
     return rc;
 }
@@ -4173 +4173 @@
 static DECLCALLBACK(int) pcnetLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-
-    int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+
+    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertRC(rc);
-    PDMCritSectLeave(&pData->CritSect);
+    PDMCritSectLeave(&pThis->CritSect);
 
     return VINF_SUCCESS;
@@ -4193 +4193 @@
 static DECLCALLBACK(int) pcnetLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     RTMAC       Mac;
     if (   SSM_VERSION_MAJOR_CHANGED(u32Version, PCNET_SAVEDSTATE_VERSION)
@@ -4200 +4200 @@
 
     /* restore data */
-    SSMR3GetBool(pSSMHandle, &pData->fLinkUp);
-    SSMR3GetU32(pSSMHandle, &pData->u32RAP);
-    SSMR3GetS32(pSSMHandle, &pData->iISR);
-    SSMR3GetU32(pSSMHandle, &pData->u32Lnkst);
+    SSMR3GetBool(pSSMHandle, &pThis->fLinkUp);
+    SSMR3GetU32(pSSMHandle, &pThis->u32RAP);
+    SSMR3GetS32(pSSMHandle, &pThis->iISR);
+    SSMR3GetU32(pSSMHandle, &pThis->u32Lnkst);
     if (   SSM_VERSION_MAJOR(u32Version) >  0
         || SSM_VERSION_MINOR(u32Version) >= 9)
     {
-        SSMR3GetBool(pSSMHandle, &pData->fPrivIfEnabled);
-        if (pData->fPrivIfEnabled)
+        SSMR3GetBool(pSSMHandle, &pThis->fPrivIfEnabled);
+        if (pThis->fPrivIfEnabled)
             LogRel(("PCNet#%d: Enabling private interface\n", PCNET_INST_NR));
     }
@@ -4214 +4214 @@
         || SSM_VERSION_MINOR(u32Version) >= 10)
     {
-        SSMR3GetBool(pSSMHandle, &pData->fSignalRxMiss);
-    }
-    SSMR3GetGCPhys32(pSSMHandle, &pData->GCRDRA);
-    SSMR3GetGCPhys32(pSSMHandle, &pData->GCTDRA);
-    SSMR3GetMem(pSSMHandle, &pData->aPROM, sizeof(pData->aPROM));
-    SSMR3GetMem(pSSMHandle, &pData->aCSR, sizeof(pData->aCSR));
-    SSMR3GetMem(pSSMHandle, &pData->aBCR, sizeof(pData->aBCR));
-    SSMR3GetMem(pSSMHandle, &pData->aMII, sizeof(pData->aMII));
-    SSMR3GetU16(pSSMHandle, &pData->u16CSR0LastSeenByGuest);
-    SSMR3GetU64(pSSMHandle, &pData->u64LastPoll);
+        SSMR3GetBool(pSSMHandle, &pThis->fSignalRxMiss);
+    }
+    SSMR3GetGCPhys32(pSSMHandle, &pThis->GCRDRA);
+    SSMR3GetGCPhys32(pSSMHandle, &pThis->GCTDRA);
+    SSMR3GetMem(pSSMHandle, &pThis->aPROM, sizeof(pThis->aPROM));
+    SSMR3GetMem(pSSMHandle, &pThis->aCSR, sizeof(pThis->aCSR));
+    SSMR3GetMem(pSSMHandle, &pThis->aBCR, sizeof(pThis->aBCR));
+    SSMR3GetMem(pSSMHandle, &pThis->aMII, sizeof(pThis->aMII));
+    SSMR3GetU16(pSSMHandle, &pThis->u16CSR0LastSeenByGuest);
+    SSMR3GetU64(pSSMHandle, &pThis->u64LastPoll);
     SSMR3GetMem(pSSMHandle, &Mac, sizeof(Mac));
-    Assert(     !memcmp(&Mac, &pData->MacConfigured, sizeof(Mac))
+    Assert(     !memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac))
            ||   SSMR3HandleGetAfter(pSSMHandle) == SSMAFTER_DEBUG_IT);
-    SSMR3GetBool(pSSMHandle, &pData->fAm79C973);
-    SSMR3GetU32(pSSMHandle, &pData->u32LinkSpeed);
+    SSMR3GetBool(pSSMHandle, &pThis->fAm79C973);
+    SSMR3GetU32(pSSMHandle, &pThis->u32LinkSpeed);
 #ifndef PCNET_NO_POLLING
-    TMR3TimerLoad(pData->CTX_SUFF(pTimerPoll), pSSMHandle);
-#endif
-    if (pData->fAm79C973)
+    TMR3TimerLoad(pThis->CTX_SUFF(pTimerPoll), pSSMHandle);
+#endif
+    if (pThis->fAm79C973)
     {
         if (   SSM_VERSION_MAJOR(u32Version) >  0
             || SSM_VERSION_MINOR(u32Version) >= 8)
-            TMR3TimerLoad(pData->CTX_SUFF(pTimerSoftInt), pSSMHandle);
-    }
-
-    pData->iLog2DescSize = BCR_SWSTYLE(pData)
+            TMR3TimerLoad(pThis->CTX_SUFF(pTimerSoftInt), pSSMHandle);
+    }
+
+    pThis->iLog2DescSize = BCR_SWSTYLE(pThis)
                          ? 4
                          : 3;
-    pData->GCUpperPhys   = BCR_SSIZE32(pData)
+    pThis->GCUpperPhys   = BCR_SSIZE32(pThis)
                          ? 0
-                         : (0xff00 & (uint32_t)pData->aCSR[2]) << 16;
+                         : (0xff00 & (uint32_t)pThis->aCSR[2]) << 16;
 
     /* update promiscuous mode. */
-    if (pData->pDrv)
-        pData->pDrv->pfnSetPromiscuousMode(pData->pDrv, CSR_PROM(pData));
+    if (pThis->pDrv)
+        pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv, CSR_PROM(pThis));
 
 #ifdef PCNET_NO_POLLING
     /* Enable physical monitoring again (!) */
-    pcnetUpdateRingHandlers(pData);
+    pcnetUpdateRingHandlers(pThis);
 #endif
     /* Indicate link down to the guest OS that all network connections have been lost. */
-    if (pData->fLinkUp)
-    {
-        pData->fLinkTempDown = true;
-        pData->cLinkDownReported = 0;
-        pData->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR (this is probably wrong) */
-        pData->Led.Asserted.s.fError = pData->Led.Actual.s.fError = 1;
-        return TMTimerSetMillies(pData->pTimerRestore, 5000);
+    if (pThis->fLinkUp)
+    {
+        pThis->fLinkTempDown = true;
+        pThis->cLinkDownReported = 0;
+        pThis->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR (this is probably wrong) */
+        pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
+        return TMTimerSetMillies(pThis->pTimerRestore, 5000);
     }
     return VINF_SUCCESS;
@@ -4278 +4278 @@
 static DECLCALLBACK(void *) pcnetQueryInterface(struct PDMIBASE *pInterface, PDMINTERFACE enmInterface)
 {
-    PCNetState *pData = (PCNetState *)((uintptr_t)pInterface - RT_OFFSETOF(PCNetState, IBase));
-    Assert(&pData->IBase == pInterface);
+    PCNetState *pThis = (PCNetState *)((uintptr_t)pInterface - RT_OFFSETOF(PCNetState, IBase));
+    Assert(&pThis->IBase == pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         case PDMINTERFACE_NETWORK_PORT:
-            return &pData->INetworkPort;
+            return &pThis->INetworkPort;
         case PDMINTERFACE_NETWORK_CONFIG:
-            return &pData->INetworkConfig;
+            return &pThis->INetworkConfig;
         case PDMINTERFACE_LED_PORTS:
-            return &pData->ILeds;
+            return &pThis->ILeds;
         default:
             return NULL;
@@ -4306 +4306 @@
  * @param   pInterface      Pointer to the interface structure containing the called function pointer.
  */
-static int pcnetCanReceive(PCNetState *pData)
-{
-    int rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+static int pcnetCanReceive(PCNetState *pThis)
+{
+    int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertReleaseRC(rc);
 
     rc = VERR_NET_NO_BUFFER_SPACE;
 
-    if (RT_LIKELY(!CSR_DRX(pData) && !CSR_STOP(pData) && !CSR_SPND(pData)))
-    {
-        if (HOST_IS_OWNER(CSR_CRST(pData)) && pData->GCRDRA)
-            pcnetRdtePoll(pData);
-
-        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pData))))
+    if (RT_LIKELY(!CSR_DRX(pThis) && !CSR_STOP(pThis) && !CSR_SPND(pThis)))
+    {
+        if (HOST_IS_OWNER(CSR_CRST(pThis)) && pThis->GCRDRA)
+            pcnetRdtePoll(pThis);
+
+        if (RT_UNLIKELY(HOST_IS_OWNER(CSR_CRST(pThis))))
         {
             /** @todo Notify the guest _now_. Will potentially increase the interrupt load */
-            if (pData->fSignalRxMiss)
-                pData->aCSR[0] |= 0x1000; /* Set MISS flag */
+            if (pThis->fSignalRxMiss)
+                pThis->aCSR[0] |= 0x1000; /* Set MISS flag */
         }
         else
@@ -4328 +4328 @@
     }
 
-    PDMCritSectLeave(&pData->CritSect);
+    PDMCritSectLeave(&pThis->CritSect);
     return rc;
 }
@@ -4338 +4338 @@
 static DECLCALLBACK(int) pcnetWaitReceiveAvail(PPDMINETWORKPORT pInterface, unsigned cMillies)
 {
-    PCNetState *pData = INETWORKPORT_2_DATA(pInterface);
-
-    int rc = pcnetCanReceive(pData);
+    PCNetState *pThis = INETWORKPORT_2_DATA(pInterface);
+
+    int rc = pcnetCanReceive(pThis);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
@@ -4347 +4347 @@
 
     rc = VERR_INTERRUPTED;
-    ASMAtomicXchgBool(&pData->fMaybeOutOfSpace, true);
-    STAM_PROFILE_START(&pData->StatRxOverflow, a);
-    while (RT_LIKELY(PDMDevHlpVMState(pData->CTX_SUFF(pDevIns)) == VMSTATE_RUNNING))
-    {
-        int rc2 = pcnetCanReceive(pData);
+    ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, true);
+    STAM_PROFILE_START(&pThis->StatRxOverflow, a);
+    while (RT_LIKELY(PDMDevHlpVMState(pThis->CTX_SUFF(pDevIns)) == VMSTATE_RUNNING))
+    {
+        int rc2 = pcnetCanReceive(pThis);
         if (RT_SUCCESS(rc2))
         {
@@ -4360 +4360 @@
         /* Start the poll timer once which will remain active as long fMaybeOutOfSpace
          * is true -- even if (transmit) polling is disabled (CSR_DPOLL). */
-        rc2 = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+        rc2 = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
         AssertReleaseRC(rc2);
-        pcnetPollTimerStart(pData);
-        PDMCritSectLeave(&pData->CritSect);
-        RTSemEventWait(pData->hEventOutOfRxSpace, cMillies);
-    }
-    STAM_PROFILE_STOP(&pData->StatRxOverflow, a);
-    ASMAtomicXchgBool(&pData->fMaybeOutOfSpace, false);
+        pcnetPollTimerStart(pThis);
+        PDMCritSectLeave(&pThis->CritSect);
+        RTSemEventWait(pThis->hEventOutOfRxSpace, cMillies);
+    }
+    STAM_PROFILE_STOP(&pThis->StatRxOverflow, a);
+    ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, false);
 
     return rc;
@@ -4384 +4384 @@
 static DECLCALLBACK(int) pcnetReceive(PPDMINETWORKPORT pInterface, const void *pvBuf, size_t cb)
 {
-    PCNetState *pData = INETWORKPORT_2_DATA(pInterface);
+    PCNetState *pThis = INETWORKPORT_2_DATA(pInterface);
     int         rc;
 
-    STAM_PROFILE_ADV_START(&pData->StatReceive, a);
-    rc = PDMCritSectEnter(&pData->CritSect, VERR_SEM_BUSY);
+    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
+    rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     AssertReleaseRC(rc);
 
     if (cb > 70) /* unqualified guess */
-        pData->Led.Asserted.s.fReading = pData->Led.Actual.s.fReading = 1;
-    pcnetReceiveNoSync(pData, (const uint8_t *)pvBuf, cb);
-    pData->Led.Actual.s.fReading = 0;
-
-    PDMCritSectLeave(&pData->CritSect);
-    STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
+        pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1;
+    pcnetReceiveNoSync(pThis, (const uint8_t *)pvBuf, cb);
+    pThis->Led.Actual.s.fReading = 0;
+
+    PDMCritSectLeave(&pThis->CritSect);
+    STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
 
     return VINF_SUCCESS;
@@ -4416 +4416 @@
 static DECLCALLBACK(int) pcnetGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
 {
-    PCNetState *pData = INETWORKCONFIG_2_DATA(pInterface);
-    memcpy(pMac, pData->aPROM, sizeof(*pMac));
+    PCNetState *pThis = INETWORKCONFIG_2_DATA(pInterface);
+    memcpy(pMac, pThis->aPROM, sizeof(*pMac));
     return VINF_SUCCESS;
 }
@@ -4431 +4431 @@
 static DECLCALLBACK(PDMNETWORKLINKSTATE) pcnetGetLinkState(PPDMINETWORKCONFIG pInterface)
 {
-    PCNetState *pData = INETWORKCONFIG_2_DATA(pInterface);
-    if (pData->fLinkUp && !pData->fLinkTempDown)
+    PCNetState *pThis = INETWORKCONFIG_2_DATA(pInterface);
+    if (pThis->fLinkUp && !pThis->fLinkTempDown)
         return PDMNETWORKLINKSTATE_UP;
-    if (!pData->fLinkUp)
+    if (!pThis->fLinkUp)
         return PDMNETWORKLINKSTATE_DOWN;
-    if (pData->fLinkTempDown)
+    if (pThis->fLinkTempDown)
         return PDMNETWORKLINKSTATE_DOWN_RESUME;
     AssertMsgFailed(("Invalid link state!\n"));
@@ -4453 +4453 @@
 static DECLCALLBACK(int) pcnetSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
 {
-    PCNetState *pData = INETWORKCONFIG_2_DATA(pInterface);
+    PCNetState *pThis = INETWORKCONFIG_2_DATA(pInterface);
     bool fLinkUp;
     if (    enmState != PDMNETWORKLINKSTATE_DOWN
@@ -4464 +4464 @@
     /* has the state changed? */
     fLinkUp = enmState == PDMNETWORKLINKSTATE_UP;
-    if (pData->fLinkUp != fLinkUp)
-    {
-        pData->fLinkUp = fLinkUp;
+    if (pThis->fLinkUp != fLinkUp)
+    {
+        pThis->fLinkUp = fLinkUp;
         if (fLinkUp)
         {
             /* connect */
-            pData->aCSR[0] &= ~(RT_BIT(15) | RT_BIT(13)); /* ERR | CERR - probably not 100% correct either... */
-            pData->Led.Actual.s.fError = 0;
+            pThis->aCSR[0] &= ~(RT_BIT(15) | RT_BIT(13)); /* ERR | CERR - probably not 100% correct either... */
+            pThis->Led.Actual.s.fError = 0;
         }
         else
         {
             /* disconnect */
-            pData->cLinkDownReported = 0;
-            pData->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR (this is probably wrong) */
-            pData->Led.Asserted.s.fError = pData->Led.Actual.s.fError = 1;
+            pThis->cLinkDownReported = 0;
+            pThis->aCSR[0] |= RT_BIT(15) | RT_BIT(13); /* ERR | CERR (this is probably wrong) */
+            pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1;
         }
-        Assert(!PDMCritSectIsOwner(&pData->CritSect));
-        pData->pDrv->pfnNotifyLinkChanged(pData->pDrv, enmState);
+        Assert(!PDMCritSectIsOwner(&pThis->CritSect));
+        pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, enmState);
     }
     return VINF_SUCCESS;
@@ -4497 +4497 @@
 static DECLCALLBACK(int) pcnetQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
 {
-    PCNetState *pData = (PCNetState *)( (uintptr_t)pInterface - RT_OFFSETOF(PCNetState, ILeds) );
+    PCNetState *pThis = (PCNetState *)( (uintptr_t)pInterface - RT_OFFSETOF(PCNetState, ILeds) );
     if (iLUN == 0)
     {
-        *ppLed = &pData->Led;
+        *ppLed = &pThis->Led;
         return VINF_SUCCESS;
     }
@@ -4532 +4532 @@
 static DECLCALLBACK(void) pcnetReset(PPDMDEVINS pDevIns)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-    if (pData->fLinkTempDown)
-    {
-        pData->cLinkDownReported = 0x10000;
-        TMTimerStop(pData->pTimerRestore);
-        pcnetTimerRestore(pDevIns, pData->pTimerRestore);
-    }
-    if (pData->pSharedMMIOR3)
-        pcnetInitSharedMemory(pData);
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+    if (pThis->fLinkTempDown)
+    {
+        pThis->cLinkDownReported = 0x10000;
+        TMTimerStop(pThis->pTimerRestore);
+        pcnetTimerRestore(pDevIns, pThis->pTimerRestore);
+    }
+    if (pThis->pSharedMMIOR3)
+        pcnetInitSharedMemory(pThis);
 
     /** @todo How to flush the queues? */
-    pcnetHardReset(pData);
+    pcnetHardReset(pThis);
 }
 
@@ -4552 +4552 @@
 static DECLCALLBACK(void) pcnetRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-    pData->pDevInsRC     = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->pXmitQueueRC  = PDMQueueRCPtr(pData->pXmitQueueR3);
-    pData->pCanRxQueueRC = PDMQueueRCPtr(pData->pCanRxQueueR3);
-    if (pData->pSharedMMIOR3)
-        pData->pSharedMMIORC += offDelta;
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+    pThis->pDevInsRC     = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->pXmitQueueRC  = PDMQueueRCPtr(pThis->pXmitQueueR3);
+    pThis->pCanRxQueueRC = PDMQueueRCPtr(pThis->pCanRxQueueR3);
+    if (pThis->pSharedMMIOR3)
+        pThis->pSharedMMIORC += offDelta;
 #ifdef PCNET_NO_POLLING
-    pData->pfnEMInterpretInstructionRC += offDelta;
+    pThis->pfnEMInterpretInstructionRC += offDelta;
 #else
-    pData->pTimerPollRC  = TMTimerRCPtr(pData->pTimerPollR3);
-#endif
-    if (pData->fAm79C973)
-        pData->pTimerSoftIntRC = TMTimerRCPtr(pData->pTimerSoftIntR3);
+    pThis->pTimerPollRC  = TMTimerRCPtr(pThis->pTimerPollR3);
+#endif
+    if (pThis->fAm79C973)
+        pThis->pTimerSoftIntRC = TMTimerRCPtr(pThis->pTimerSoftIntR3);
 }
 
@@ -4579 +4579 @@
 static DECLCALLBACK(int) pcnetDestruct(PPDMDEVINS pDevIns)
 {
-    PCNetState *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
-
-    if (PDMCritSectIsInitialized(&pData->CritSect))
+    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
+
+    if (PDMCritSectIsInitialized(&pThis->CritSect))
     {
         /*
@@ -4588 +4588 @@
          * will take care of terminating and cleaning up the thread.
          */
-        RTSemEventDestroy(pData->hSendEventSem);
-        pData->hSendEventSem = NIL_RTSEMEVENT;
-        RTSemEventSignal(pData->hEventOutOfRxSpace);
-        RTSemEventDestroy(pData->hEventOutOfRxSpace);
-        pData->hEventOutOfRxSpace = NIL_RTSEMEVENT;
-        PDMR3CritSectDelete(&pData->CritSect);
+        RTSemEventDestroy(pThis->hSendEventSem);
+        pThis->hSendEventSem = NIL_RTSEMEVENT;
+        RTSemEventSignal(pThis->hEventOutOfRxSpace);
+        RTSemEventDestroy(pThis->hEventOutOfRxSpace);
+        pThis->hEventOutOfRxSpace = NIL_RTSEMEVENT;
+        PDMR3CritSectDelete(&pThis->CritSect);
     }
 #ifdef PCNET_QUEUE_SEND_PACKETS
-    if (pData->apXmitRingBuffer)
-        RTMemFree(pData->apXmitRingBuffer[0]);
+    if (pThis->apXmitRingBuffer)
+        RTMemFree(pThis->apXmitRingBuffer[0]);
 #endif
     return VINF_SUCCESS;
@@ -4618 +4618 @@
 static DECLCALLBACK(int) pcnetConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    PCNetState     *pData = PDMINS_2_DATA(pDevIns, PCNetState *);
+    PCNetState     *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
     PPDMIBASE       pBase;
     char            szTmp[128];
@@ -4626 +4626 @@
     Assert((iInstance >= 0) && (iInstance < 4));
 
-    Assert(RT_ELEMENTS(pData->aBCR) == BCR_MAX_RAP);
-    Assert(RT_ELEMENTS(pData->aMII) == MII_MAX_REG);
-    Assert(sizeof(pData->abSendBuf) == RT_ALIGN_Z(sizeof(pData->abSendBuf), 16));
+    Assert(RT_ELEMENTS(pThis->aBCR) == BCR_MAX_RAP);
+    Assert(RT_ELEMENTS(pThis->aMII) == MII_MAX_REG);
+    Assert(sizeof(pThis->abSendBuf) == RT_ALIGN_Z(sizeof(pThis->abSendBuf), 16));
 
     /*
      * Init what's required to make the destructor safe.
      */
-    pData->hEventOutOfRxSpace = NIL_RTSEMEVENT;
-    pData->hSendEventSem = NIL_RTSEMEVENT;
+    pThis->hEventOutOfRxSpace = NIL_RTSEMEVENT;
+    pThis->hSendEventSem = NIL_RTSEMEVENT;
 
     /*
@@ -4646 +4646 @@
      * Read the configuration.
      */
-    rc = CFGMR3QueryBytes(pCfgHandle, "MAC", &pData->MacConfigured, sizeof(pData->MacConfigured));
+    rc = CFGMR3QueryBytes(pCfgHandle, "MAC", &pThis->MacConfigured, sizeof(pThis->MacConfigured));
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"MAC\" value"));
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "CableConnected", &pData->fLinkUp, true);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "CableConnected", &pThis->fLinkUp, true);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"CableConnected\" value"));
 
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "Am79C973", &pData->fAm79C973, false);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "Am79C973", &pThis->fAm79C973, false);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"Am79C973\" value"));
 
-    rc = CFGMR3QueryU32Def(pCfgHandle, "LineSpeed", &pData->u32LinkSpeed, 1000000); /* 1GBit/s (in kbps units)*/
+    rc = CFGMR3QueryU32Def(pCfgHandle, "LineSpeed", &pThis->u32LinkSpeed, 1000000); /* 1GBit/s (in kbps units)*/
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -4666 +4666 @@
 
 #ifdef PCNET_GC_ENABLED
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "GCEnabled", &pData->fGCEnabled, true);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "GCEnabled", &pThis->fGCEnabled, true);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"GCEnabled\" value"));
 
-    rc = CFGMR3QueryBoolDef(pCfgHandle, "R0Enabled", &pData->fR0Enabled, true);
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "R0Enabled", &pThis->fR0Enabled, true);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -4677 +4677 @@
 
 #else /* !PCNET_GC_ENABLED */
-    pData->fGCEnabled = false;
-    pData->fR0Enabled = false;
+    pThis->fGCEnabled = false;
+    pThis->fR0Enabled = false;
 #endif /* !PCNET_GC_ENABLED */
 
@@ -4685 +4685 @@
      * Initialize data (most of it anyway).
      */
-    pData->pDevInsR3                        = pDevIns;
-    pData->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->Led.u32Magic                     = PDMLED_MAGIC;
+    pThis->pDevInsR3                        = pDevIns;
+    pThis->pDevInsR0                        = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC                        = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->Led.u32Magic                     = PDMLED_MAGIC;
     /* IBase */
-    pData->IBase.pfnQueryInterface          = pcnetQueryInterface;
+    pThis->IBase.pfnQueryInterface          = pcnetQueryInterface;
     /* INeworkPort */
-    pData->INetworkPort.pfnWaitReceiveAvail = pcnetWaitReceiveAvail;
-    pData->INetworkPort.pfnReceive          = pcnetReceive;
+    pThis->INetworkPort.pfnWaitReceiveAvail = pcnetWaitReceiveAvail;
+    pThis->INetworkPort.pfnReceive          = pcnetReceive;
     /* INetworkConfig */
-    pData->INetworkConfig.pfnGetMac         = pcnetGetMac;
-    pData->INetworkConfig.pfnGetLinkState   = pcnetGetLinkState;
-    pData->INetworkConfig.pfnSetLinkState   = pcnetSetLinkState;
+    pThis->INetworkConfig.pfnGetMac         = pcnetGetMac;
+    pThis->INetworkConfig.pfnGetLinkState   = pcnetGetLinkState;
+    pThis->INetworkConfig.pfnSetLinkState   = pcnetSetLinkState;
     /* ILeds */
-    pData->ILeds.pfnQueryStatusLed          = pcnetQueryStatusLed;
+    pThis->ILeds.pfnQueryStatusLed          = pcnetQueryStatusLed;
 
     /* PCI Device */
-    PCIDevSetVendorId(&pData->PciDev, 0x1022);
-    PCIDevSetDeviceId(&pData->PciDev, 0x2000);
-    pData->PciDev.config[0x04] = 0x07; /* command */
-    pData->PciDev.config[0x05] = 0x00;
-    pData->PciDev.config[0x06] = 0x80; /* status */
-    pData->PciDev.config[0x07] = 0x02;
-    pData->PciDev.config[0x08] = pData->fAm79C973 ? 0x40 : 0x10; /* revision */
-    pData->PciDev.config[0x09] = 0x00;
-    pData->PciDev.config[0x0a] = 0x00; /* ethernet network controller */
-    pData->PciDev.config[0x0b] = 0x02;
-    pData->PciDev.config[0x0e] = 0x00; /* header_type */
-
-    pData->PciDev.config[0x10] = 0x01; /* IO Base */
-    pData->PciDev.config[0x11] = 0x00;
-    pData->PciDev.config[0x12] = 0x00;
-    pData->PciDev.config[0x13] = 0x00;
-    pData->PciDev.config[0x14] = 0x00; /* MMIO Base */
-    pData->PciDev.config[0x15] = 0x00;
-    pData->PciDev.config[0x16] = 0x00;
-    pData->PciDev.config[0x17] = 0x00;
+    PCIDevSetVendorId(&pThis->PciDev, 0x1022);
+    PCIDevSetDeviceId(&pThis->PciDev, 0x2000);
+    pThis->PciDev.config[0x04] = 0x07; /* command */
+    pThis->PciDev.config[0x05] = 0x00;
+    pThis->PciDev.config[0x06] = 0x80; /* status */
+    pThis->PciDev.config[0x07] = 0x02;
+    pThis->PciDev.config[0x08] = pThis->fAm79C973 ? 0x40 : 0x10; /* revision */
+    pThis->PciDev.config[0x09] = 0x00;
+    pThis->PciDev.config[0x0a] = 0x00; /* ethernet network controller */
+    pThis->PciDev.config[0x0b] = 0x02;
+    pThis->PciDev.config[0x0e] = 0x00; /* header_type */
+
+    pThis->PciDev.config[0x10] = 0x01; /* IO Base */
+    pThis->PciDev.config[0x11] = 0x00;
+    pThis->PciDev.config[0x12] = 0x00;
+    pThis->PciDev.config[0x13] = 0x00;
+    pThis->PciDev.config[0x14] = 0x00; /* MMIO Base */
+    pThis->PciDev.config[0x15] = 0x00;
+    pThis->PciDev.config[0x16] = 0x00;
+    pThis->PciDev.config[0x17] = 0x00;
 
     /* subsystem and subvendor IDs */
-    pData->PciDev.config[0x2c] = 0x22; /* subsystem vendor id */
-    pData->PciDev.config[0x2d] = 0x10;
-    pData->PciDev.config[0x2e] = 0x00; /* subsystem id */
-    pData->PciDev.config[0x2f] = 0x20;
-    pData->PciDev.config[0x3d] = 1;    /* interrupt pin 0 */
-    pData->PciDev.config[0x3e] = 0x06;
-    pData->PciDev.config[0x3f] = 0xff;
+    pThis->PciDev.config[0x2c] = 0x22; /* subsystem vendor id */
+    pThis->PciDev.config[0x2d] = 0x10;
+    pThis->PciDev.config[0x2e] = 0x00; /* subsystem id */
+    pThis->PciDev.config[0x2f] = 0x20;
+    pThis->PciDev.config[0x3d] = 1;    /* interrupt pin 0 */
+    pThis->PciDev.config[0x3e] = 0x06;
+    pThis->PciDev.config[0x3f] = 0xff;
 
     /*
      * Register the PCI device, its I/O regions, the timer and the saved state item.
      */
-    rc = PDMDevHlpPCIRegister(pDevIns, &pData->PciDev);
+    rc = PDMDevHlpPCIRegister(pDevIns, &pThis->PciDev);
     if (RT_FAILURE(rc))
         return rc;
@@ -4761 +4761 @@
          * should not care if there is an additional PCI ressource but just in case we made this configurable.
          */
-        rc = PDMDevHlpMMIO2Register(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE, 0, (void **)&pData->pSharedMMIOR3, "PCNetShMem");
+        rc = PDMDevHlpMMIO2Register(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE, 0, (void **)&pThis->pSharedMMIOR3, "PCNetShMem");
         if (RT_FAILURE(rc))
             return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                        N_("Failed to allocate %u bytes of memory for the PCNet device"), PCNET_GUEST_SHARED_MEMORY_SIZE);
-        rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pData->pSharedMMIORC);
+        rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pThis->pSharedMMIORC);
         if (RT_FAILURE(rc))
             return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                        N_("Failed to map 8192 bytes of memory for the PCNet device into the hyper memory"));
-        pData->pSharedMMIOR0 = (uintptr_t)pData->pSharedMMIOR3; /** @todo #1865: Map MMIO2 into ring-0. */
-
-        pcnetInitSharedMemory(pData);
+        pThis->pSharedMMIOR0 = (uintptr_t)pThis->pSharedMMIOR3; /** @todo #1865: Map MMIO2 into ring-0. */
+
+        pcnetInitSharedMemory(pThis);
         rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE,
                                           PCI_ADDRESS_SPACE_MEM, pcnetMMIOSharedMap);
@@ -4782 +4782 @@
      * Resolve the R0 and RC handlers.
      */
-    rc = PDMR3GetSymbolR0Lazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", &pData->pfnEMInterpretInstructionR0);
+    rc = PDMR3GetSymbolR0Lazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", &pThis->pfnEMInterpretInstructionR0);
     if (RT_SUCCESS(rc))
-        rc = PDMR3GetSymbolGCLazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", (RTGCPTR *)&pData->pfnEMInterpretInstructionRC);
+        rc = PDMR3GetSymbolGCLazy(PDMDevHlpGetVM(pDevIns), NULL, "EMInterpretInstruction", (RTGCPTR *)&pThis->pfnEMInterpretInstructionRC);
     AssertLogRelMsgRCReturn(rc, ("PDMR3GetSymbolGCLazy(EMInterpretInstruction) -> %Vrc\n", rc), rc);
 #else
     rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimer,
-                                "PCNet Poll Timer", &pData->pTimerPollR3);
+                                "PCNet Poll Timer", &pThis->pTimerPollR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pTimerPollR0 = TMTimerR0Ptr(pData->pTimerPollR3);
-    pData->pTimerPollRC = TMTimerRCPtr(pData->pTimerPollR3);
-#endif
-    if (pData->fAm79C973)
+    pThis->pTimerPollR0 = TMTimerR0Ptr(pThis->pTimerPollR3);
+    pThis->pTimerPollRC = TMTimerRCPtr(pThis->pTimerPollR3);
+#endif
+    if (pThis->fAm79C973)
     {
         /* Software Interrupt timer */
         rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimerSoftInt,
-                                    "PCNet SoftInt Timer", &pData->pTimerSoftIntR3);
+                                    "PCNet SoftInt Timer", &pThis->pTimerSoftIntR3);
         if (RT_FAILURE(rc))
             return rc;
-        pData->pTimerSoftIntR0 = TMTimerR0Ptr(pData->pTimerSoftIntR3);
-        pData->pTimerSoftIntRC = TMTimerRCPtr(pData->pTimerSoftIntR3);
+        pThis->pTimerSoftIntR0 = TMTimerR0Ptr(pThis->pTimerSoftIntR3);
+        pThis->pTimerSoftIntRC = TMTimerRCPtr(pThis->pTimerSoftIntR3);
     }
     rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, pcnetTimerRestore,
-                                "PCNet Restore Timer", &pData->pTimerRestore);
+                                "PCNet Restore Timer", &pThis->pTimerRestore);
     if (RT_FAILURE(rc))
         return rc;
 
     rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance,
-                              PCNET_SAVEDSTATE_VERSION, sizeof(*pData),
+                              PCNET_SAVEDSTATE_VERSION, sizeof(*pThis),
                               pcnetSavePrep, pcnetSaveExec, NULL,
                               pcnetLoadPrep, pcnetLoadExec, NULL);
@@ -4822 +4822 @@
     char szName[24];
     RTStrPrintf(szName, sizeof(szName), "PCNet#%d", iInstance);
-    rc = PDMDevHlpCritSectInit(pDevIns, &pData->CritSect, szName);
+    rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, szName);
     if (RT_FAILURE(rc))
         return rc;
 
-    rc = RTSemEventCreate(&pData->hEventOutOfRxSpace);
+    rc = RTSemEventCreate(&pThis->hEventOutOfRxSpace);
     AssertRC(rc);
 
@@ -4833 +4833 @@
      */
     rc = PDMDevHlpPDMQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
-                                 pcnetXmitQueueConsumer, true, &pData->pXmitQueueR3);
+                                 pcnetXmitQueueConsumer, true, &pThis->pXmitQueueR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pXmitQueueR0 = PDMQueueR0Ptr(pData->pXmitQueueR3);
-    pData->pXmitQueueRC = PDMQueueRCPtr(pData->pXmitQueueR3);
+    pThis->pXmitQueueR0 = PDMQueueR0Ptr(pThis->pXmitQueueR3);
+    pThis->pXmitQueueRC = PDMQueueRCPtr(pThis->pXmitQueueR3);
 
     /*
@@ -4843 +4843 @@
      */
     rc = PDMDevHlpPDMQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
-                                 pcnetCanRxQueueConsumer, true, &pData->pCanRxQueueR3);
+                                 pcnetCanRxQueueConsumer, true, &pThis->pCanRxQueueR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pCanRxQueueR0 = PDMQueueR0Ptr(pData->pCanRxQueueR3);
-    pData->pCanRxQueueRC = PDMQueueRCPtr(pData->pCanRxQueueR3);
+    pThis->pCanRxQueueR0 = PDMQueueR0Ptr(pThis->pCanRxQueueR3);
+    pThis->pCanRxQueueRC = PDMQueueRCPtr(pThis->pCanRxQueueR3);
 
     /*
@@ -4858 +4858 @@
      * 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 = (PPDMILEDCONNECTORS)
+        pThis->pLedsConnector = (PPDMILEDCONNECTORS)
             pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
     else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
@@ -4871 +4871 @@
      * Attach driver.
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pData->IBase, &pData->pDrvBase, "Network Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Network Port");
     if (RT_SUCCESS(rc))
     {
@@ -4884 +4884 @@
 #endif
         }
-        pData->pDrv = (PPDMINETWORKCONNECTOR)
-            pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_NETWORK_CONNECTOR);
-        if (!pData->pDrv)
+        pThis->pDrv = (PPDMINETWORKCONNECTOR)
+            pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_NETWORK_CONNECTOR);
+        if (!pThis->pDrv)
         {
             AssertMsgFailed(("Failed to obtain the PDMINTERFACE_NETWORK_CONNECTOR interface!\n"));
@@ -4900 +4900 @@
      * Reset the device state. (Do after attaching.)
      */
-    pcnetHardReset(pData);
+    pcnetHardReset(pThis);
 
     /* Create send queue for the async send thread. */
-    rc = RTSemEventCreate(&pData->hSendEventSem);
+    rc = RTSemEventCreate(&pThis->hSendEventSem);
     AssertRC(rc);
 
     /* Create asynchronous thread */
-    rc = PDMDevHlpPDMThreadCreate(pDevIns, &pData->pSendThread, pData, pcnetAsyncSendThread, pcnetAsyncSendThreadWakeUp, 0, RTTHREADTYPE_IO, "PCNET_TX");
+    rc = PDMDevHlpPDMThreadCreate(pDevIns, &pThis->pSendThread, pThis, pcnetAsyncSendThread, pcnetAsyncSendThreadWakeUp, 0, RTTHREADTYPE_IO, "PCNET_TX");
     AssertRCReturn(rc, rc);
 
 #ifdef PCNET_QUEUE_SEND_PACKETS
-    pData->apXmitRingBuffer[0] = (uint8_t *)RTMemAlloc(PCNET_MAX_XMIT_SLOTS * MAX_FRAME);
+    pThis->apXmitRingBuffer[0] = (uint8_t *)RTMemAlloc(PCNET_MAX_XMIT_SLOTS * MAX_FRAME);
     for (unsigned i = 1; i < PCNET_MAX_XMIT_SLOTS; i++)
-        pData->apXmitRingBuffer[i] = pData->apXmitRingBuffer[0] + i*MAX_FRAME;
+        pThis->apXmitRingBuffer[i] = pThis->apXmitRingBuffer[0] + i*MAX_FRAME;
 #endif
 
 #ifdef VBOX_WITH_STATISTICS
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatMMIOReadGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO reads in GC",         "/Devices/PCNet%d/MMIO/ReadGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatMMIOReadHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO reads in HC",         "/Devices/PCNet%d/MMIO/ReadHC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatMMIOWriteGC,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO writes in GC",        "/Devices/PCNet%d/MMIO/WriteGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatMMIOWriteHC,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO writes in HC",        "/Devices/PCNet%d/MMIO/WriteHC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatAPROMRead,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling APROM reads",              "/Devices/PCNet%d/IO/APROMRead", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatAPROMWrite,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling APROM writes",             "/Devices/PCNet%d/IO/APROMWrite", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatIOReadGC,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in GC",           "/Devices/PCNet%d/IO/ReadGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatIOReadHC,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in HC",           "/Devices/PCNet%d/IO/ReadHC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatIOWriteGC,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in GC",          "/Devices/PCNet%d/IO/WriteGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatIOWriteHC,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in HC",          "/Devices/PCNet%d/IO/WriteHC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTimer,              STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling Timer",                    "/Devices/PCNet%d/Timer", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatReceive,            STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive",                  "/Devices/PCNet%d/Receive", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRxOverflow,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows",        "/Devices/PCNet%d/RxOverflow", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRxOverflowWakeup,   STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Nr of RX overflow wakeups",     "/Devices/PCNet%d/RxOverflowWakeup", iInstance);
-#endif
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatReceiveBytes,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data received",            "/Devices/PCNet%d/ReceiveBytes", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMMIOReadGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO reads in GC",         "/Devices/PCNet%d/MMIO/ReadGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMMIOReadHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO reads in HC",         "/Devices/PCNet%d/MMIO/ReadHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMMIOWriteGC,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO writes in GC",        "/Devices/PCNet%d/MMIO/WriteGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMMIOWriteHC,        STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling MMIO writes in HC",        "/Devices/PCNet%d/MMIO/WriteHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatAPROMRead,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling APROM reads",              "/Devices/PCNet%d/IO/APROMRead", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatAPROMWrite,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling APROM writes",             "/Devices/PCNet%d/IO/APROMWrite", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOReadGC,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in GC",           "/Devices/PCNet%d/IO/ReadGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOReadHC,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in HC",           "/Devices/PCNet%d/IO/ReadHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOWriteGC,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in GC",          "/Devices/PCNet%d/IO/WriteGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatIOWriteHC,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in HC",          "/Devices/PCNet%d/IO/WriteHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTimer,              STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling Timer",                    "/Devices/PCNet%d/Timer", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceive,            STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive",                  "/Devices/PCNet%d/Receive", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflow,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows",        "/Devices/PCNet%d/RxOverflow", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflowWakeup,   STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Nr of RX overflow wakeups",     "/Devices/PCNet%d/RxOverflowWakeup", iInstance);
+#endif
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveBytes,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data received",            "/Devices/PCNet%d/ReceiveBytes", iInstance);
 #ifdef VBOX_WITH_STATISTICS
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTransmit,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in HC",          "/Devices/PCNet%d/Transmit/Total", iInstance);
-#endif
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTransmitBytes,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data transmitted",         "/Devices/PCNet%d/TransmitBytes", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmit,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in HC",          "/Devices/PCNet%d/Transmit/Total", iInstance);
+#endif
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitBytes,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data transmitted",         "/Devices/PCNet%d/TransmitBytes", iInstance);
 #ifdef VBOX_WITH_STATISTICS
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTransmitSend,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet send transmit in HC","/Devices/PCNet%d/Transmit/Send", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTdtePollGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TdtePoll in GC",     "/Devices/PCNet%d/TdtePollGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTdtePollHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TdtePoll in HC",     "/Devices/PCNet%d/TdtePollHC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRdtePollGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet RdtePoll in GC",     "/Devices/PCNet%d/RdtePollGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRdtePollHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet RdtePoll in HC",     "/Devices/PCNet%d/RdtePollHC", iInstance);
-
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTmdStoreGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TmdStore in GC",     "/Devices/PCNet%d/TmdStoreGC", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTmdStoreHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TmdStore in HC",     "/Devices/PCNet%d/TmdStoreHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitSend,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet send transmit in HC","/Devices/PCNet%d/Transmit/Send", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTdtePollGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TdtePoll in GC",     "/Devices/PCNet%d/TdtePollGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTdtePollHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TdtePoll in HC",     "/Devices/PCNet%d/TdtePollHC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRdtePollGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet RdtePoll in GC",     "/Devices/PCNet%d/RdtePollGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRdtePollHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet RdtePoll in HC",     "/Devices/PCNet%d/RdtePollHC", iInstance);
+
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTmdStoreGC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TmdStore in GC",     "/Devices/PCNet%d/TmdStoreGC", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTmdStoreHC,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling PCNet TmdStore in HC",     "/Devices/PCNet%d/TmdStoreHC", iInstance);
 
     unsigned i;
-    for (i = 0; i < RT_ELEMENTS(pData->aStatXmitFlush) - 1; i++)
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitFlush[i],  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d", iInstance, i + 1);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitFlush[i],      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d+", iInstance, i + 1);
-
-    for (i = 0; i < RT_ELEMENTS(pData->aStatXmitChainCounts) - 1; i++)
-        PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,  "",                                   "/Devices/PCNet%d/XmitChainCounts/%d", iInstance, i + 1);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,      "",                                   "/Devices/PCNet%d/XmitChainCounts/%d+", iInstance, i + 1);
-
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatXmitSkipCurrent,    STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "",                                   "/Devices/PCNet%d/Xmit/Skipped", iInstance, i + 1);
-
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatInterrupt,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling interrupt checks",         "/Devices/PCNet%d/UpdateIRQ", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatPollTimer,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling poll timer",               "/Devices/PCNet%d/PollTimer", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatMIIReads,           STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of MII reads",                "/Devices/PCNet%d/MIIReads", iInstance);
+    for (i = 0; i < RT_ELEMENTS(pThis->aStatXmitFlush) - 1; i++)
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStatXmitFlush[i],  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d", iInstance, i + 1);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStatXmitFlush[i],      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,       "",                                   "/Devices/PCNet%d/XmitFlushIrq/%d+", iInstance, i + 1);
+
+    for (i = 0; i < RT_ELEMENTS(pThis->aStatXmitChainCounts) - 1; i++)
+        PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,  "",                                   "/Devices/PCNet%d/XmitChainCounts/%d", iInstance, i + 1);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->aStatXmitChainCounts[i], STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES,      "",                                   "/Devices/PCNet%d/XmitChainCounts/%d+", iInstance, i + 1);
+
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatXmitSkipCurrent,    STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "",                                   "/Devices/PCNet%d/Xmit/Skipped", iInstance, i + 1);
+
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatInterrupt,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling interrupt checks",         "/Devices/PCNet%d/UpdateIRQ", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatPollTimer,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling poll timer",               "/Devices/PCNet%d/PollTimer", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMIIReads,           STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of MII reads",                "/Devices/PCNet%d/MIIReads", iInstance);
 # ifdef PCNET_NO_POLLING
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRCVRingWrite,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of receive ring writes",          "/Devices/PCNet%d/Ring/RCVWrites", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatTXRingWrite,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of transmit ring writes",         "/Devices/PCNet%d/Ring/TXWrites", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteHC,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/HC/Writes", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteR0,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/R0/Writes", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteGC,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/GC/Writes", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteFailedHC,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/HC/Failed", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteFailedR0,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/R0/Failed", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteFailedGC,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/GC/Failed", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteOutsideHC, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/HC/Outside", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteOutsideR0, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/R0/Outside", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pData->StatRingWriteOutsideGC, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/GC/Outside", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRCVRingWrite,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of receive ring writes",          "/Devices/PCNet%d/Ring/RCVWrites", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTXRingWrite,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of transmit ring writes",         "/Devices/PCNet%d/Ring/TXWrites", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteHC,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/HC/Writes", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteR0,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/R0/Writes", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteGC,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored ring page writes",   "/Devices/PCNet%d/Ring/GC/Writes", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteFailedHC,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/HC/Failed", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteFailedR0,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/R0/Failed", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteFailedGC,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of failed ring page writes",      "/Devices/PCNet%d/Ring/GC/Failed", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteOutsideHC, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/HC/Outside", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteOutsideR0, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/R0/Outside", iInstance);
+    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRingWriteOutsideGC, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of monitored writes outside ring","/Devices/PCNet%d/Ring/GC/Outside", iInstance);
 # endif /* PCNET_NO_POLLING */
 #endif

trunk/src/VBox/Devices/Network/DrvNAT.cpp

@@ -112 +112 @@
 static DECLCALLBACK(void) drvNATOutput(const void * data, const uint8_t *msg, size_t size)
 {
-        PDRVNAT pData = (PDRVNAT)(void *)data;
+        PDRVNAT pThis = (PDRVNAT)(void *)data;
         LogFlow(("output: pvBuf=%p cb=%#x\n", msg, size));
-        int rc =  pData->pPort->pfnWaitReceiveAvail(pData->pPort, 0);
+        int rc =  pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, 0);
         if (RT_SUCCESS(rc))
-                pData->pPort->pfnReceive(pData->pPort, msg, size);
+                pThis->pPort->pfnReceive(pThis->pPort, msg, size);
         LogFlow(("output: exit\n"));
 }
@@ -133 +133 @@
 static DECLCALLBACK(int) drvNATSend(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
 {
-    PDRVNAT pData = PDMINETWORKCONNECTOR_2_DRVNAT(pInterface);
+    PDRVNAT pThis = PDMINETWORKCONNECTOR_2_DRVNAT(pInterface);
 
     LogFlow(("drvNATSend: pvBuf=%p cb=%#x\n", pvBuf, cb));
@@ -140 +140 @@
           pvBuf, cb, cb, pvBuf));
 
-    int rc = RTCritSectEnter(&pData->CritSect);
+    int rc = RTCritSectEnter(&pThis->CritSect);
     AssertReleaseRC(rc);
 
-    Assert(pData->enmLinkState == PDMNETWORKLINKSTATE_UP);
-    if (pData->enmLinkState == PDMNETWORKLINKSTATE_UP) {
-#ifndef VBOX_NAT_SOURCES
-        slirp_input(pData->pNATState, (uint8_t *)pvBuf, cb);
+    Assert(pThis->enmLinkState == PDMNETWORKLINKSTATE_UP);
+    if (pThis->enmLinkState == PDMNETWORKLINKSTATE_UP) {
+#ifndef VBOX_NAT_SOURCES
+        slirp_input(pThis->pNATState, (uint8_t *)pvBuf, cb);
 #else
-                ether_chk(pData, pvBuf, cb);
+                ether_chk(pThis, pvBuf, cb);
 #endif
         }
-    RTCritSectLeave(&pData->CritSect);
+    RTCritSectLeave(&pThis->CritSect);
     LogFlow(("drvNATSend: end\n"));
     return VINF_SUCCESS;
@@ -183 +183 @@
 static DECLCALLBACK(void) drvNATNotifyLinkChanged(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState)
 {
-    PDRVNAT pData = PDMINETWORKCONNECTOR_2_DRVNAT(pInterface);
+    PDRVNAT pThis = PDMINETWORKCONNECTOR_2_DRVNAT(pInterface);
 
     LogFlow(("drvNATNotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
 
-    int rc = RTCritSectEnter(&pData->CritSect);
+    int rc = RTCritSectEnter(&pThis->CritSect);
     AssertReleaseRC(rc);
-    pData->enmLinkState = enmLinkState;
+    pThis->enmLinkState = enmLinkState;
 
     switch (enmLinkState)
@@ -196 +196 @@
             LogRel(("NAT: link up\n"));
 #ifndef VBOX_NAT_SOURCES
-            slirp_link_up(pData->pNATState);
+            slirp_link_up(pThis->pNATState);
 #endif
             break;
@@ -204 +204 @@
             LogRel(("NAT: link down\n"));
 #ifndef VBOX_NAT_SOURCES
-            slirp_link_down(pData->pNATState);
+            slirp_link_down(pThis->pNATState);
 #endif
             break;
@@ -211 +211 @@
             AssertMsgFailed(("drvNATNotifyLinkChanged: unexpected link state %d\n", enmLinkState));
     }
-    RTCritSectLeave(&pData->CritSect);
+    RTCritSectLeave(&pThis->CritSect);
 }
 
@@ -220 +220 @@
 static DECLCALLBACK(void) drvNATPoller(PPDMDRVINS pDrvIns)
 {
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
     fd_set  ReadFDs;
     fd_set  WriteFDs;
@@ -229 +229 @@
     FD_ZERO(&XcptFDs);
 
-    int rc = RTCritSectEnter(&pData->CritSect);
+    int rc = RTCritSectEnter(&pThis->CritSect);
     AssertReleaseRC(rc);
 
 #ifndef VBOX_NAT_SOURCES
-    slirp_select_fill(pData->pNATState, &cFDs, &ReadFDs, &WriteFDs, &XcptFDs);
+    slirp_select_fill(pThis->pNATState, &cFDs, &ReadFDs, &WriteFDs, &XcptFDs);
 #else
         nat_select_fill(NULL, &cFDs, &ReadFDs, &WriteFDs, &XcptFDs);
@@ -242 +242 @@
 #ifndef VBOX_NAT_SOURCES
     if (cReadFDs >= 0)
-        slirp_select_poll(pData->pNATState, &ReadFDs, &WriteFDs, &XcptFDs);
+        slirp_select_poll(pThis->pNATState, &ReadFDs, &WriteFDs, &XcptFDs);
 #else
     if (cReadFDs >= 0) {
-                nat_select_poll(pData, &ReadFDs, &WriteFDs, &XcptFDs);
+                nat_select_poll(pThis, &ReadFDs, &WriteFDs, &XcptFDs);
         }
 #endif
 
-    RTCritSectLeave(&pData->CritSect);
+    RTCritSectLeave(&pThis->CritSect);
 }
 
@@ -260 +260 @@
 int slirp_can_output(void *pvUser)
 {
-    PDRVNAT pData = (PDRVNAT)pvUser;
-
-    Assert(pData);
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+
+    Assert(pThis);
 
     /** Happens during termination */
-    if (!RTCritSectIsOwner(&pData->CritSect))
+    if (!RTCritSectIsOwner(&pThis->CritSect))
         return 0;
 
-    int rc =  pData->pPort->pfnWaitReceiveAvail(pData->pPort, 0);
+    int rc =  pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, 0);
     return RT_SUCCESS(rc);
 }
@@ -278 +278 @@
 void slirp_output(void *pvUser, const uint8_t *pu8Buf, int cb)
 {
-    PDRVNAT pData = (PDRVNAT)pvUser;
+    PDRVNAT pThis = (PDRVNAT)pvUser;
 
     LogFlow(("slirp_output BEGIN %x %d\n", pu8Buf, cb));
-    Log2(("slirp_output: pu8Buf=%p cb=%#x (pData=%p)\n"
+    Log2(("slirp_output: pu8Buf=%p cb=%#x (pThis=%p)\n"
           "%.*Vhxd\n",
-          pu8Buf, cb, pData,
+          pu8Buf, cb, pThis,
           cb, pu8Buf));
 
-    Assert(pData);
+    Assert(pThis);
 
     /** Happens during termination */
-    if (!RTCritSectIsOwner(&pData->CritSect))
+    if (!RTCritSectIsOwner(&pThis->CritSect))
         return;
 
-    int rc = pData->pPort->pfnReceive(pData->pPort, pu8Buf, cb);
+    int rc = pThis->pPort->pfnReceive(pThis->pPort, pu8Buf, cb);
     AssertRC(rc);
     LogFlow(("slirp_output END %x %d\n", pu8Buf, cb));
@@ -310 +310 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
     switch (enmInterface)
     {
@@ -316 +316 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_NETWORK_CONNECTOR:
-            return &pData->INetworkConnector;
+            return &pThis->INetworkConnector;
         default:
             return NULL;
@@ -333 +333 @@
 static DECLCALLBACK(void) drvNATDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
 
     LogFlow(("drvNATDestruct:\n"));
 
-    int rc = RTCritSectEnter(&pData->CritSect);
+    int rc = RTCritSectEnter(&pThis->CritSect);
     AssertReleaseRC(rc);
 #ifndef VBOX_NAT_SOURCES
-    slirp_term(pData->pNATState);
-    pData->pNATState = NULL;
-#endif
-    RTCritSectLeave(&pData->CritSect);
-
-    RTCritSectDelete(&pData->CritSect);
+    slirp_term(pThis->pNATState);
+    pThis->pNATState = NULL;
+#endif
+    RTCritSectLeave(&pThis->CritSect);
+
+    RTCritSectDelete(&pThis->CritSect);
 }
 
@@ -355 +355 @@
  * @param   pCfgHandle      The drivers configuration handle.
  */
-static int drvNATConstructRedir(unsigned iInstance, PDRVNAT pData, PCFGMNODE pCfgHandle, RTIPV4ADDR Network)
+static int drvNATConstructRedir(unsigned iInstance, PDRVNAT pThis, PCFGMNODE pCfgHandle, RTIPV4ADDR Network)
 {
 #ifndef VBOX_NAT_SOURCES
@@ -367 +367 @@
          */
         if (!CFGMR3AreValuesValid(pNode, "Protocol\0UDP\0HostPort\0GuestPort\0GuestIP\0"))
-            return PDMDRV_SET_ERROR(pData->pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, N_("Unknown configuration in port forwarding"));
+            return PDMDRV_SET_ERROR(pThis->pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, N_("Unknown configuration in port forwarding"));
 
         /* protocol type */
@@ -379 +379 @@
                 fUDP = false;
             else if (RT_FAILURE(rc))
-                return PDMDrvHlpVMSetError(pData->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"UDP\" boolean failed"), iInstance);
+                return PDMDrvHlpVMSetError(pThis->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"UDP\" boolean failed"), iInstance);
         }
         else if (RT_SUCCESS(rc))
@@ -388 +388 @@
                 fUDP = true;
             else
-                return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("NAT#%d: Invalid configuration value for \"Protocol\": \"%s\""), iInstance, szProtocol);
+                return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("NAT#%d: Invalid configuration value for \"Protocol\": \"%s\""), iInstance, szProtocol);
         }
         else
-            return PDMDrvHlpVMSetError(pData->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"Protocol\" string failed"), iInstance);
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"Protocol\" string failed"), iInstance);
 
         /* host port */
@@ -397 +397 @@
         rc = CFGMR3QueryS32(pNode, "HostPort", &iHostPort);
         if (RT_FAILURE(rc))
-            return PDMDrvHlpVMSetError(pData->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"HostPort\" integer failed"), iInstance);
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"HostPort\" integer failed"), iInstance);
 
         /* guest port */
@@ -403 +403 @@
         rc = CFGMR3QueryS32(pNode, "GuestPort", &iGuestPort);
         if (RT_FAILURE(rc))
-            return PDMDrvHlpVMSetError(pData->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"GuestPort\" integer failed"), iInstance);
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"GuestPort\" integer failed"), iInstance);
 
         /* guest address */
@@ -412 +412 @@
                         (Network & 0xFF000000) >> 24, (Network & 0xFF0000) >> 16, (Network & 0xFF00) >> 8, (Network & 0xE0) | 15);
         else if (RT_FAILURE(rc))
-            return PDMDrvHlpVMSetError(pData->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"GuestIP\" string failed"), iInstance);
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"GuestIP\" string failed"), iInstance);
         struct in_addr GuestIP;
         if (!inet_aton(szGuestIP, &GuestIP))
-            return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_NAT_REDIR_GUEST_IP, RT_SRC_POS, N_("NAT#%d: configuration error: invalid \"GuestIP\"=\"%s\", inet_aton failed"), iInstance, szGuestIP);
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_NAT_REDIR_GUEST_IP, RT_SRC_POS, N_("NAT#%d: configuration error: invalid \"GuestIP\"=\"%s\", inet_aton failed"), iInstance, szGuestIP);
 
         /*
@@ -421 +421 @@
          */
         Log(("drvNATConstruct: Redir %d -> %s:%d\n", iHostPort, szGuestIP, iGuestPort));
-        if (slirp_redir(pData->pNATState, fUDP, iHostPort, GuestIP, iGuestPort) < 0)
-            return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_NAT_REDIR_SETUP, RT_SRC_POS, N_("NAT#%d: configuration error: failed to set up redirection of %d to %s:%d. Probably a conflict with existing services or other rules"), iInstance, iHostPort, szGuestIP, iGuestPort);
+        if (slirp_redir(pThis->pNATState, fUDP, iHostPort, GuestIP, iGuestPort) < 0)
+            return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_NAT_REDIR_SETUP, RT_SRC_POS, N_("NAT#%d: configuration error: failed to set up redirection of %d to %s:%d. Probably a conflict with existing services or other rules"), iInstance, iHostPort, szGuestIP, iGuestPort);
     } /* for each redir rule */
 #endif
@@ -432 +432 @@
  * Get the MAC address into the slirp stack.
  */
-static void drvNATSetMac(PDRVNAT pData)
-{
-#ifndef VBOX_NAT_SOURCES
-    if (pData->pConfig)
+static void drvNATSetMac(PDRVNAT pThis)
+{
+#ifndef VBOX_NAT_SOURCES
+    if (pThis->pConfig)
     {
         RTMAC Mac;
-        pData->pConfig->pfnGetMac(pData->pConfig, &Mac);
-        slirp_set_ethaddr(pData->pNATState, Mac.au8);
+        pThis->pConfig->pfnGetMac(pThis->pConfig, &Mac);
+        slirp_set_ethaddr(pThis->pNATState, Mac.au8);
     }
 #endif
@@ -452 +452 @@
 static DECLCALLBACK(int) drvNATLoadDone(PPDMDRVINS pDrvIns, PSSMHANDLE pSSMHandle)
 {
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
-    drvNATSetMac(pData);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    drvNATSetMac(pThis);
     return VINF_SUCCESS;
 }
@@ -463 +463 @@
 static DECLCALLBACK(void) drvNATPowerOn(PPDMDRVINS pDrvIns)
 {
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
-    drvNATSetMac(pData);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    drvNATSetMac(pThis);
 }
 
@@ -480 +480 @@
 static DECLCALLBACK(int) drvNATConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVNAT pData = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
     char szNetAddr[16];
     char szNetwork[32]; /* xxx.xxx.xxx.xxx/yy */
@@ -494 +494 @@
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-#ifndef VBOX_NAT_SOURCES
-    pData->pNATState                    = NULL;
-#endif
-    pData->pszTFTPPrefix                = NULL;
-    pData->pszBootFile                  = NULL;
+    pThis->pDrvIns                      = pDrvIns;
+#ifndef VBOX_NAT_SOURCES
+    pThis->pNATState                    = NULL;
+#endif
+    pThis->pszTFTPPrefix                = NULL;
+    pThis->pszBootFile                  = NULL;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvNATQueryInterface;
     /* INetwork */
-    pData->INetworkConnector.pfnSend               = drvNATSend;
-    pData->INetworkConnector.pfnSetPromiscuousMode = drvNATSetPromiscuousMode;
-    pData->INetworkConnector.pfnNotifyLinkChanged  = drvNATNotifyLinkChanged;
+    pThis->INetworkConnector.pfnSend               = drvNATSend;
+    pThis->INetworkConnector.pfnSetPromiscuousMode = drvNATSetPromiscuousMode;
+    pThis->INetworkConnector.pfnNotifyLinkChanged  = drvNATNotifyLinkChanged;
 
     /*
@@ -517 +517 @@
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"PassDomain\" boolean failed"), pDrvIns->iInstance);
 
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TFTPPrefix", &pData->pszTFTPPrefix);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TFTPPrefix", &pThis->pszTFTPPrefix);
     if (RT_FAILURE(rc) && rc != VERR_CFGM_VALUE_NOT_FOUND)
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"TFTPPrefix\" string failed"), pDrvIns->iInstance);
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "BootFile", &pData->pszBootFile);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "BootFile", &pThis->pszBootFile);
     if (RT_FAILURE(rc) && rc != VERR_CFGM_VALUE_NOT_FOUND)
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NAT#%d: configuration query for \"BootFile\" string failed"), pDrvIns->iInstance);
@@ -527 +527 @@
      * Query the network port interface.
      */
-    pData->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
-    if (!pData->pPort)
+    pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
+    if (!pThis->pPort)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
                                 N_("Configuration error: the above device/driver didn't export the network port interface"));
-    pData->pConfig = (PPDMINETWORKCONFIG)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_CONFIG);
-    if (!pData->pConfig)
+    pThis->pConfig = (PPDMINETWORKCONFIG)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_CONFIG);
+    if (!pThis->pConfig)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
                                 N_("Configuration error: the above device/driver didn't export the network config interface"));
@@ -555 +555 @@
      * The slirp lock..
      */
-    rc = RTCritSectInit(&pData->CritSect);
+    rc = RTCritSectInit(&pThis->CritSect);
     if (RT_FAILURE(rc))
         return rc;
@@ -574 +574 @@
              * Initialize slirp.
              */
-            rc = slirp_init(&pData->pNATState, &szNetAddr[0], Netmask, fPassDomain, pData->pszTFTPPrefix, pData->pszBootFile, pData);
+            rc = slirp_init(&pThis->pNATState, &szNetAddr[0], Netmask, fPassDomain, pThis->pszTFTPPrefix, pThis->pszBootFile, pThis);
             if (RT_SUCCESS(rc))
             {
-                int rc2 = drvNATConstructRedir(pDrvIns->iInstance, pData, pCfgHandle, Network);
+                int rc2 = drvNATConstructRedir(pDrvIns->iInstance, pThis, pCfgHandle, Network);
                 if (RT_SUCCESS(rc2))
                 {
@@ -590 +590 @@
                     pDrvIns->pDrvHlp->pfnPDMPollerRegister(pDrvIns, drvNATPoller);
 
-                    pData->enmLinkState = PDMNETWORKLINKSTATE_UP;
+                    pThis->enmLinkState = PDMNETWORKLINKSTATE_UP;
 #if 0
                     RTSemEventSignal(g_EventSem);
@@ -600 +600 @@
                 /* failure path */
                 rc = rc2;
-                slirp_term(pData->pNATState);
-                pData->pNATState = NULL;
+                slirp_term(pThis->pNATState);
+                pThis->pNATState = NULL;
             }
             else
@@ -610 +610 @@
 #else
         pDrvIns->pDrvHlp->pfnPDMPollerRegister(pDrvIns, drvNATPoller);
-        pData->enmLinkState = PDMNETWORKLINKSTATE_UP;
+        pThis->enmLinkState = PDMNETWORKLINKSTATE_UP;
         mbuf_init(NULL);
         struct nat_output_callbacks cb;
@@ -631 +631 @@
 #endif
 #ifndef VBOX_NAT_SOURCES
-    RTCritSectDelete(&pData->CritSect);
+    RTCritSectDelete(&pThis->CritSect);
 #endif
     return rc;

trunk/src/VBox/Devices/Network/DrvTAP.cpp

@@ -151 +151 @@
 #ifdef RT_OS_SOLARIS
 # ifdef VBOX_WITH_CROSSBOW
-static int              SolarisOpenVNIC(PDRVTAP pData);
+static int              SolarisOpenVNIC(PDRVTAP pThis);
 static int              SolarisDLPIErr2VBoxErr(int rc);
 # else
-static int              SolarisTAPAttach(PDRVTAP pData);
+static int              SolarisTAPAttach(PDRVTAP pThis);
 # endif
 #endif
@@ -170 +170 @@
 static DECLCALLBACK(int) drvTAPSend(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
 {
-    PDRVTAP pData = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
-    STAM_COUNTER_INC(&pData->StatPktSent);
-    STAM_COUNTER_ADD(&pData->StatPktSentBytes, cb);
-    STAM_PROFILE_START(&pData->StatTransmit, a);
+    PDRVTAP pThis = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
+    STAM_COUNTER_INC(&pThis->StatPktSent);
+    STAM_COUNTER_ADD(&pThis->StatPktSentBytes, cb);
+    STAM_PROFILE_START(&pThis->StatTransmit, a);
 
 #ifdef LOG_ENABLED
     uint64_t u64Now = RTTimeProgramNanoTS();
     LogFlow(("drvTAPSend: %-4d bytes at %llu ns  deltas: r=%llu t=%llu\n",
-             cb, u64Now, u64Now - pData->u64LastReceiveTS, u64Now - pData->u64LastTransferTS));
-    pData->u64LastTransferTS = u64Now;
+             cb, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
+    pThis->u64LastTransferTS = u64Now;
 #endif
     Log2(("drvTAPSend: pvBuf=%p cb=%#x\n"
@@ -185 +185 @@
           pvBuf, cb, cb, pvBuf));
 
-    int rc = RTFileWrite(pData->FileDevice, pvBuf, cb, NULL);
-
-    STAM_PROFILE_STOP(&pData->StatTransmit, a);
+    int rc = RTFileWrite(pThis->FileDevice, pvBuf, cb, NULL);
+
+    STAM_PROFILE_STOP(&pThis->StatTransmit, a);
     AssertRC(rc);
     return rc;
@@ -233 +233 @@
 static DECLCALLBACK(int) drvTAPAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
-    LogFlow(("drvTAPAsyncIoThread: pData=%p\n", pData));
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    LogFlow(("drvTAPAsyncIoThread: pThis=%p\n", pThis));
 
     if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
         return VINF_SUCCESS;
 
-    STAM_PROFILE_ADV_START(&pData->StatReceive, a);
+    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
 
     /*
@@ -250 +250 @@
          */
         struct pollfd aFDs[2];
-        aFDs[0].fd      = pData->FileDevice;
+        aFDs[0].fd      = pThis->FileDevice;
         aFDs[0].events  = POLLIN | POLLPRI;
         aFDs[0].revents = 0;
-        aFDs[1].fd      = pData->PipeRead;
+        aFDs[1].fd      = pThis->PipeRead;
         aFDs[1].events  = POLLIN | POLLPRI | POLLERR | POLLHUP;
         aFDs[1].revents = 0;
-        STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
+        STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
         errno=0;
         int rc = poll(&aFDs[0], RT_ELEMENTS(aFDs), -1 /* infinite */);
@@ -264 +264 @@
             break;
 
-        STAM_PROFILE_ADV_START(&pData->StatReceive, a);
+        STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
         if (    rc > 0
             &&  (aFDs[0].revents & (POLLIN | POLLPRI))
@@ -276 +276 @@
 #ifdef VBOX_WITH_CROSSBOW
             cbRead = sizeof(achBuf);
-            rc = g_pfnLibDlpiRecv(pData->pDeviceHandle, NULL, NULL, achBuf, &cbRead, -1, NULL);
+            rc = g_pfnLibDlpiRecv(pThis->pDeviceHandle, NULL, NULL, achBuf, &cbRead, -1, NULL);
             rc = RT_LIKELY(rc == DLPI_SUCCESS) ? VINF_SUCCESS : SolarisDLPIErr2VBoxErr(rc);
 #else
@@ -282 +282 @@
              *        after poll() returned successfully. I don't know why but a second
              *        RTFileRead() operation will return with VERR_TRY_AGAIN in any case. */
-            rc = RTFileRead(pData->FileDevice, achBuf, sizeof(achBuf), &cbRead);
+            rc = RTFileRead(pThis->FileDevice, achBuf, sizeof(achBuf), &cbRead);
 #endif
             if (RT_SUCCESS(rc))
@@ -299 +299 @@
                  *    overflow error to allocate more receive buffers
                  */
-                STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
-                int rc = pData->pPort->pfnWaitReceiveAvail(pData->pPort, RT_INDEFINITE_WAIT);
-                STAM_PROFILE_ADV_START(&pData->StatReceive, a);
+                STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
+                int rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
+                STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
 
                 /*
@@ -316 +316 @@
                 uint64_t u64Now = RTTimeProgramNanoTS();
                 LogFlow(("drvTAPAsyncIoThread: %-4d bytes at %llu ns  deltas: r=%llu t=%llu\n",
-                         cbRead, u64Now, u64Now - pData->u64LastReceiveTS, u64Now - pData->u64LastTransferTS));
-                pData->u64LastReceiveTS = u64Now;
+                         cbRead, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
+                pThis->u64LastReceiveTS = u64Now;
 #endif
                 Log2(("drvTAPAsyncIoThread: cbRead=%#x\n" "%.*Vhxd\n", cbRead, cbRead, achBuf));
-                STAM_COUNTER_INC(&pData->StatPktRecv);
-                STAM_COUNTER_ADD(&pData->StatPktRecvBytes, cbRead);
-                rc = pData->pPort->pfnReceive(pData->pPort, achBuf, cbRead);
+                STAM_COUNTER_INC(&pThis->StatPktRecv);
+                STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, cbRead);
+                rc = pThis->pPort->pfnReceive(pThis->pPort, achBuf, cbRead);
                 AssertRC(rc);
             }
@@ -343 +343 @@
             char ch;
             size_t cbRead;
-            RTFileRead(pData->PipeRead, &ch, 1, &cbRead);
+            RTFileRead(pThis->PipeRead, &ch, 1, &cbRead);
         }
         else
@@ -363 +363 @@
 
     LogFlow(("drvTAPAsyncIoThread: returns %Vrc\n", VINF_SUCCESS));
-    STAM_PROFILE_ADV_STOP(&pData->StatReceive, a);
+    STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
     return VINF_SUCCESS;
 }
@@ -377 +377 @@
 static DECLCALLBACK(int) drvTapAsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
-
-    int rc = RTFileWrite(pData->PipeWrite, "", 1, NULL);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+
+    int rc = RTFileWrite(pThis->PipeWrite, "", 1, NULL);
     AssertRC(rc);
 
@@ -391 +391 @@
  *
  * @returns VBox error code.
- * @param   pData           The instance data.
- */
-static int drvTAPSetupApplication(PDRVTAP pData)
+ * @param   pThis           The instance data.
+ */
+static int drvTAPSetupApplication(PDRVTAP pThis)
 {
     char szCommand[4096];
@@ -400 +400 @@
     /* Convert MAC address bytes to string (required by Solaris' dladm). */
     char *pszHex = "0123456789abcdef";
-    uint8_t *pMacAddr8 = pData->MacAddress.au8;
+    uint8_t *pMacAddr8 = pThis->MacAddress.au8;
     char szMacAddress[3 * sizeof(RTMAC)];
     for (unsigned int i = 0; i < sizeof(RTMAC); i++)
@@ -411 +411 @@
     szMacAddress[sizeof(szMacAddress) - 1] =  0;
 
-    RTStrPrintf(szCommand, sizeof(szCommand), "%s %s %s", pData->pszSetupApplication,
-            szMacAddress, pData->fStatic ? pData->pszDeviceName : "");
+    RTStrPrintf(szCommand, sizeof(szCommand), "%s %s %s", pThis->pszSetupApplication,
+            szMacAddress, pThis->fStatic ? pThis->pszDeviceName : "");
 #else
-    RTStrPrintf(szCommand, sizeof(szCommand), "%s %s", pData->pszSetupApplication,
-            pData->fStatic ? pData->pszDeviceName : "");
+    RTStrPrintf(szCommand, sizeof(szCommand), "%s %s", pThis->pszSetupApplication,
+            pThis->fStatic ? pThis->pszDeviceName : "");
 #endif
 
@@ -423 +423 @@
     if (pfSetupHandle == 0)
     {
-        LogRel(("TAP#%d: Failed to run TAP setup application: %s\n", pData->pDrvIns->iInstance,
-              pData->pszSetupApplication, strerror(errno)));
+        LogRel(("TAP#%d: Failed to run TAP setup application: %s\n", pThis->pDrvIns->iInstance,
+              pThis->pszSetupApplication, strerror(errno)));
         return VERR_HOSTIF_INIT_FAILED;
     }
-    if (!pData->fStatic)
+    if (!pThis->fStatic)
     {
         /* Obtain device name from setup application. */
@@ -444 +444 @@
         /* Overwrite the terminating newline character. */
         acBuffer[cBufSize - 1] = 0;
-        RTStrAPrintf(&pData->pszDeviceName, "%s", acBuffer);
+        RTStrAPrintf(&pThis->pszDeviceName, "%s", acBuffer);
     }
     int rc = pclose(pfSetupHandle);
@@ -465 +465 @@
  *
  * @returns VBox error code.
- * @param   pData           The instance data.
- */
-static int drvTAPTerminateApplication(PDRVTAP pData)
+ * @param   pThis           The instance data.
+ */
+static int drvTAPTerminateApplication(PDRVTAP pThis)
 {
     char *pszArgs[3];
-    pszArgs[0] = pData->pszTerminateApplication;
-    pszArgs[1] = pData->pszDeviceName;
+    pszArgs[0] = pThis->pszTerminateApplication;
+    pszArgs[1] = pThis->pszDeviceName;
     pszArgs[2] = NULL;
 
-    Log2(("Starting TAP terminate application: %s %s\n", pData->pszTerminateApplication, pData->pszDeviceName));
+    Log2(("Starting TAP terminate application: %s %s\n", pThis->pszTerminateApplication, pThis->pszDeviceName));
     RTPROCESS pid = NIL_RTPROCESS;
     int rc = RTProcCreate(pszArgs[0], pszArgs, RTENV_DEFAULT, 0, &pid);
@@ -487 +487 @@
                 return VINF_SUCCESS;
 
-            LogRel(("TAP#%d: Error running TAP terminate application: %s\n", pData->pDrvIns->iInstance, pData->pszTerminateApplication));
+            LogRel(("TAP#%d: Error running TAP terminate application: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
         }
         else
-            LogRel(("TAP#%d: RTProcWait failed for: %s\n", pData->pDrvIns->iInstance, pData->pszTerminateApplication));
+            LogRel(("TAP#%d: RTProcWait failed for: %s\n", pThis->pDrvIns->iInstance, pThis->pszTerminateApplication));
     }
     else
     {
         /* Bad. RTProcCreate() failed! */
-        LogRel(("TAP#%d: Failed to fork() process for running TAP terminate application: %s\n", pData->pDrvIns->iInstance,
-              pData->pszTerminateApplication, strerror(errno)));
+        LogRel(("TAP#%d: Failed to fork() process for running TAP terminate application: %s\n", pThis->pDrvIns->iInstance,
+              pThis->pszTerminateApplication, strerror(errno)));
     }
     return VERR_HOSTIF_TERM_FAILED;
@@ -510 +510 @@
  *
  * @returns VBox error code.
- * @param   pData           The instance data.
- */
-static int SolarisOpenVNIC(PDRVTAP pData)
+ * @param   pThis           The instance data.
+ */
+static int SolarisOpenVNIC(PDRVTAP pThis)
 {
     /*
      * Open & bind the NIC using the datalink provider routine.
      */
-    int rc = g_pfnLibDlpiOpen(pData->pszDeviceName, &pData->pDeviceHandle, DLPI_RAW);
+    int rc = g_pfnLibDlpiOpen(pThis->pszDeviceName, &pThis->pDeviceHandle, DLPI_RAW);
     if (rc != DLPI_SUCCESS)
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
-                           N_("Failed to open VNIC \"%s\" in raw mode"), pData->pszDeviceName);
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                           N_("Failed to open VNIC \"%s\" in raw mode"), pThis->pszDeviceName);
 
     dlpi_info_t vnicInfo;
-    rc = g_pfnLibDlpiInfo(pData->pDeviceHandle, &vnicInfo, 0);
+    rc = g_pfnLibDlpiInfo(pThis->pDeviceHandle, &vnicInfo, 0);
     if (rc == DLPI_SUCCESS)
     {
         if (vnicInfo.di_mactype == DL_ETHER)
         {
-            rc = g_pfnLibDlpiBind(pData->pDeviceHandle, DLPI_ANY_SAP, NULL);
+            rc = g_pfnLibDlpiBind(pThis->pDeviceHandle, DLPI_ANY_SAP, NULL);
             if (rc == DLPI_SUCCESS)
             {
-                rc = g_pfnLibDlpiSetPhysAddr(pData->pDeviceHandle, DL_CURR_PHYS_ADDR, &pData->MacAddress, ETHERADDRL);
+                rc = g_pfnLibDlpiSetPhysAddr(pThis->pDeviceHandle, DL_CURR_PHYS_ADDR, &pThis->MacAddress, ETHERADDRL);
                 if (rc == DLPI_SUCCESS)
                 {
-                    rc = g_pfnLibDlpiPromiscon(pData->pDeviceHandle, DL_PROMISC_SAP);
+                    rc = g_pfnLibDlpiPromiscon(pThis->pDeviceHandle, DL_PROMISC_SAP);
                     if (rc == DLPI_SUCCESS)
                     {
                         /* Need to use DL_PROMIS_PHYS (not multicast) as we cannot be sure what the guest needs. */
-                        rc = g_pfnLibDlpiPromiscon(pData->pDeviceHandle, DL_PROMISC_PHYS);
+                        rc = g_pfnLibDlpiPromiscon(pThis->pDeviceHandle, DL_PROMISC_PHYS);
                         if (rc == DLPI_SUCCESS)
                         {
-                            pData->FileDevice = g_pfnLibDlpiFd(pData->pDeviceHandle);
-                            if (pData->FileDevice >= 0)
+                            pThis->FileDevice = g_pfnLibDlpiFd(pThis->pDeviceHandle);
+                            if (pThis->FileDevice >= 0)
                             {
-                                Log(("SolarisOpenVNIC: %s -> %d\n", pData->pszDeviceName, pData->FileDevice));
+                                Log(("SolarisOpenVNIC: %s -> %d\n", pThis->pszDeviceName, pThis->FileDevice));
                                 return VINF_SUCCESS;
                             }
 
-                            rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                            rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                                      N_("Failed to obtain file descriptor for VNIC"));
                         }
                         else
-                            rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                            rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                                      N_("Failed to set appropriate promiscous mode"));
                     }
                     else
-                        rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                        rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                                  N_("Failed to activate promiscous mode for VNIC"));
                 }
                 else
-                    rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                    rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                              N_("Failed to set physical address for VNIC"));
             }
             else
-                rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+                rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                          N_("Failed to bind VNIC"));
         }
         else
-            rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+            rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                          N_("VNIC type is not ethernet"));
     }
     else
-        rc = PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
+        rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
                                          N_("Failed to obtain VNIC info"));
-    g_pfnLibDlpiClose(pData->pDeviceHandle);
+    g_pfnLibDlpiClose(pThis->pDeviceHandle);
     return rc;
 }
@@ -625 +625 @@
  *
  * @returns VBox error code.
- * @param   pData            The instance data.
- */
-static DECLCALLBACK(int) SolarisTAPAttach(PDRVTAP pData)
-{
-    LogFlow(("SolarisTapAttach: pData=%p\n", pData));
+ * @param   pThis            The instance data.
+ */
+static DECLCALLBACK(int) SolarisTAPAttach(PDRVTAP pThis)
+{
+    LogFlow(("SolarisTapAttach: pThis=%p\n", pThis));
 
 
     int IPFileDes = open("/dev/udp", O_RDWR, 0);
     if (IPFileDes < 0)
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
                                    N_("Failed to open /dev/udp. errno=%d"), errno);
 
     int TapFileDes = open("/dev/tap", O_RDWR, 0);
     if (TapFileDes < 0)
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
                                    N_("Failed to open /dev/tap for TAP. errno=%d"), errno);
 
     /* Use the PPA from the ifname if possible (e.g "tap2", then use 2 as PPA) */
     int iPPA = -1;
-    if (pData->pszDeviceName)
-    {
-        size_t cch = strlen(pData->pszDeviceName);
-        if (cch > 1 && isdigit(pData->pszDeviceName[cch - 1]) != 0)
-            iPPA = pData->pszDeviceName[cch - 1] - '0';
+    if (pThis->pszDeviceName)
+    {
+        size_t cch = strlen(pThis->pszDeviceName);
+        if (cch > 1 && isdigit(pThis->pszDeviceName[cch - 1]) != 0)
+            iPPA = pThis->pszDeviceName[cch - 1] - '0';
     }
 
@@ -660 +660 @@
     {
         close(TapFileDes);
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
                                    N_("Failed to get new interface. errno=%d"), errno);
     }
@@ -666 +666 @@
     int InterfaceFD = open("/dev/tap", O_RDWR, 0);
     if (!InterfaceFD)
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
                                    N_("Failed to open interface /dev/tap. errno=%d"), errno);
 
@@ -672 +672 @@
     {
         close(InterfaceFD);
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
                                    N_("Failed to push IP. errno=%d"), errno);
     }
@@ -679 +679 @@
     memset(&ifReq, 0, sizeof(ifReq));
     if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
-        LogRel(("TAP#%d: Failed to get interface flags.\n", pData->pDrvIns->iInstance));
+        LogRel(("TAP#%d: Failed to get interface flags.\n", pThis->pDrvIns->iInstance));
 
     ifReq.lifr_ppa = iPPA;
-    RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pData->pszDeviceName);
+    RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
 
     if (ioctl(InterfaceFD, SIOCSLIFNAME, &ifReq) == -1)
-        LogRel(("TAP#%d: Failed to set PPA. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to set PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
     if (ioctl(InterfaceFD, SIOCGLIFFLAGS, &ifReq) == -1)
-        LogRel(("TAP#%d: Failed to get interface flags after setting PPA. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to get interface flags after setting PPA. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
 #ifdef VBOX_SOLARIS_TAP_ARP
     /* Interface */
     if (ioctl(InterfaceFD, I_PUSH, "arp") == -1)
-        LogRel(("TAP#%d: Failed to push ARP to Interface FD. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to push ARP to Interface FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
     /* IP */
     if (ioctl(IPFileDes, I_POP, NULL) == -1)
-        LogRel(("TAP#%d: Failed I_POP from IP FD. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed I_POP from IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
     if (ioctl(IPFileDes, I_PUSH, "arp") == -1)
-        LogRel(("TAP#%d: Failed to push ARP to IP FD. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to push ARP to IP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
     /* ARP */
     int ARPFileDes = open("/dev/tap", O_RDWR, 0);
     if (ARPFileDes < 0)
-        LogRel(("TAP#%d: Failed to open for /dev/tap for ARP. errno=%d", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to open for /dev/tap for ARP. errno=%d", pThis->pDrvIns->iInstance, errno));
 
     if (ioctl(ARPFileDes, I_PUSH, "arp") == -1)
-        LogRel(("TAP#%d: Failed to push ARP to ARP FD. errno=%d\n", pData->pDrvIns->iInstance, errno));
+        LogRel(("TAP#%d: Failed to push ARP to ARP FD. errno=%d\n", pThis->pDrvIns->iInstance, errno));
 
     ioIF.ic_cmd = SIOCSLIFNAME;
@@ -715 +715 @@
     ioIF.ic_dp = (char *)&ifReq;
     if (ioctl(ARPFileDes, I_STR, &ioIF) == -1)
-        LogRel(("TAP#%d: Failed to set interface name to ARP.\n", pData->pDrvIns->iInstance));
+        LogRel(("TAP#%d: Failed to set interface name to ARP.\n", pThis->pDrvIns->iInstance));
 #endif
 
@@ -729 +729 @@
         close(ARPFileDes);
 #endif
-        LogRel(("TAP#%d: Cannot link TAP device to IP.\n", pData->pDrvIns->iInstance));
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
+        LogRel(("TAP#%d: Cannot link TAP device to IP.\n", pThis->pDrvIns->iInstance));
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
                     N_("Failed to link TAP device to IP. Check TAP interface name. errno=%d"), errno);
     }
@@ -737 +737 @@
     int ARPMuxID = ioctl(IPFileDes, I_LINK, ARPFileDes);
     if (ARPMuxID == -1)
-        LogRel(("TAP#%d: Failed to link TAP device to ARP\n", pData->pDrvIns->iInstance));
+        LogRel(("TAP#%d: Failed to link TAP device to ARP\n", pThis->pDrvIns->iInstance));
 
     close(ARPFileDes);
@@ -745 +745 @@
     /* Reuse ifReq */
     memset(&ifReq, 0, sizeof(ifReq));
-    RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pData->pszDeviceName);
+    RTStrPrintf (ifReq.lifr_name, sizeof(ifReq.lifr_name), pThis->pszDeviceName);
     ifReq.lifr_ip_muxid  = IPMuxID;
 #ifdef VBOX_SOLARIS_TAP_ARP
@@ -758 +758 @@
         ioctl(IPFileDes, I_PUNLINK, IPMuxID);
         close(IPFileDes);
-        LogRel(("TAP#%d: Failed to set Mux ID.\n", pData->pDrvIns->iInstance));
-        return PDMDrvHlpVMSetError(pData->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
+        LogRel(("TAP#%d: Failed to set Mux ID.\n", pThis->pDrvIns->iInstance));
+        return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
                                    N_("Failed to set Mux ID. Check TAP interface name. errno=%d"), errno);
     }
 
-    pData->FileDevice = (RTFILE)TapFileDes;
-    pData->IPFileDevice = (RTFILE)IPFileDes;
+    pThis->FileDevice = (RTFILE)TapFileDes;
+    pThis->IPFileDevice = (RTFILE)IPFileDes;
 
     return VINF_SUCCESS;
@@ -785 +785 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
     switch (enmInterface)
     {
@@ -791 +791 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_NETWORK_CONNECTOR:
-            return &pData->INetworkConnector;
+            return &pThis->INetworkConnector;
         default:
             return NULL;
@@ -809 +809 @@
 {
     LogFlow(("drvTAPDestruct\n"));
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
 
     /*
      * Terminate the control pipe.
      */
-    if (pData->PipeWrite != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->PipeWrite);
+    if (pThis->PipeWrite != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->PipeWrite);
         AssertRC(rc);
-        pData->PipeWrite = NIL_RTFILE;
-    }
-    if (pData->PipeRead != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->PipeRead);
+        pThis->PipeWrite = NIL_RTFILE;
+    }
+    if (pThis->PipeRead != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->PipeRead);
         AssertRC(rc);
-        pData->PipeRead = NIL_RTFILE;
+        pThis->PipeRead = NIL_RTFILE;
     }
 
 #ifdef RT_OS_SOLARIS
     /** @todo r=bird: This *does* need checking against ConsoleImpl2.cpp if used on non-solaris systems. */
-    if (pData->FileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->FileDevice);
+    if (pThis->FileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->FileDevice);
         AssertRC(rc);
-        pData->FileDevice = NIL_RTFILE;
+        pThis->FileDevice = NIL_RTFILE;
     }
 
 # ifndef VBOX_WITH_CROSSBOW
-    if (pData->IPFileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->IPFileDevice);
+    if (pThis->IPFileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->IPFileDevice);
         AssertRC(rc);
-        pData->IPFileDevice = NIL_RTFILE;
+        pThis->IPFileDevice = NIL_RTFILE;
     }
 # endif
@@ -849 +849 @@
      * TerminateApplication would not be able to unplumb it.
      */
-    if (pData->pszTerminateApplication)
-        drvTAPTerminateApplication(pData);
+    if (pThis->pszTerminateApplication)
+        drvTAPTerminateApplication(pThis);
 
 #endif  /* RT_OS_SOLARIS */
 
 #ifdef RT_OS_SOLARIS
-    if (!pData->fStatic)
-        RTStrFree(pData->pszDeviceName);    /* allocated by drvTAPSetupApplication */
+    if (!pThis->fStatic)
+        RTStrFree(pThis->pszDeviceName);    /* allocated by drvTAPSetupApplication */
     else
-        MMR3HeapFree(pData->pszDeviceName);
+        MMR3HeapFree(pThis->pszDeviceName);
 #else
-    MMR3HeapFree(pData->pszDeviceName);
-#endif
-    MMR3HeapFree(pData->pszSetupApplication);
-    MMR3HeapFree(pData->pszTerminateApplication);
+    MMR3HeapFree(pThis->pszDeviceName);
+#endif
+    MMR3HeapFree(pThis->pszSetupApplication);
+    MMR3HeapFree(pThis->pszTerminateApplication);
 }
 
@@ -879 +879 @@
 static DECLCALLBACK(int) drvTAPConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-    pData->FileDevice                   = NIL_RTFILE;
-    pData->pszDeviceName                = NULL;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->FileDevice                   = NIL_RTFILE;
+    pThis->pszDeviceName                = NULL;
 #ifdef RT_OS_SOLARIS
 # ifdef VBOX_WITH_CROSSBOW
-    pData->pDeviceHandle                = NULL;
+    pThis->pDeviceHandle                = NULL;
 # else
-    pData->IPFileDevice                 = NIL_RTFILE;
+    pThis->IPFileDevice                 = NIL_RTFILE;
 # endif
-    pData->fStatic                      = true;
-#endif
-    pData->pszSetupApplication          = NULL;
-    pData->pszTerminateApplication      = NULL;
+    pThis->fStatic                      = true;
+#endif
+    pThis->pszSetupApplication          = NULL;
+    pThis->pszTerminateApplication      = NULL;
 
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvTAPQueryInterface;
     /* INetwork */
-    pData->INetworkConnector.pfnSend                = drvTAPSend;
-    pData->INetworkConnector.pfnSetPromiscuousMode  = drvTAPSetPromiscuousMode;
-    pData->INetworkConnector.pfnNotifyLinkChanged   = drvTAPNotifyLinkChanged;
+    pThis->INetworkConnector.pfnSend                = drvTAPSend;
+    pThis->INetworkConnector.pfnSetPromiscuousMode  = drvTAPSetPromiscuousMode;
+    pThis->INetworkConnector.pfnNotifyLinkChanged   = drvTAPNotifyLinkChanged;
 
     /*
@@ -922 +922 @@
      * Query the network port interface.
      */
-    pData->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
-    if (!pData->pPort)
+    pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
+    if (!pThis->pPort)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
                                 N_("Configuration error: The above device/driver didn't export the network port interface"));
@@ -931 +931 @@
      */
 #if defined(RT_OS_SOLARIS)   /** @todo Other platforms' TAP code should be moved here from ConsoleImpl & VBoxBFE. */
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TAPSetupApplication", &pData->pszSetupApplication);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TAPSetupApplication", &pThis->pszSetupApplication);
     if (RT_SUCCESS(rc))
     {
-        if (!RTPathExists(pData->pszSetupApplication))
+        if (!RTPathExists(pThis->pszSetupApplication))
             return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
-                                       N_("Invalid TAP setup program path: %s"), pData->pszSetupApplication);
+                                       N_("Invalid TAP setup program path: %s"), pThis->pszSetupApplication);
     }
     else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: failed to query \"TAPTerminateApplication\""));
 
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TAPTerminateApplication", &pData->pszTerminateApplication);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "TAPTerminateApplication", &pThis->pszTerminateApplication);
     if (RT_SUCCESS(rc))
     {
-        if (!RTPathExists(pData->pszTerminateApplication))
+        if (!RTPathExists(pThis->pszTerminateApplication))
             return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
-                                       N_("Invalid TAP terminate program path: %s"), pData->pszTerminateApplication);
+                                       N_("Invalid TAP terminate program path: %s"), pThis->pszTerminateApplication);
     }
     else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
@@ -952 +952 @@
 
 # ifdef VBOX_WITH_CROSSBOW
-    rc = CFGMR3QueryBytes(pCfgHandle, "MAC", &pData->MacAddress, sizeof(pData->MacAddress));
+    rc = CFGMR3QueryBytes(pCfgHandle, "MAC", &pThis->MacAddress, sizeof(pThis->MacAddress));
     if (RT_FAILURE(rc))
         return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Configuration error: Failed to query \"MAC\""));
 # endif
 
-    rc = CFGMR3QueryStringAlloc(pCfgHandle, "Device", &pData->pszDeviceName);
+    rc = CFGMR3QueryStringAlloc(pCfgHandle, "Device", &pThis->pszDeviceName);
     if (RT_FAILURE(rc))
-        pData->fStatic = false;
+        pThis->fStatic = false;
 
     /* Obtain the device name from the setup application (if none was specified). */
-    if (pData->pszSetupApplication)
-    {
-        rc = drvTAPSetupApplication(pData);
+    if (pThis->pszSetupApplication)
+    {
+        rc = drvTAPSetupApplication(pThis);
         if (RT_FAILURE(rc))
             return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,
@@ -979 +979 @@
                                        N_("Failed to load library %s required for host interface networking."), LIB_DLPI);
     }
-    rc = SolarisOpenVNIC(pData);
+    rc = SolarisOpenVNIC(pThis);
 # else
-    rc = SolarisTAPAttach(pData);
+    rc = SolarisTAPAttach(pThis);
 # endif
     if (RT_FAILURE(rc))
@@ -993 +993 @@
         return PDMDRV_SET_ERROR(pDrvIns, rc,
                                 N_("Configuration error: Query for \"FileHandle\" 32-bit signed integer failed"));
-    pData->FileDevice = (RTFILE)iFile;
-    if (!RTFileIsValid(pData->FileDevice))
+    pThis->FileDevice = (RTFILE)iFile;
+    if (!RTFileIsValid(pThis->FileDevice))
         return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_HANDLE, RT_SRC_POS,
-                                   N_("The TAP file handle %RTfile is not valid"), pData->FileDevice);
+                                   N_("The TAP file handle %RTfile is not valid"), pThis->FileDevice);
 #endif /* !RT_OS_SOLARIS */
 
@@ -1005 +1005 @@
      * found any way to do that.
      */
-    if (fcntl(pData->FileDevice, F_SETFL, O_NONBLOCK) == -1)
+    if (fcntl(pThis->FileDevice, F_SETFL, O_NONBLOCK) == -1)
         return PDMDrvHlpVMSetError(pDrvIns, VERR_HOSTIF_IOCTL, RT_SRC_POS,
                                    N_("Configuration error: Failed to configure /dev/net/tun. errno=%d"), errno);
     /** @todo determine device name. This can be done by reading the link /proc/<pid>/fd/<fd> */
-    Log(("drvTAPContruct: %d (from fd)\n", pData->FileDevice));
+    Log(("drvTAPContruct: %d (from fd)\n", pThis->FileDevice));
     rc = VINF_SUCCESS;
 
@@ -1026 +1026 @@
         return rc;
     }
-    pData->PipeRead = fds[0];
-    pData->PipeWrite = fds[1];
+    pThis->PipeRead = fds[0];
+    pThis->PipeWrite = fds[1];
 
     /*
      * Create the async I/O thread.
      */
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pThread, pData, drvTAPAsyncIoThread, drvTapAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPAsyncIoThread, drvTapAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
     AssertRCReturn(rc, rc);
 
@@ -1039 +1039 @@
      * Statistics.
      */
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSent,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,        "Number of sent packets.",          "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSentBytes,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,             "Number of sent bytes.",            "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecv,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,        "Number of received packets.",      "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecvBytes,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,             "Number of received bytes.",        "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatTransmit,      STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,    "Profiling packet transmit runs.",  "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatReceive,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,    "Profiling packet receive runs.",   "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,        "Number of sent packets.",          "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,             "Number of sent bytes.",            "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,        "Number of received packets.",      "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,             "Number of received bytes.",        "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit,      STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,    "Profiling packet transmit runs.",  "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL,    "Profiling packet receive runs.",   "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
 #endif /* VBOX_WITH_STATISTICS */
 

trunk/src/VBox/Devices/Network/DrvTAPWin.cpp

@@ -112 +112 @@
     DWORD      cbBytesWritten;
     int        rc;
-    PDRVTAP    pData = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
+    PDRVTAP    pThis = PDMINETWORKCONNECTOR_2_DRVTAP(pInterface);
 
     Log2(("drvTAPW32Send%d: pvBuf=%p cb=%#x\n"
-          "%.*Vhxd\n", pData->pDrvIns->iInstance, pvBuf, cb, cb, pvBuf));
+          "%.*Vhxd\n", pThis->pDrvIns->iInstance, pvBuf, cb, cb, pvBuf));
 
 #ifdef DEBUG
-    pData->dwLastReadTime = timeGetTime();
-    Log(("drvTAPW32Send %d bytes at %08x - delta %x\n", cb, pData->dwLastReadTime, pData->dwLastReadTime - pData->dwLastWriteTime));
+    pThis->dwLastReadTime = timeGetTime();
+    Log(("drvTAPW32Send %d bytes at %08x - delta %x\n", cb, pThis->dwLastReadTime, pThis->dwLastReadTime - pThis->dwLastWriteTime));
 #endif
 
-    STAM_COUNTER_INC(&pData->StatPktSent);
-    STAM_COUNTER_ADD(&pData->StatPktSentBytes, cb);
-    STAM_PROFILE_ADV_START(&pData->StatTransmit, a);
+    STAM_COUNTER_INC(&pThis->StatPktSent);
+    STAM_COUNTER_ADD(&pThis->StatPktSentBytes, cb);
+    STAM_PROFILE_ADV_START(&pThis->StatTransmit, a);
 
     memset(&overlapped, 0, sizeof(overlapped));
-    overlapped.hEvent = pData->hEventWrite;
+    overlapped.hEvent = pThis->hEventWrite;
 
     rc = VINF_SUCCESS;
-    if (WriteFile(pData->hFile, pvBuf, cb, &cbBytesWritten, &overlapped) == FALSE)
+    if (WriteFile(pThis->hFile, pvBuf, cb, &cbBytesWritten, &overlapped) == FALSE)
     {
         if (GetLastError() == ERROR_IO_PENDING)
@@ -145 +145 @@
         }
     }
-    STAM_PROFILE_ADV_STOP(&pData->StatTransmit, a);
+    STAM_PROFILE_ADV_STOP(&pThis->StatTransmit, a);
     AssertRC(rc);
     return rc;
@@ -187 +187 @@
 static DECLCALLBACK(int) drvTAPW32AsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
     HANDLE  haWait[2];
     DWORD   rc = ERROR_SUCCESS, dwNumberOfBytesTransferred;
@@ -194 +194 @@
         return VINF_SUCCESS;
 
-    Assert(pData);
-    haWait[0] = pData->hEventRead;
-    haWait[1] = pData->hHaltAsyncEventSem;
+    Assert(pThis);
+    haWait[0] = pThis->hEventRead;
+    haWait[1] = pThis->hHaltAsyncEventSem;
 
     while(1)
@@ -202 +202 @@
         BOOL  bRet;
 
-        memset(&pData->overlappedRead, 0, sizeof(pData->overlappedRead));
-        pData->overlappedRead.hEvent = pData->hEventRead;
-        bRet = ReadFile(pData->hFile, pData->readBuffer, sizeof(pData->readBuffer),
-                        &dwNumberOfBytesTransferred, &pData->overlappedRead);
+        memset(&pThis->overlappedRead, 0, sizeof(pThis->overlappedRead));
+        pThis->overlappedRead.hEvent = pThis->hEventRead;
+        bRet = ReadFile(pThis->hFile, pThis->readBuffer, sizeof(pThis->readBuffer),
+                        &dwNumberOfBytesTransferred, &pThis->overlappedRead);
         if (bRet == FALSE)
         {
@@ -219 +219 @@
                 break;  /* asked to quit or fatal error. */
 
-            rc = GetOverlappedResult(pData->hFile, &pData->overlappedRead, &dwNumberOfBytesTransferred, FALSE);
+            rc = GetOverlappedResult(pThis->hFile, &pThis->overlappedRead, &dwNumberOfBytesTransferred, FALSE);
             Assert(rc == TRUE);
 
@@ -230 +230 @@
          * current packet and wait for the next one.
          */
-        rc = pData->pPort->pfnWaitReceiveAvail(pData->pPort, RT_INDEFINITE_WAIT);
+        rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc))
             continue;
 
-        STAM_COUNTER_INC(&pData->StatPktRecv);
-        STAM_COUNTER_ADD(&pData->StatPktRecvBytes, dwNumberOfBytesTransferred);
+        STAM_COUNTER_INC(&pThis->StatPktRecv);
+        STAM_COUNTER_ADD(&pThis->StatPktRecvBytes, dwNumberOfBytesTransferred);
 #ifdef DEBUG
-        pData->dwLastWriteTime = timeGetTime();
+        pThis->dwLastWriteTime = timeGetTime();
         Log(("drvTAPW32AsyncIo %d bytes at %08x - delta %x\n", dwNumberOfBytesTransferred,
-             pData->dwLastWriteTime, pData->dwLastWriteTime - pData->dwLastReadTime));
+             pThis->dwLastWriteTime, pThis->dwLastWriteTime - pThis->dwLastReadTime));
 #endif
-        rc = pData->pPort->pfnReceive(pData->pPort, pData->readBuffer, dwNumberOfBytesTransferred);
+        rc = pThis->pPort->pfnReceive(pThis->pPort, pThis->readBuffer, dwNumberOfBytesTransferred);
         AssertRC(rc);
     }
 
-    SetEvent(pData->hHaltAsyncEventSem);
+    SetEvent(pThis->hHaltAsyncEventSem);
     Log(("drvTAPW32AsyncIo: exit thread!!\n"));
     return VINF_SUCCESS;
@@ -260 +260 @@
 static DECLCALLBACK(int) drvTAPW32AsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
 
     /** @todo this isn't a safe method to notify the async thread; it might be using the instance
@@ -266 +266 @@
      *        without risks either.
      */
-    SetEvent(pData->hHaltAsyncEventSem);
+    SetEvent(pThis->hHaltAsyncEventSem);
 
     /* Yield or else our async thread will never acquire the event semaphore */
     RTThreadSleep(16);
     /* Wait for the async thread to quit; up to half a second */
-    WaitForSingleObject(pData->hHaltAsyncEventSem, 500);
+    WaitForSingleObject(pThis->hHaltAsyncEventSem, 500);
 
     return VINF_SUCCESS;
@@ -288 +288 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
     switch (enmInterface)
     {
@@ -294 +294 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_NETWORK_CONNECTOR:
-            return &pData->INetworkConnector;
+            return &pThis->INetworkConnector;
         default:
             return NULL;
@@ -311 +311 @@
 static DECLCALLBACK(void) drvTAPW32Destruct(PPDMDRVINS pDrvIns)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
     TAP_MEDIASTATUS mediastatus;
     DWORD dwLength;
@@ -318 +318 @@
 
     mediastatus.fConnect = FALSE;
-    BOOL ret = DeviceIoControl(pData->hFile, TAP_IOCTL_SET_MEDIA_STATUS,
+    BOOL ret = DeviceIoControl(pThis->hFile, TAP_IOCTL_SET_MEDIA_STATUS,
                                &mediastatus, sizeof(mediastatus), NULL, 0, &dwLength, NULL);
     Assert(ret);
 
-    CloseHandle(pData->hEventWrite);
-    CancelIo(pData->hFile);
-    CloseHandle(pData->hFile);
+    CloseHandle(pThis->hEventWrite);
+    CancelIo(pThis->hFile);
+    CloseHandle(pThis->hFile);
 }
 
@@ -340 +340 @@
 static DECLCALLBACK(int) drvTAPW32Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVTAP pData = PDMINS_2_DATA(pDrvIns, PDRVTAP);
+    PDRVTAP pThis = PDMINS_2_DATA(pDrvIns, PDRVTAP);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-    pData->hFile                        = INVALID_HANDLE_VALUE;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->hFile                        = INVALID_HANDLE_VALUE;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvTAPW32QueryInterface;
     /* INetwork */
-    pData->INetworkConnector.pfnSend                = drvTAPW32Send;
-    pData->INetworkConnector.pfnSetPromiscuousMode  = drvTAPW32SetPromiscuousMode;
-    pData->INetworkConnector.pfnNotifyLinkChanged   = drvTAPW32NotifyLinkChanged;
+    pThis->INetworkConnector.pfnSend                = drvTAPW32Send;
+    pThis->INetworkConnector.pfnSetPromiscuousMode  = drvTAPW32SetPromiscuousMode;
+    pThis->INetworkConnector.pfnNotifyLinkChanged   = drvTAPW32NotifyLinkChanged;
 
     /*
@@ -371 +371 @@
      * Query the network port interface.
      */
-    pData->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
-    if (!pData->pPort)
+    pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
+    if (!pThis->pPort)
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
                                 N_("Configuration error: the above device/driver didn't export the network port interface"));
@@ -397 +397 @@
     RTStrPrintfEx(NULL, NULL, szFullDriverName, sizeof(szFullDriverName), "\\\\.\\Global\\%s.tap", szDriverGUID);
 
-    pData->hFile = CreateFile(szFullDriverName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+    pThis->hFile = CreateFile(szFullDriverName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
                               FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
 
-    if (pData->hFile == INVALID_HANDLE_VALUE)
+    if (pThis->hFile == INVALID_HANDLE_VALUE)
     {
         rc = GetLastError();
@@ -412 +412 @@
     }
 
-    BOOL ret = DeviceIoControl(pData->hFile, TAP_IOCTL_GET_VERSION, &pData->tapVersion, sizeof (pData->tapVersion),
-                               &pData->tapVersion, sizeof(pData->tapVersion), &length, NULL);
+    BOOL ret = DeviceIoControl(pThis->hFile, TAP_IOCTL_GET_VERSION, &pThis->tapVersion, sizeof (pThis->tapVersion),
+                               &pThis->tapVersion, sizeof(pThis->tapVersion), &length, NULL);
     if (ret == FALSE)
     {
-        CloseHandle(pData->hFile);
+        CloseHandle(pThis->hFile);
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_HIF_INVALID_VERSION,
                                 N_("Failed to get the Host Interface Networking device driver version"));;
     }
-    LogRel(("TAP version %d.%d\n", pData->tapVersion.major, pData->tapVersion.minor));
+    LogRel(("TAP version %d.%d\n", pThis->tapVersion.major, pThis->tapVersion.minor));
 
     /* Must be at least version 8.1 */
-    if (    pData->tapVersion.major != 8
-        ||  pData->tapVersion.minor < 1)
-    {
-        CloseHandle(pData->hFile);
+    if (    pThis->tapVersion.major != 8
+        ||  pThis->tapVersion.minor < 1)
+    {
+        CloseHandle(pThis->hFile);
         return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_HIF_INVALID_VERSION,
                                 N_("Invalid Host Interface Networking device driver version"));;
@@ -432 +432 @@
 
     mediastatus.fConnect = TRUE;
-    ret = DeviceIoControl(pData->hFile, TAP_IOCTL_SET_MEDIA_STATUS, &mediastatus, sizeof(mediastatus), NULL, 0, &length, NULL);
+    ret = DeviceIoControl(pThis->hFile, TAP_IOCTL_SET_MEDIA_STATUS, &mediastatus, sizeof(mediastatus), NULL, 0, &length, NULL);
     if (ret == FALSE)
     {
-        CloseHandle(pData->hFile);
+        CloseHandle(pThis->hFile);
         return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
     }
@@ -442 +442 @@
         MMR3HeapFree(pszHostDriver);
 
-    pData->hEventWrite = CreateEvent(NULL, FALSE, FALSE, NULL);
-    pData->hEventRead  = CreateEvent(NULL, FALSE, FALSE, NULL);
-    memset(&pData->overlappedRead, 0, sizeof(pData->overlappedRead));
-
-    pData->hHaltAsyncEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);
-    Assert(pData->hHaltAsyncEventSem != NULL);
+    pThis->hEventWrite = CreateEvent(NULL, FALSE, FALSE, NULL);
+    pThis->hEventRead  = CreateEvent(NULL, FALSE, FALSE, NULL);
+    memset(&pThis->overlappedRead, 0, sizeof(pThis->overlappedRead));
+
+    pThis->hHaltAsyncEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);
+    Assert(pThis->hHaltAsyncEventSem != NULL);
 
     /* Create asynchronous thread */
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pThread, pData, drvTAPW32AsyncIoThread, drvTAPW32AsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvTAPW32AsyncIoThread, drvTAPW32AsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "TAP");
     AssertRCReturn(rc, rc);
 
@@ -457 +457 @@
      * Statistics.
      */
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSent,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of sent packets.",         "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Number of sent bytes.",           "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecv,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of received packets.",     "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Number of received bytes.",       "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatTransmit,     STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatReceive,      STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.",  "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatRecvOverflows,STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling packet receive overflows.", "/Drivers/TAP%d/RecvOverflows", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of sent packets.",         "/Drivers/TAP%d/Packets/Sent", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Number of sent bytes.",           "/Drivers/TAP%d/Bytes/Sent", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of received packets.",     "/Drivers/TAP%d/Packets/Received", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Number of received bytes.",       "/Drivers/TAP%d/Bytes/Received", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit,     STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/TAP%d/Transmit", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive,      STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.",  "/Drivers/TAP%d/Receive", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatRecvOverflows,STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling packet receive overflows.", "/Drivers/TAP%d/RecvOverflows", pDrvIns->iInstance);
 #endif
 

trunk/src/VBox/Devices/PC/DevACPI.cpp

@@ -1466 +1466 @@
 static DECLCALLBACK(void *) acpiQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    ACPIState *pData = (ACPIState*)((uintptr_t)pInterface - RT_OFFSETOF(ACPIState, IBase));
+    ACPIState *pThis = (ACPIState*)((uintptr_t)pInterface - RT_OFFSETOF(ACPIState, IBase));
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         case PDMINTERFACE_ACPI_PORT:
-            return &pData->IACPIPort;
+            return &pThis->IACPIPort;
         default:
             return NULL;

trunk/src/VBox/Devices/PC/DevAPIC.cpp

@@ -1656 +1656 @@
 static DECLCALLBACK(void) apicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    APICState *pData = PDMINS_2_DATA(pDevIns, APICState *);
-    pData->pDevInsRC  = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->pApicHlpRC = pData->pApicHlpR3->pfnGetRCHelpers(pDevIns);
-    pData->pTimerRC   = TMTimerRCPtr(pData->CTX_SUFF(pTimer));
+    APICState *pThis = PDMINS_2_DATA(pDevIns, APICState *);
+    pThis->pDevInsRC  = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->pApicHlpRC = pThis->pApicHlpR3->pfnGetRCHelpers(pDevIns);
+    pThis->pTimerRC   = TMTimerRCPtr(pThis->CTX_SUFF(pTimer));
 }
 
@@ -1667 +1667 @@
 static DECLCALLBACK(int) apicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    APICState      *pData = PDMINS_2_DATA(pDevIns, APICState *);
+    APICState      *pThis = PDMINS_2_DATA(pDevIns, APICState *);
     PDMAPICREG      ApicReg;
     int             rc;
@@ -1701 +1701 @@
      * Init the data.
      */
-    pData->pDevInsR3 = pDevIns;
-    pData->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->apicbase  = UINT32_C(0xfee00000) | MSR_IA32_APICBASE_BSP | MSR_IA32_APICBASE_ENABLE;
+    pThis->pDevInsR3 = pDevIns;
+    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->apicbase  = UINT32_C(0xfee00000) | MSR_IA32_APICBASE_BSP | MSR_IA32_APICBASE_ENABLE;
     for (i = 0; i < APIC_LVT_NB; i++)
-        pData->lvt[i] = 1 << 16; /* mask LVT */
-    pData->spurious_vec = 0xff;
+        pThis->lvt[i] = 1 << 16; /* mask LVT */
+    pThis->spurious_vec = 0xff;
 
     /*
@@ -1756 +1756 @@
 
     Assert(pDevIns->pDevHlp->pfnAPICRegister);
-    rc = pDevIns->pDevHlp->pfnAPICRegister(pDevIns, &ApicReg, &pData->pApicHlpR3);
+    rc = pDevIns->pDevHlp->pfnAPICRegister(pDevIns, &ApicReg, &pThis->pApicHlpR3);
     if (RT_FAILURE(rc))
     {
@@ -1779 +1779 @@
         {
             LogRel(("Activating Local APIC\n"));
-            pData->pApicHlpR3->pfnChangeFeature(pDevIns, true);
+            pThis->pApicHlpR3->pfnChangeFeature(pDevIns, true);
         }
     }
@@ -1786 +1786 @@
      * Register the MMIO range.
      */
-    rc = PDMDevHlpMMIORegister(pDevIns, pData->apicbase & ~0xfff, 0x1000, pData,
+    rc = PDMDevHlpMMIORegister(pDevIns, pThis->apicbase & ~0xfff, 0x1000, pThis,
                                apicMMIOWrite, apicMMIORead, NULL, "APIC Memory");
     if (RT_FAILURE(rc))
@@ -1792 +1792 @@
 
     if (fGCEnabled) {
-        pData->pApicHlpRC = pData->pApicHlpR3->pfnGetRCHelpers(pDevIns);
-
-        rc = PDMDevHlpMMIORegisterGC(pDevIns, pData->apicbase & ~0xfff, 0x1000, 0,
+        pThis->pApicHlpRC = pThis->pApicHlpR3->pfnGetRCHelpers(pDevIns);
+
+        rc = PDMDevHlpMMIORegisterGC(pDevIns, pThis->apicbase & ~0xfff, 0x1000, 0,
                                      "apicMMIOWrite", "apicMMIORead", NULL);
         if (RT_FAILURE(rc))
@@ -1801 +1801 @@
 
     if (fR0Enabled) {
-        pData->pApicHlpR0 = pData->pApicHlpR3->pfnGetR0Helpers(pDevIns);
-
-        rc = PDMDevHlpMMIORegisterR0(pDevIns, pData->apicbase & ~0xfff, 0x1000, 0,
+        pThis->pApicHlpR0 = pThis->pApicHlpR3->pfnGetR0Helpers(pDevIns);
+
+        rc = PDMDevHlpMMIORegisterR0(pDevIns, pThis->apicbase & ~0xfff, 0x1000, 0,
                                      "apicMMIOWrite", "apicMMIORead", NULL);
         if (RT_FAILURE(rc))
@@ -1813 +1813 @@
      */
     rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, apicTimer,
-                                "APIC Timer", &pData->CTX_SUFF(pTimer));
+                                "APIC Timer", &pThis->CTX_SUFF(pTimer));
     if (RT_FAILURE(rc))
         return rc;
-    pData->pTimerR0 = TMTimerR0Ptr(pData->CTX_SUFF(pTimer));
-    pData->pTimerRC = TMTimerRCPtr(pData->CTX_SUFF(pTimer));
+    pThis->pTimerR0 = TMTimerR0Ptr(pThis->CTX_SUFF(pTimer));
+    pThis->pTimerRC = TMTimerRCPtr(pThis->CTX_SUFF(pTimer));
 
     /*
@@ -1823 +1823 @@
      */
     rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */,
-                              sizeof(*pData), NULL, apicSaveExec, NULL, NULL, apicLoadExec, NULL);
+                              sizeof(*pThis), NULL, apicSaveExec, NULL, NULL, apicLoadExec, NULL);
     if (RT_FAILURE(rc))
         return rc;
@@ -1831 +1831 @@
      * Statistics.
      */
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOReadGC,     STAMTYPE_COUNTER,  "/PDM/APIC/MMIOReadGC",   STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in GC.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOReadHC,     STAMTYPE_COUNTER,  "/PDM/APIC/MMIOReadHC",   STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in HC.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOWriteGC,    STAMTYPE_COUNTER,  "/PDM/APIC/MMIOWriteGC",  STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in GC.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOWriteHC,    STAMTYPE_COUNTER,  "/PDM/APIC/MMIOWriteHC",  STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in HC.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatClearedActiveIrq, STAMTYPE_COUNTER,  "/PDM/APIC/Masked/ActiveIRQ",  STAMUNIT_OCCURENCES, "Number of cleared irqs.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOReadGC,     STAMTYPE_COUNTER,  "/PDM/APIC/MMIOReadGC",   STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in GC.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOReadHC,     STAMTYPE_COUNTER,  "/PDM/APIC/MMIOReadHC",   STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in HC.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOWriteGC,    STAMTYPE_COUNTER,  "/PDM/APIC/MMIOWriteGC",  STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in GC.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOWriteHC,    STAMTYPE_COUNTER,  "/PDM/APIC/MMIOWriteHC",  STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in HC.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatClearedActiveIrq, STAMTYPE_COUNTER,  "/PDM/APIC/Masked/ActiveIRQ",  STAMUNIT_OCCURENCES, "Number of cleared irqs.");
 #endif
 

trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

@@ -638 +638 @@
     if (cb == 1)
     {
-        PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
-        const uint64_t u64Now = TMTimerGet(pData->channels[0].CTX_SUFF(pTimer));
-        Assert(TMTimerGetFreq(pData->channels[0].CTX_SUFF(pTimer)) == 1000000000); /* lazy bird. */
+        PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
+        const uint64_t u64Now = TMTimerGet(pThis->channels[0].CTX_SUFF(pTimer));
+        Assert(TMTimerGetFreq(pThis->channels[0].CTX_SUFF(pTimer)) == 1000000000); /* lazy bird. */
 
         /* bit 6,7 Parity error stuff. */
         /* bit 5 - mirrors timer 2 output condition. */
-        const int fOut = pit_get_out(pData, 2, u64Now);
+        const int fOut = pit_get_out(pThis, 2, u64Now);
         /* bit 4 - toggled every with each (DRAM?) refresh request, every 15.085 µs. */
 #ifdef FAKE_REFRESH_CLOCK
-        pData->dummy_refresh_clock ^= 1;
-        const int fRefresh = pData->dummy_refresh_clock;
+        pThis->dummy_refresh_clock ^= 1;
+        const int fRefresh = pThis->dummy_refresh_clock;
 #else
         const int fRefresh = (u64Now / 15085) & 1;
@@ -654 +654 @@
         /* bit 2,3 NMI / parity status stuff. */
         /* bit 1 - speaker data status */
-        const int fSpeakerStatus = pData->speaker_data_on;
+        const int fSpeakerStatus = pThis->speaker_data_on;
         /* bit 0 - timer 2 clock gate to speaker status. */
-        const int fTimer2GateStatus = pit_get_gate(pData, 2);
+        const int fTimer2GateStatus = pit_get_gate(pThis, 2);
 
         *pu32 = fTimer2GateStatus
@@ -687 +687 @@
     if (cb == 1)
     {
-        PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
-        pData->speaker_data_on = (u32 >> 1) & 1;
-        pit_set_gate(pData, 2, u32 & 1);
+        PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
+        pThis->speaker_data_on = (u32 >> 1) & 1;
+        pit_set_gate(pThis, 2, u32 & 1);
     }
     Log(("pitIOPortSpeakerWrite: Port=%#x cb=%x u32=%#x\n", Port, cb, u32));
@@ -705 +705 @@
 static DECLCALLBACK(int) pitSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     unsigned i;
 
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        PITChannelState *s = &pData->channels[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        PITChannelState *s = &pThis->channels[i];
         SSMR3PutU32(pSSMHandle, s->count);
         SSMR3PutU16(pSSMHandle, s->latched_count);
@@ -731 +731 @@
     }
 
-    SSMR3PutS32(pSSMHandle, pData->speaker_data_on);
+    SSMR3PutS32(pSSMHandle, pThis->speaker_data_on);
 #ifdef FAKE_REFRESH_CLOCK
-    return SSMR3PutS32(pSSMHandle, pData->dummy_refresh_clock);
+    return SSMR3PutS32(pSSMHandle, pThis->dummy_refresh_clock);
 #else
     return SSMR3PutS32(pSSMHandle, 0);
@@ -750 +750 @@
 static DECLCALLBACK(int) pitLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
 {
-    PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     unsigned i;
 
@@ -756 +756 @@
         return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
 
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        PITChannelState *s = &pData->channels[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        PITChannelState *s = &pThis->channels[i];
         SSMR3GetU32(pSSMHandle, &s->count);
         SSMR3GetU16(pSSMHandle, &s->latched_count);
@@ -781 +781 @@
                     s->mode, s->count, s->count, PIT_FREQ / s->count, (PIT_FREQ * 100 / s->count) % 100, i));
         }
-        pData->channels[0].cRelLogEntries = 0;
-    }
-
-    SSMR3GetS32(pSSMHandle, &pData->speaker_data_on);
+        pThis->channels[0].cRelLogEntries = 0;
+    }
+
+    SSMR3GetS32(pSSMHandle, &pThis->speaker_data_on);
 #ifdef FAKE_REFRESH_CLOCK
-    return SSMR3GetS32(pSSMHandle, &pData->dummy_refresh_clock);
+    return SSMR3GetS32(pSSMHandle, &pThis->dummy_refresh_clock);
 #else
     int32_t u32Dummy;
@@ -802 +802 @@
 static DECLCALLBACK(void) pitTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer)
 {
-    PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
-    PITChannelState *s = &pData->channels[0];
+    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
+    PITChannelState *s = &pThis->channels[0];
     STAM_PROFILE_ADV_START(&s->CTX_SUFF(pPit)->StatPITHandler, a);
     pit_irq_timer_update(s, s->next_transition_time);
@@ -819 +819 @@
 static DECLCALLBACK(void) pitRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     unsigned i;
     LogFlow(("pitRelocate: \n"));
 
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        PITChannelState *pCh = &pData->channels[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        PITChannelState *pCh = &pThis->channels[i];
         if (pCh->pTimerR3)
             pCh->pTimerRC = TMTimerRCPtr(pCh->pTimerR3);
-        pData->channels[i].pPitRC = PDMINS_2_DATA_RCPTR(pDevIns);
+        pThis->channels[i].pPitRC = PDMINS_2_DATA_RCPTR(pDevIns);
     }
 }
@@ -843 +843 @@
 static DECLCALLBACK(void) pitReset(PPDMDEVINS pDevIns)
 {
-    PITState *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     unsigned i;
     LogFlow(("pitReset: \n"));
 
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        PITChannelState *s = &pData->channels[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        PITChannelState *s = &pThis->channels[i];
 
 #if 1 /* Set everything back to virgin state. (might not be strictly correct) */
@@ -879 +879 @@
 static DECLCALLBACK(void) pitInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PITState   *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState   *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     unsigned    i;
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        const PITChannelState *pCh = &pData->channels[i];
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        const PITChannelState *pCh = &pThis->channels[i];
 
         pHlp->pfnPrintf(pHlp,
@@ -904 +904 @@
 #ifdef FAKE_REFRESH_CLOCK
     pHlp->pfnPrintf(pHlp, "speaker_data_on=%#x dummy_refresh_clock=%#x\n",
-                    pData->speaker_data_on, pData->dummy_refresh_clock);
+                    pThis->speaker_data_on, pThis->dummy_refresh_clock);
 #else
-    pHlp->pfnPrintf(pHlp, "speaker_data_on=%#x\n", pData->speaker_data_on);
+    pHlp->pfnPrintf(pHlp, "speaker_data_on=%#x\n", pThis->speaker_data_on);
 #endif
 }
@@ -926 +926 @@
 static DECLCALLBACK(int)  pitConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    PITState   *pData = PDMINS_2_DATA(pDevIns, PITState *);
+    PITState   *pThis = PDMINS_2_DATA(pDevIns, PITState *);
     int         rc;
     uint8_t     u8Irq;
@@ -970 +970 @@
                                 N_("Configuration error: failed to read R0Enabled as boolean"));
 
-    pData->pDevIns = pDevIns;
-    pData->channels[0].irq = u8Irq;
-    for (i = 0; i < RT_ELEMENTS(pData->channels); i++)
-    {
-        pData->channels[i].pPitR3 = pData;
-        pData->channels[i].pPitR0 = PDMINS_2_DATA_R0PTR(pDevIns);
-        pData->channels[i].pPitRC = PDMINS_2_DATA_RCPTR(pDevIns);
+    pThis->pDevIns = pDevIns;
+    pThis->channels[0].irq = u8Irq;
+    for (i = 0; i < RT_ELEMENTS(pThis->channels); i++)
+    {
+        pThis->channels[i].pPitR3 = pThis;
+        pThis->channels[i].pPitR0 = PDMINS_2_DATA_R0PTR(pDevIns);
+        pThis->channels[i].pPitRC = PDMINS_2_DATA_RCPTR(pDevIns);
     }
 
@@ -983 +983 @@
      */
     rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, pitTimer, "i8254 Programmable Interval Timer",
-                                &pData->channels[0].pTimerR3);
+                                &pThis->channels[0].pTimerR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->channels[0].pTimerRC = TMTimerRCPtr(pData->channels[0].pTimerR3);
-    pData->channels[0].pTimerR0 = TMTimerR0Ptr(pData->channels[0].pTimerR3);
+    pThis->channels[0].pTimerRC = TMTimerRCPtr(pThis->channels[0].pTimerR3);
+    pThis->channels[0].pTimerR0 = TMTimerR0Ptr(pThis->channels[0].pTimerR3);
 
     rc = PDMDevHlpIOPortRegister(pDevIns, u16Base, 4, NULL, pitIOPortWrite, pitIOPortRead, NULL, NULL, "i8254 Programmable Interval Timer");
@@ -1018 +1018 @@
     }
 
-    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, PIT_SAVED_STATE_VERSION, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, PIT_SAVED_STATE_VERSION, sizeof(*pThis),
                                           NULL, pitSaveExec, NULL,
                                           NULL, pitLoadExec, NULL);
@@ -1032 +1032 @@
      * Register statistics and debug info.
      */
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatPITIrq,      STAMTYPE_COUNTER, "/TM/PIT/Irq",      STAMUNIT_OCCURENCES,     "The number of times a timer interrupt was triggered.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatPITHandler,  STAMTYPE_PROFILE, "/TM/PIT/Handler",  STAMUNIT_TICKS_PER_CALL, "Profiling timer callback handler.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatPITIrq,      STAMTYPE_COUNTER, "/TM/PIT/Irq",      STAMUNIT_OCCURENCES,     "The number of times a timer interrupt was triggered.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatPITHandler,  STAMTYPE_PROFILE, "/TM/PIT/Handler",  STAMUNIT_TICKS_PER_CALL, "Profiling timer callback handler.");
 
     PDMDevHlpDBGFInfoRegister(pDevIns, "pit", "Display PIT (i8254) status. (no arguments)", pitInfo);

trunk/src/VBox/Devices/PC/DevRTC.cpp

@@ -673 +673 @@
  * Calculate and update the standard CMOS checksum.
  *
- * @param   pData       Pointer to the RTC state data.
- */
-static void rtcCalcCRC(RTCState *pData)
+ * @param   pThis       Pointer to the RTC state data.
+ */
+static void rtcCalcCRC(RTCState *pThis)
 {
     uint16_t u16;
@@ -681 +681 @@
 
     for (i = RTC_CRC_START, u16 = 0; i <= RTC_CRC_LAST; i++)
-        u16 += pData->cmos_data[i];
-    pData->cmos_data[RTC_CRC_LOW] = u16 & 0xff;
-    pData->cmos_data[RTC_CRC_HIGH] = (u16 >> 8) & 0xff;
+        u16 += pThis->cmos_data[i];
+    pThis->cmos_data[RTC_CRC_LOW] = u16 & 0xff;
+    pThis->cmos_data[RTC_CRC_HIGH] = (u16 >> 8) & 0xff;
 }
 
@@ -697 +697 @@
 static DECLCALLBACK(int) rtcCMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
 {
-    RTCState *pData = PDMINS_2_DATA(pDevIns, RTCState *);
-    if (iReg < RT_ELEMENTS(pData->cmos_data))
+    RTCState *pThis = PDMINS_2_DATA(pDevIns, RTCState *);
+    if (iReg < RT_ELEMENTS(pThis->cmos_data))
     {
-        pData->cmos_data[iReg] = u8Value;
+        pThis->cmos_data[iReg] = u8Value;
 
         /* does it require checksum update? */
         if (    iReg >= RTC_CRC_START
             &&  iReg <= RTC_CRC_LAST)
-            rtcCalcCRC(pData);
+            rtcCalcCRC(pThis);
 
         return VINF_SUCCESS;
@@ -724 +724 @@
 static DECLCALLBACK(int) rtcCMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
 {
-    RTCState   *pData = PDMINS_2_DATA(pDevIns, RTCState *);
-    if (iReg < RT_ELEMENTS(pData->cmos_data))
+    RTCState   *pThis = PDMINS_2_DATA(pDevIns, RTCState *);
+    if (iReg < RT_ELEMENTS(pThis->cmos_data))
     {
-        *pu8Value = pData->cmos_data[iReg];
+        *pu8Value = pThis->cmos_data[iReg];
         return VINF_SUCCESS;
     }
@@ -741 +741 @@
 {
     /** @todo this should be (re)done at power on if we didn't load a state... */
-    RTCState   *pData = PDMINS_2_DATA(pDevIns, RTCState *);
+    RTCState   *pThis = PDMINS_2_DATA(pDevIns, RTCState *);
 
     /*
@@ -749 +749 @@
     PDMDevHlpUTCNow(pDevIns, &Now);
     RTTIME Time;
-    if (pData->fUTC)
+    if (pThis->fUTC)
         RTTimeExplode(&Time, &Now);
     else
@@ -765 +765 @@
     Tm.tm_sec  = Time.u8Second;
 
-    rtc_set_date(pData, &Tm);
-
-    int iYear = to_bcd(pData, (Tm.tm_year / 100) + 19); /* tm_year is 1900 based */
-    rtc_set_memory(pData, 0x32, iYear);                                     /* 32h - Century Byte (BCD value for the century */
-    rtc_set_memory(pData, 0x37, iYear);                                     /* 37h - (IBM PS/2) Date Century Byte */
+    rtc_set_date(pThis, &Tm);
+
+    int iYear = to_bcd(pThis, (Tm.tm_year / 100) + 19); /* tm_year is 1900 based */
+    rtc_set_memory(pThis, 0x32, iYear);                                     /* 32h - Century Byte (BCD value for the century */
+    rtc_set_memory(pThis, 0x37, iYear);                                     /* 37h - (IBM PS/2) Date Century Byte */
 
     /*
      * Recalculate the checksum just in case.
      */
-    rtcCalcCRC(pData);
-
-    Log(("CMOS: \n%16.128Vhxd\n", pData->cmos_data));
+    rtcCalcCRC(pThis);
+
+    Log(("CMOS: \n%16.128Vhxd\n", pThis->cmos_data));
     return VINF_SUCCESS;
 }
@@ -812 +812 @@
 static DECLCALLBACK(int)  rtcConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    RTCState   *pData = PDMINS_2_DATA(pDevIns, RTCState *);
+    RTCState   *pThis = PDMINS_2_DATA(pDevIns, RTCState *);
     int         rc;
     uint8_t     u8Irq;
@@ -852 +852 @@
 
 
-    pData->pDevInsR3            = pDevIns;
-    pData->pDevInsR0            = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC            = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->irq                  = u8Irq;
-    pData->cmos_data[RTC_REG_A] = 0x26;
-    pData->cmos_data[RTC_REG_B] = 0x02;
-    pData->cmos_data[RTC_REG_C] = 0x00;
-    pData->cmos_data[RTC_REG_D] = 0x80;
-    pData->RtcReg.u32Version    = PDM_RTCREG_VERSION;
-    pData->RtcReg.pfnRead       = rtcCMOSRead;
-    pData->RtcReg.pfnWrite      = rtcCMOSWrite;
+    pThis->pDevInsR3            = pDevIns;
+    pThis->pDevInsR0            = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC            = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->irq                  = u8Irq;
+    pThis->cmos_data[RTC_REG_A] = 0x26;
+    pThis->cmos_data[RTC_REG_B] = 0x02;
+    pThis->cmos_data[RTC_REG_C] = 0x00;
+    pThis->cmos_data[RTC_REG_D] = 0x80;
+    pThis->RtcReg.u32Version    = PDM_RTCREG_VERSION;
+    pThis->RtcReg.pfnRead       = rtcCMOSRead;
+    pThis->RtcReg.pfnWrite      = rtcCMOSWrite;
 
     /*
      * Create timers, arm them, register I/O Ports and save state.
      */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerPeriodic, "MC146818 RTC/CMOS - Periodic", &pData->pPeriodicTimerR3);
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerPeriodic, "MC146818 RTC/CMOS - Periodic", &pThis->pPeriodicTimerR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pPeriodicTimerR0 = TMTimerR0Ptr(pData->pPeriodicTimerR3);
-    pData->pPeriodicTimerRC = TMTimerRCPtr(pData->pPeriodicTimerR3);
-
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond,   "MC146818 RTC/CMOS - Second", &pData->pSecondTimerR3);
+    pThis->pPeriodicTimerR0 = TMTimerR0Ptr(pThis->pPeriodicTimerR3);
+    pThis->pPeriodicTimerRC = TMTimerRCPtr(pThis->pPeriodicTimerR3);
+
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond,   "MC146818 RTC/CMOS - Second", &pThis->pSecondTimerR3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pSecondTimerR0 = TMTimerR0Ptr(pData->pSecondTimerR3);
-    pData->pSecondTimerRC = TMTimerRCPtr(pData->pSecondTimerR3);
-
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond2,  "MC146818 RTC/CMOS - Second2", &pData->pSecondTimer2R3);
+    pThis->pSecondTimerR0 = TMTimerR0Ptr(pThis->pSecondTimerR3);
+    pThis->pSecondTimerRC = TMTimerRCPtr(pThis->pSecondTimerR3);
+
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, rtcTimerSecond2,  "MC146818 RTC/CMOS - Second2", &pThis->pSecondTimer2R3);
     if (RT_FAILURE(rc))
         return rc;
-    pData->pSecondTimer2R0 = TMTimerR0Ptr(pData->pSecondTimer2R3);
-    pData->pSecondTimer2RC = TMTimerRCPtr(pData->pSecondTimer2R3);
-    pData->next_second_time = TMTimerGet(pData->CTX_SUFF(pSecondTimer2)) + (TMTimerGetFreq(pData->CTX_SUFF(pSecondTimer2)) * 99) / 100;
-    rc = TMTimerSet(pData->CTX_SUFF(pSecondTimer2), pData->next_second_time);
+    pThis->pSecondTimer2R0 = TMTimerR0Ptr(pThis->pSecondTimer2R3);
+    pThis->pSecondTimer2RC = TMTimerRCPtr(pThis->pSecondTimer2R3);
+    pThis->next_second_time = TMTimerGet(pThis->CTX_SUFF(pSecondTimer2)) + (TMTimerGetFreq(pThis->CTX_SUFF(pSecondTimer2)) * 99) / 100;
+    rc = TMTimerSet(pThis->CTX_SUFF(pSecondTimer2), pThis->next_second_time);
     if (RT_FAILURE(rc))
         return rc;
@@ -905 +905 @@
     }
 
-    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pThis),
                               NULL, rtcSaveExec, NULL,
                               NULL, rtcLoadExec, NULL);
@@ -914 +914 @@
      * Register ourselves as the RTC/CMOS with PDM.
      */
-    rc = pDevIns->pDevHlp->pfnRTCRegister(pDevIns, &pData->RtcReg, &pData->pRtcHlpR3);
+    rc = pDevIns->pDevHlp->pfnRTCRegister(pDevIns, &pThis->RtcReg, &pThis->pRtcHlpR3);
     if (RT_FAILURE(rc))
         return rc;

trunk/src/VBox/Devices/PC/DrvACPI.cpp

@@ -73 +73 @@
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVACPI pData = PDMINS_2_DATA(pDrvIns, PDRVACPI);
+    PDRVACPI pThis = PDMINS_2_DATA(pDrvIns, PDRVACPI);
     switch (enmInterface)
     {
@@ -79 +79 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_ACPI_CONNECTOR:
-            return &pData->IACPIConnector;
+            return &pThis->IACPIConnector;
         default:
             return NULL;
@@ -442 +442 @@
 static DECLCALLBACK(int) drvACPIConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVACPI pData = PDMINS_2_DATA(pDrvIns, PDRVACPI);
+    PDRVACPI pThis = PDMINS_2_DATA(pDrvIns, PDRVACPI);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                              = pDrvIns;
+    pThis->pDrvIns                              = pDrvIns;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface            = drvACPIQueryInterface;
     /* IACPIConnector */
-    pData->IACPIConnector.pfnQueryPowerSource   = drvACPIQueryPowerSource;
-    pData->IACPIConnector.pfnQueryBatteryStatus = drvACPIQueryBatteryStatus;
+    pThis->IACPIConnector.pfnQueryPowerSource   = drvACPIQueryPowerSource;
+    pThis->IACPIConnector.pfnQueryBatteryStatus = drvACPIQueryBatteryStatus;
 
     /*
@@ -473 +473 @@
      * Query the ACPI port interface.
      */
-    pData->pPort = (PPDMIACPIPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase,
+    pThis->pPort = (PPDMIACPIPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase,
                                                                       PDMINTERFACE_ACPI_PORT);
-    if (!pData->pPort)
+    if (!pThis->pPort)
     {
         AssertMsgFailed(("Configuration error: "

trunk/src/VBox/Devices/Parallel/DevParallel.cpp

@@ -402 +402 @@
 static DECLCALLBACK(int) parallelNotifyInterrupt(PPDMIHOSTPARALLELPORT pInterface)
 {
-    ParallelState *pData = PDMIHOSTPARALLELPORT_2_PARALLELSTATE(pInterface);
-
-    PDMCritSectEnter(&pData->CritSect, VINF_SUCCESS);
-    parallel_set_irq(pData);
-    PDMCritSectLeave(&pData->CritSect);
+    ParallelState *pThis = PDMIHOSTPARALLELPORT_2_PARALLELSTATE(pInterface);
+
+    PDMCritSectEnter(&pThis->CritSect, VINF_SUCCESS);
+    parallel_set_irq(pThis);
+    PDMCritSectLeave(&pThis->CritSect);
 
     return VINF_SUCCESS;
@@ -426 +426 @@
                                        RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
         if (rc == VINF_SUCCESS)
         {
             Log2(("%s: port %#06x val %#04x\n", __FUNCTION__, Port, u32));
-            rc = parallel_ioport_write (pData, Port, u32);
-            PDMCritSectLeave(&pData->CritSect);
+            rc = parallel_ioport_write (pThis, Port, u32);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -459 +459 @@
                                       RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_READ);
         if (rc == VINF_SUCCESS)
         {
-            *pu32 = parallel_ioport_read (pData, Port, &rc);
+            *pu32 = parallel_ioport_read (pThis, Port, &rc);
             Log2(("%s: port %#06x val %#04x\n", __FUNCTION__, Port, *pu32));
-            PDMCritSectLeave(&pData->CritSect);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -493 +493 @@
                                           RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
         if (rc == VINF_SUCCESS)
         {
             Log2(("%s: ecp port %#06x val %#04x\n", __FUNCTION__, Port, u32));
-            rc = parallel_ioport_write_ecp (pData, Port, u32);
-            PDMCritSectLeave(&pData->CritSect);
+            rc = parallel_ioport_write_ecp (pThis, Port, u32);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -526 +526 @@
                                          RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_READ);
         if (rc == VINF_SUCCESS)
         {
-            *pu32 = parallel_ioport_read_ecp (pData, Port, &rc);
+            *pu32 = parallel_ioport_read_ecp (pThis, Port, &rc);
             Log2(("%s: ecp port %#06x val %#04x\n", __FUNCTION__, Port, *pu32));
-            PDMCritSectLeave(&pData->CritSect);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -557 +557 @@
                                           PSSMHANDLE pSSMHandle)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
-
-    SSMR3PutU8(pSSMHandle, pData->reg_data);
-    SSMR3PutU8(pSSMHandle, pData->reg_status);
-    SSMR3PutU8(pSSMHandle, pData->reg_control);
-    SSMR3PutS32(pSSMHandle, pData->irq);
-    SSMR3PutU32(pSSMHandle, pData->base);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
+
+    SSMR3PutU8(pSSMHandle, pThis->reg_data);
+    SSMR3PutU8(pSSMHandle, pThis->reg_status);
+    SSMR3PutU8(pSSMHandle, pThis->reg_control);
+    SSMR3PutS32(pSSMHandle, pThis->irq);
+    SSMR3PutU32(pSSMHandle, pThis->base);
 
     return SSMR3PutU32(pSSMHandle, ~0); /* sanity/terminator */
@@ -582 +582 @@
     int          rc;
     uint32_t     u32;
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
 
     if (u32Version != PARALLEL_SAVED_STATE_VERSION)
@@ -590 +590 @@
     }
 
-    SSMR3GetU8(pSSMHandle, &pData->reg_data);
-    SSMR3GetU8(pSSMHandle, &pData->reg_status);
-    SSMR3GetU8(pSSMHandle, &pData->reg_control);
-    SSMR3GetS32(pSSMHandle, &pData->irq);
-    SSMR3GetU32(pSSMHandle, &pData->base);
+    SSMR3GetU8(pSSMHandle, &pThis->reg_data);
+    SSMR3GetU8(pSSMHandle, &pThis->reg_status);
+    SSMR3GetU8(pSSMHandle, &pThis->reg_control);
+    SSMR3GetS32(pSSMHandle, &pThis->irq);
+    SSMR3GetU32(pSSMHandle, &pThis->base);
 
     rc = SSMR3GetU32(pSSMHandle, &u32);
@@ -606 +606 @@
     }
 
-    pData->pDevInsHC = pDevIns;
-    pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+    pThis->pDevInsHC = pDevIns;
+    pThis->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
     return VINF_SUCCESS;
 }
@@ -617 +617 @@
 static DECLCALLBACK(void) parallelRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
-    pData->pDevInsGC     += offDelta;
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
+    pThis->pDevInsGC     += offDelta;
 }
 
@@ -624 +624 @@
 static DECLCALLBACK(void *) parallelQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    ParallelState *pData = PDMIBASE_2_PARALLELSTATE(pInterface);
+    ParallelState *pThis = PDMIBASE_2_PARALLELSTATE(pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         case PDMINTERFACE_HOST_PARALLEL_PORT:
-            return &pData->IHostParallelPort;
+            return &pThis->IHostParallelPort;
         default:
             return NULL;
@@ -647 +647 @@
 static DECLCALLBACK(int) parallelDestruct(PPDMDEVINS pDevIns)
 {
-    ParallelState *pData = PDMINS_2_DATA(pDevIns, ParallelState *);
-
-    PDMR3CritSectDelete(&pData->CritSect);
-    RTSemEventDestroy(pData->ReceiveSem);
+    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
+
+    PDMR3CritSectDelete(&pThis->CritSect);
+    RTSemEventDestroy(pThis->ReceiveSem);
 
     return VINF_SUCCESS;
@@ -674 +674 @@
 {
     int            rc;
-    ParallelState  *pData = PDMINS_2_DATA(pDevIns, ParallelState*);
+    ParallelState  *pThis = PDMINS_2_DATA(pDevIns, ParallelState*);
     uint16_t       io_base;
     uint8_t        irq_lvl;
@@ -680 +680 @@
     Assert(iInstance < 4);
 
-    pData->pDevInsHC = pDevIns;
-    pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+    pThis->pDevInsHC = pDevIns;
+    pThis->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
 
     /*
@@ -690 +690 @@
                                 N_("Configuration error: Unknown config key"));
 
-    rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &pData->fGCEnabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &pThis->fGCEnabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fGCEnabled = true;
+        pThis->fGCEnabled = true;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"GCEnabled\" value"));
 
-    rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &pData->fR0Enabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &pThis->fR0Enabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fR0Enabled = true;
+        pThis->fR0Enabled = true;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -705 +705 @@
 
     /* IBase */
-    pData->IBase.pfnQueryInterface = parallelQueryInterface;
+    pThis->IBase.pfnQueryInterface = parallelQueryInterface;
 
     /* IHostParallelPort */
-    pData->IHostParallelPort.pfnNotifyInterrupt = parallelNotifyInterrupt;
-
-    rc = RTSemEventCreate(&pData->ReceiveSem);
+    pThis->IHostParallelPort.pfnNotifyInterrupt = parallelNotifyInterrupt;
+
+    rc = RTSemEventCreate(&pThis->ReceiveSem);
     AssertRC(rc);
 
@@ -719 +719 @@
     char szName[24];
     RTStrPrintf(szName, sizeof(szName), "Parallel#%d", iInstance);
-    rc = PDMDevHlpCritSectInit(pDevIns, &pData->CritSect, szName);
+    rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, szName);
     if (RT_FAILURE(rc))
         return rc;
@@ -739 +739 @@
     Log(("parallelConstruct instance %d iobase=%04x irq=%d\n", iInstance, io_base, irq_lvl));
 
-    pData->irq = irq_lvl;
-    pData->base = io_base;
+    pThis->irq = irq_lvl;
+    pThis->base = io_base;
 
     /* Init parallel state */
-    pData->reg_data = 0;
-    pData->reg_ecp_ecr = LPT_ECP_ECR_CHIPMODE_COMPAT | LPT_ECP_ECR_FIFO_EMPTY;
-    pData->act_fifo_pos_read = 0;
-    pData->act_fifo_pos_write = 0;
+    pThis->reg_data = 0;
+    pThis->reg_ecp_ecr = LPT_ECP_ECR_CHIPMODE_COMPAT | LPT_ECP_ECR_FIFO_EMPTY;
+    pThis->act_fifo_pos_read = 0;
+    pThis->act_fifo_pos_write = 0;
 
     rc = PDMDevHlpIOPortRegister(pDevIns, io_base, 8, 0,
@@ -763 +763 @@
 #endif
 
-    if (pData->fGCEnabled)
+    if (pThis->fGCEnabled)
     {
         rc = PDMDevHlpIOPortRegisterGC(pDevIns, io_base, 8, 0, "parallelIOPortWrite",
@@ -778 +778 @@
     }
 
-    if (pData->fR0Enabled)
+    if (pThis->fR0Enabled)
     {
         rc = PDMDevHlpIOPortRegisterR0(pDevIns, io_base, 8, 0, "parallelIOPortWrite",
@@ -795 +795 @@
     /* Attach the parallel port driver and get the interfaces. For now no run-time
      * changes are supported. */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pData->IBase, &pData->pDrvBase, "Parallel Host");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Parallel Host");
     if (RT_SUCCESS(rc))
     {
-        pData->pDrvHostParallelConnector = (PDMIHOSTPARALLELCONNECTOR *)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase,
+        pThis->pDrvHostParallelConnector = (PDMIHOSTPARALLELCONNECTOR *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase,
                                                                                                            PDMINTERFACE_HOST_PARALLEL_CONNECTOR);
-        if (!pData->pDrvHostParallelConnector)
+        if (!pThis->pDrvHostParallelConnector)
         {
             AssertMsgFailed(("Configuration error: instance %d has no host parallel interface!\n", iInstance));
@@ -809 +809 @@
     else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
     {
-        pData->pDrvBase = NULL;
-        pData->pDrvHostParallelConnector = NULL;
+        pThis->pDrvBase = NULL;
+        pThis->pDrvHostParallelConnector = NULL;
         LogRel(("Parallel%d: no unit\n", iInstance));
     }
@@ -821 +821 @@
 
     /* Set compatibility mode */
-    pData->pDrvHostParallelConnector->pfnSetMode(pData->pDrvHostParallelConnector, PDM_PARALLEL_PORT_MODE_COMPAT);
+    pThis->pDrvHostParallelConnector->pfnSetMode(pThis->pDrvHostParallelConnector, PDM_PARALLEL_PORT_MODE_COMPAT);
     /* Get status of control register */
-    pData->pDrvHostParallelConnector->pfnReadControl(pData->pDrvHostParallelConnector, &pData->reg_control);
+    pThis->pDrvHostParallelConnector->pfnReadControl(pThis->pDrvHostParallelConnector, &pThis->reg_control);
 
     rc = PDMDevHlpSSMRegister(
@@ -830 +830 @@
         iInstance,                      /* u32Instance */
         PARALLEL_SAVED_STATE_VERSION,   /* u32Version */
-        sizeof (*pData),                /* cbGuess */
+        sizeof (*pThis),                /* cbGuess */
         NULL,                           /* pfnSavePrep */
         parallelSaveExec,               /* pfnSaveExec */

trunk/src/VBox/Devices/Parallel/DrvHostParallel.cpp

@@ -94 +94 @@
 {
     PPDMDRVINS  pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVHOSTPARALLEL    pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
+    PDRVHOSTPARALLEL    pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
     switch (enmInterface)
     {
@@ -100 +100 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_HOST_PARALLEL_CONNECTOR:
-            return &pData->IHostParallelConnector;
+            return &pThis->IHostParallelConnector;
         default:
             return NULL;
@@ -111 +111 @@
 static DECLCALLBACK(int) drvHostParallelWrite(PPDMIHOSTPARALLELCONNECTOR pInterface, const void *pvBuf, size_t *cbWrite)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
     const unsigned char *pBuffer = (const unsigned char *)pvBuf;
 
     LogFlow(("%s: pvBuf=%#p cbWrite=%d\n", __FUNCTION__, pvBuf, *cbWrite));
 
-    ioctl(pData->FileDevice, PPWDATA, pBuffer);
+    ioctl(pThis->FileDevice, PPWDATA, pBuffer);
     *cbWrite = 1;
 
@@ -124 +124 @@
 static DECLCALLBACK(int) drvHostParallelRead(PPDMIHOSTPARALLELCONNECTOR pInterface, void *pvBuf, size_t *cbRead)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
     unsigned char *pBuffer = (unsigned char *)pvBuf;
 
     LogFlow(("%s: pvBuf=%#p cbRead=%d\n", __FUNCTION__, pvBuf, cbRead));
 
-    ioctl(pData->FileDevice, PPRDATA, pBuffer);
+    ioctl(pThis->FileDevice, PPRDATA, pBuffer);
     *cbRead = 1;
 
@@ -137 +137 @@
 static DECLCALLBACK(int) drvHostParallelSetMode(PPDMIHOSTPARALLELCONNECTOR pInterface, PDMPARALLELPORTMODE enmMode)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
     int ppdev_mode;
 
@@ -154 +154 @@
     }
 
-    ioctl(pData->FileDevice, PPSETMODE, &ppdev_mode);
+    ioctl(pThis->FileDevice, PPSETMODE, &ppdev_mode);
 
     return VINF_SUCCESS;
@@ -161 +161 @@
 static DECLCALLBACK(int) drvHostParallelWriteControl(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t fReg)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
 
     LogFlow(("%s: fReg=%d\n", __FUNCTION__, fReg));
 
-    ioctl(pData->FileDevice, PPWCONTROL, &fReg);
+    ioctl(pThis->FileDevice, PPWCONTROL, &fReg);
 
     return VINF_SUCCESS;
@@ -172 +172 @@
 static DECLCALLBACK(int) drvHostParallelReadControl(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
     uint8_t fReg;
 
-    ioctl(pData->FileDevice, PPRCONTROL, &fReg);
+    ioctl(pThis->FileDevice, PPRCONTROL, &fReg);
 
     LogFlow(("%s: fReg=%d\n", __FUNCTION__, fReg));
@@ -186 +186 @@
 static DECLCALLBACK(int) drvHostParallelReadStatus(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg)
 {
-    PDRVHOSTPARALLEL pData = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
+    PDRVHOSTPARALLEL pThis = PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface);
     uint8_t fReg;
 
-    ioctl(pData->FileDevice, PPRSTATUS, &fReg);
+    ioctl(pThis->FileDevice, PPRSTATUS, &fReg);
 
     LogFlow(("%s: fReg=%d\n", __FUNCTION__, fReg));
@@ -200 +200 @@
 static DECLCALLBACK(int) drvHostParallelMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTPARALLEL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
+    PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
     struct pollfd aFDs[2];
 
@@ -210 +210 @@
         int rc;
 
-        aFDs[0].fd      = pData->FileDevice;
+        aFDs[0].fd      = pThis->FileDevice;
         aFDs[0].events  = POLLIN;
         aFDs[0].revents = 0;
-        aFDs[1].fd      = pData->WakeupPipeR;
+        aFDs[1].fd      = pThis->WakeupPipeR;
         aFDs[1].events  = POLLIN | POLLERR | POLLHUP;
         aFDs[1].revents = 0;
@@ -232 +232 @@
             char ch;
             size_t cbRead;
-            RTFileRead(pData->WakeupPipeR, &ch, 1, &cbRead);
+            RTFileRead(pThis->WakeupPipeR, &ch, 1, &cbRead);
             continue;
         }
 
         /* Interrupt occured. */
-        rc = pData->pDrvHostParallelPort->pfnNotifyInterrupt(pData->pDrvHostParallelPort);
+        rc = pThis->pDrvHostParallelPort->pfnNotifyInterrupt(pThis->pDrvHostParallelPort);
         AssertRC(rc);
     }
@@ -253 +253 @@
 static DECLCALLBACK(int) drvHostParallelWakeupMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTPARALLEL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
-
-    return RTFileWrite(pData->WakeupPipeW, "", 1, NULL);
+    PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
+
+    return RTFileWrite(pThis->WakeupPipeW, "", 1, NULL);
 }
 
@@ -272 +272 @@
 static DECLCALLBACK(int) drvHostParallelConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVHOSTPARALLEL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
+    PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
@@ -289 +289 @@
     pDrvIns->IBase.pfnQueryInterface               = drvHostParallelQueryInterface;
     /* IHostParallelConnector. */
-    pData->IHostParallelConnector.pfnWrite         = drvHostParallelWrite;
-    pData->IHostParallelConnector.pfnRead          = drvHostParallelRead;
-    pData->IHostParallelConnector.pfnSetMode       = drvHostParallelSetMode;
-    pData->IHostParallelConnector.pfnWriteControl  = drvHostParallelWriteControl;
-    pData->IHostParallelConnector.pfnReadControl   = drvHostParallelReadControl;
-    pData->IHostParallelConnector.pfnReadStatus    = drvHostParallelReadStatus;
+    pThis->IHostParallelConnector.pfnWrite         = drvHostParallelWrite;
+    pThis->IHostParallelConnector.pfnRead          = drvHostParallelRead;
+    pThis->IHostParallelConnector.pfnSetMode       = drvHostParallelSetMode;
+    pThis->IHostParallelConnector.pfnWriteControl  = drvHostParallelWriteControl;
+    pThis->IHostParallelConnector.pfnReadControl   = drvHostParallelReadControl;
+    pThis->IHostParallelConnector.pfnReadStatus    = drvHostParallelReadStatus;
 
     /*
@@ -300 +300 @@
      */
     /* Device */
-    int rc = CFGMR3QueryStringAlloc(pCfgHandle, "DevicePath", &pData->pszDevicePath);
+    int rc = CFGMR3QueryStringAlloc(pCfgHandle, "DevicePath", &pThis->pszDevicePath);
     if (RT_FAILURE(rc))
     {
@@ -310 +310 @@
      * Open the device
      */
-    rc = RTFileOpen(&pData->FileDevice, pData->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
+    rc = RTFileOpen(&pThis->FileDevice, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Parallel#%d could not open '%s'"),
-                                   pDrvIns->iInstance, pData->pszDevicePath);
+                                   pDrvIns->iInstance, pThis->pszDevicePath);
 
     /*
      * Try to get exclusive access to parallel port
      */
-    rc = ioctl(pData->FileDevice, PPEXCL);
+    rc = ioctl(pThis->FileDevice, PPEXCL);
     if (rc < 0)
         return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
                                    N_("Parallel#%d could not get exclusive access for parallel port '%s'"
                                       "Be sure that no other process or driver accesses this port"),
-                                   pDrvIns->iInstance, pData->pszDevicePath);
+                                   pDrvIns->iInstance, pThis->pszDevicePath);
 
     /*
      * Claim the parallel port
      */
-    rc = ioctl(pData->FileDevice, PPCLAIM);
+    rc = ioctl(pThis->FileDevice, PPCLAIM);
     if (rc < 0)
         return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
                                    N_("Parallel#%d could not claim parallel port '%s'"
                                       "Be sure that no other process or driver accesses this port"),
-                                   pDrvIns->iInstance, pData->pszDevicePath);
+                                   pDrvIns->iInstance, pThis->pszDevicePath);
 
     /*
      * Get the IHostParallelPort interface of the above driver/device.
      */
-    pData->pDrvHostParallelPort = (PPDMIHOSTPARALLELPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_HOST_PARALLEL_PORT);
-    if (!pData->pDrvHostParallelPort)
+    pThis->pDrvHostParallelPort = (PPDMIHOSTPARALLELPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_HOST_PARALLEL_PORT);
+    if (!pThis->pDrvHostParallelPort)
         return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("Parallel#%d has no parallel port interface above"),
                                    pDrvIns->iInstance);
@@ -353 +353 @@
         return rc;
     }
-    pData->WakeupPipeR = aFDs[0];
-    pData->WakeupPipeW = aFDs[1];
+    pThis->WakeupPipeR = aFDs[0];
+    pThis->WakeupPipeW = aFDs[1];
 
     /*
      * Start waiting for interrupts.
      */
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pMonitorThread, pData, drvHostParallelMonitorThread, drvHostParallelWakeupMonitorThread, 0,
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pMonitorThread, pThis, drvHostParallelMonitorThread, drvHostParallelWakeupMonitorThread, 0,
                                   RTTHREADTYPE_IO, "ParMon");
     if (RT_FAILURE(rc))
@@ -378 +378 @@
 static DECLCALLBACK(void) drvHostParallelDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVHOSTPARALLEL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
+    PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
 
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
-    ioctl(pData->FileDevice, PPRELEASE);
-
-    if (pData->WakeupPipeW != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->WakeupPipeW);
+    ioctl(pThis->FileDevice, PPRELEASE);
+
+    if (pThis->WakeupPipeW != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->WakeupPipeW);
         AssertRC(rc);
-        pData->WakeupPipeW = NIL_RTFILE;
-    }
-    if (pData->WakeupPipeR != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->WakeupPipeR);
+        pThis->WakeupPipeW = NIL_RTFILE;
+    }
+    if (pThis->WakeupPipeR != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->WakeupPipeR);
         AssertRC(rc);
-        pData->WakeupPipeR = NIL_RTFILE;
-    }
-    if (pData->FileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pData->FileDevice);
+        pThis->WakeupPipeR = NIL_RTFILE;
+    }
+    if (pThis->FileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->FileDevice);
         AssertRC(rc);
-        pData->FileDevice = NIL_RTFILE;
+        pThis->FileDevice = NIL_RTFILE;
     }
 }

trunk/src/VBox/Devices/Serial/DevSerial.cpp

@@ -400 +400 @@
 static DECLCALLBACK(int) serialNotifyRead(PPDMICHARPORT pInterface, const void *pvBuf, size_t *pcbRead)
 {
-    SerialState *pData = PDMICHARPORT_2_SERIALSTATE(pInterface);
+    SerialState *pThis = PDMICHARPORT_2_SERIALSTATE(pInterface);
     int rc;
 
     Assert(*pcbRead != 0);
 
-    PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
-    if (pData->lsr & UART_LSR_DR)
+    PDMCritSectEnter(&pThis->CritSect, VERR_PERMISSION_DENIED);
+    if (pThis->lsr & UART_LSR_DR)
     {
         /* If a character is still in the read queue, then wait for it to be emptied. */
-        PDMCritSectLeave(&pData->CritSect);
-        rc = RTSemEventWait(pData->ReceiveSem, 250);
+        PDMCritSectLeave(&pThis->CritSect);
+        rc = RTSemEventWait(pThis->ReceiveSem, 250);
         if (RT_FAILURE(rc))
             return rc;
 
-        PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
-    }
-
-    if (!(pData->lsr & UART_LSR_DR))
-    {
-        pData->rbr = *(const char *)pvBuf;
-        pData->lsr |= UART_LSR_DR;
-        serial_update_irq(pData);
+        PDMCritSectEnter(&pThis->CritSect, VERR_PERMISSION_DENIED);
+    }
+
+    if (!(pThis->lsr & UART_LSR_DR))
+    {
+        pThis->rbr = *(const char *)pvBuf;
+        pThis->lsr |= UART_LSR_DR;
+        serial_update_irq(pThis);
         *pcbRead = 1;
         rc = VINF_SUCCESS;
@@ -428 +428 @@
         rc = VERR_TIMEOUT;
 
-    PDMCritSectLeave(&pData->CritSect);
+    PDMCritSectLeave(&pThis->CritSect);
 
     return rc;
@@ -435 +435 @@
 static DECLCALLBACK(int) serialNotifyStatusLinesChanged(PPDMICHARPORT pInterface, uint32_t newStatusLines)
 {
-    SerialState *pData = PDMICHARPORT_2_SERIALSTATE(pInterface);
+    SerialState *pThis = PDMICHARPORT_2_SERIALSTATE(pInterface);
     uint8_t newMsr = 0;
 
     Log(("%s: pInterface=%p newStatusLines=%u\n", __FUNCTION__, pInterface, newStatusLines));
 
-    PDMCritSectEnter(&pData->CritSect, VERR_PERMISSION_DENIED);
+    PDMCritSectEnter(&pThis->CritSect, VERR_PERMISSION_DENIED);
 
     /* Set new states. */
@@ -453 +453 @@
 
     /* Compare the old and the new states and set the delta bits accordingly. */
-    if ((newMsr & UART_MSR_DCD) != (pData->msr & UART_MSR_DCD))
+    if ((newMsr & UART_MSR_DCD) != (pThis->msr & UART_MSR_DCD))
         newMsr |= UART_MSR_DDCD;
-    if ((newMsr & UART_MSR_RI) == 1 && (pData->msr & UART_MSR_RI) == 0)
+    if ((newMsr & UART_MSR_RI) == 1 && (pThis->msr & UART_MSR_RI) == 0)
         newMsr |= UART_MSR_TERI;
-    if ((newMsr & UART_MSR_DSR) != (pData->msr & UART_MSR_DSR))
+    if ((newMsr & UART_MSR_DSR) != (pThis->msr & UART_MSR_DSR))
         newMsr |= UART_MSR_DDSR;
-    if ((newMsr & UART_MSR_CTS) != (pData->msr & UART_MSR_CTS))
+    if ((newMsr & UART_MSR_CTS) != (pThis->msr & UART_MSR_CTS))
         newMsr |= UART_MSR_DCTS;
 
-    pData->msr = newMsr;
-    pData->msr_changed = true;
-    serial_update_irq(pData);
-
-    PDMCritSectLeave(&pData->CritSect);
+    pThis->msr = newMsr;
+    pThis->msr_changed = true;
+    serial_update_irq(pThis);
+
+    PDMCritSectLeave(&pThis->CritSect);
 
     return VINF_SUCCESS;
@@ -487 +487 @@
                                      RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_WRITE);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_WRITE);
         if (rc == VINF_SUCCESS)
         {
             Log2(("%s: port %#06x val %#04x\n", __FUNCTION__, Port, u32));
-            rc = serial_ioport_write (pData, Port, u32);
-            PDMCritSectLeave(&pData->CritSect);
+            rc = serial_ioport_write (pThis, Port, u32);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -520 +520 @@
                                     RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
     int          rc = VINF_SUCCESS;
 
     if (cb == 1)
     {
-        rc = PDMCritSectEnter(&pData->CritSect, VINF_IOM_HC_IOPORT_READ);
+        rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_HC_IOPORT_READ);
         if (rc == VINF_SUCCESS)
         {
-            *pu32 = serial_ioport_read (pData, Port, &rc);
+            *pu32 = serial_ioport_read (pThis, Port, &rc);
             Log2(("%s: port %#06x val %#04x\n", __FUNCTION__, Port, *pu32));
-            PDMCritSectLeave(&pData->CritSect);
+            PDMCritSectLeave(&pThis->CritSect);
         }
     }
@@ -550 +550 @@
                                         PSSMHANDLE pSSMHandle)
 {
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
-
-    SSMR3PutU16(pSSMHandle, pData->divider);
-    SSMR3PutU8(pSSMHandle, pData->rbr);
-    SSMR3PutU8(pSSMHandle, pData->ier);
-    SSMR3PutU8(pSSMHandle, pData->lcr);
-    SSMR3PutU8(pSSMHandle, pData->mcr);
-    SSMR3PutU8(pSSMHandle, pData->lsr);
-    SSMR3PutU8(pSSMHandle, pData->msr);
-    SSMR3PutU8(pSSMHandle, pData->scr);
-    SSMR3PutS32(pSSMHandle, pData->thr_ipending);
-    SSMR3PutS32(pSSMHandle, pData->irq);
-    SSMR3PutS32(pSSMHandle, pData->last_break_enable);
-    SSMR3PutU32(pSSMHandle, pData->base);
-    SSMR3PutBool(pSSMHandle, pData->msr_changed);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
+
+    SSMR3PutU16(pSSMHandle, pThis->divider);
+    SSMR3PutU8(pSSMHandle, pThis->rbr);
+    SSMR3PutU8(pSSMHandle, pThis->ier);
+    SSMR3PutU8(pSSMHandle, pThis->lcr);
+    SSMR3PutU8(pSSMHandle, pThis->mcr);
+    SSMR3PutU8(pSSMHandle, pThis->lsr);
+    SSMR3PutU8(pSSMHandle, pThis->msr);
+    SSMR3PutU8(pSSMHandle, pThis->scr);
+    SSMR3PutS32(pSSMHandle, pThis->thr_ipending);
+    SSMR3PutS32(pSSMHandle, pThis->irq);
+    SSMR3PutS32(pSSMHandle, pThis->last_break_enable);
+    SSMR3PutU32(pSSMHandle, pThis->base);
+    SSMR3PutBool(pSSMHandle, pThis->msr_changed);
     return SSMR3PutU32(pSSMHandle, ~0); /* sanity/terminator */
 }
@@ -582 +582 @@
     int          rc;
     uint32_t     u32;
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
 
     if (u32Version != SERIAL_SAVED_STATE_VERSION)
@@ -590 +590 @@
     }
 
-    SSMR3GetU16(pSSMHandle, &pData->divider);
-    SSMR3GetU8(pSSMHandle, &pData->rbr);
-    SSMR3GetU8(pSSMHandle, &pData->ier);
-    SSMR3GetU8(pSSMHandle, &pData->lcr);
-    SSMR3GetU8(pSSMHandle, &pData->mcr);
-    SSMR3GetU8(pSSMHandle, &pData->lsr);
-    SSMR3GetU8(pSSMHandle, &pData->msr);
-    SSMR3GetU8(pSSMHandle, &pData->scr);
-    SSMR3GetS32(pSSMHandle, &pData->thr_ipending);
-    SSMR3GetS32(pSSMHandle, &pData->irq);
-    SSMR3GetS32(pSSMHandle, &pData->last_break_enable);
-    SSMR3GetU32(pSSMHandle, &pData->base);
-    SSMR3GetBool(pSSMHandle, &pData->msr_changed);
+    SSMR3GetU16(pSSMHandle, &pThis->divider);
+    SSMR3GetU8(pSSMHandle, &pThis->rbr);
+    SSMR3GetU8(pSSMHandle, &pThis->ier);
+    SSMR3GetU8(pSSMHandle, &pThis->lcr);
+    SSMR3GetU8(pSSMHandle, &pThis->mcr);
+    SSMR3GetU8(pSSMHandle, &pThis->lsr);
+    SSMR3GetU8(pSSMHandle, &pThis->msr);
+    SSMR3GetU8(pSSMHandle, &pThis->scr);
+    SSMR3GetS32(pSSMHandle, &pThis->thr_ipending);
+    SSMR3GetS32(pSSMHandle, &pThis->irq);
+    SSMR3GetS32(pSSMHandle, &pThis->last_break_enable);
+    SSMR3GetU32(pSSMHandle, &pThis->base);
+    SSMR3GetBool(pSSMHandle, &pThis->msr_changed);
 
     rc = SSMR3GetU32(pSSMHandle, &u32);
@@ -616 +616 @@
      * in the saved state. */
 
-    if (pData->lsr & UART_LSR_DR)
-    {
-        int rc = RTSemEventSignal(pData->ReceiveSem);
+    if (pThis->lsr & UART_LSR_DR)
+    {
+        int rc = RTSemEventSignal(pThis->ReceiveSem);
         AssertRC(rc);
     }
-    pData->pDevInsHC = pDevIns;
-    pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+    pThis->pDevInsHC = pDevIns;
+    pThis->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
     return VINF_SUCCESS;
 }
@@ -632 +632 @@
 static DECLCALLBACK(void) serialRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
-    pData->pDevInsGC   = PDMDEVINS_2_GCPTR(pDevIns);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
+    pThis->pDevInsGC   = PDMDEVINS_2_GCPTR(pDevIns);
 }
 
@@ -640 +640 @@
 static DECLCALLBACK(int) serialIOPortRegionMap(PPCIDEVICE pPciDev, /* unsigned */ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
 {
-    SerialState *pData = PCIDEV_2_SERIALSTATE(pPciDev);
+    SerialState *pThis = PCIDEV_2_SERIALSTATE(pPciDev);
     int rc = VINF_SUCCESS;
 
@@ -648 +648 @@
     AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
 
-    pData->base = (RTIOPORT)GCPhysAddress;
-    LogRel(("Serial#%d: mapping I/O at %#06x\n", pData->pDevIns->iInstance, pData->base));
+    pThis->base = (RTIOPORT)GCPhysAddress;
+    LogRel(("Serial#%d: mapping I/O at %#06x\n", pThis->pDevIns->iInstance, pThis->base));
 
     /*
      * Register our port IO handlers.
      */
-    rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress, 8, (void *)pData,
+    rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns, (RTIOPORT)GCPhysAddress, 8, (void *)pThis,
                                  serial_io_write, serial_io_read, NULL, NULL, "SERIAL");
     AssertRC(rc);
@@ -666 +666 @@
 static DECLCALLBACK(void *) serialQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    SerialState *pData = PDMIBASE_2_SERIALSTATE(pInterface);
+    SerialState *pThis = PDMIBASE_2_SERIALSTATE(pInterface);
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->IBase;
+            return &pThis->IBase;
         case PDMINTERFACE_CHAR_PORT:
-            return &pData->ICharPort;
+            return &pThis->ICharPort;
         default:
             return NULL;
@@ -689 +689 @@
 static DECLCALLBACK(int) serialDestruct(PPDMDEVINS pDevIns)
 {
-    SerialState *pData = PDMINS_2_DATA(pDevIns, SerialState *);
-
-    RTSemEventDestroy(pData->ReceiveSem);
-    pData->ReceiveSem = NIL_RTSEMEVENT;
-
-    PDMR3CritSectDelete(&pData->CritSect);
+    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
+
+    RTSemEventDestroy(pThis->ReceiveSem);
+    pThis->ReceiveSem = NIL_RTSEMEVENT;
+
+    PDMR3CritSectDelete(&pThis->CritSect);
     return VINF_SUCCESS;
 }
@@ -717 +717 @@
 {
     int            rc;
-    SerialState   *pData = PDMINS_2_DATA(pDevIns, SerialState*);
+    SerialState   *pThis = PDMINS_2_DATA(pDevIns, SerialState*);
     uint16_t       io_base;
     uint8_t        irq_lvl;
@@ -723 +723 @@
     Assert(iInstance < 4);
 
-    pData->pDevInsHC = pDevIns;
-    pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+    pThis->pDevInsHC = pDevIns;
+    pThis->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
 
     /*
@@ -735 +735 @@
     }
 
-    rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &pData->fGCEnabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &pThis->fGCEnabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fGCEnabled = true;
+        pThis->fGCEnabled = true;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed to get the \"GCEnabled\" value"));
 
-    rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &pData->fR0Enabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &pThis->fR0Enabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fR0Enabled = true;
+        pThis->fR0Enabled = true;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -750 +750 @@
 
     /* IBase */
-    pData->IBase.pfnQueryInterface = serialQueryInterface;
+    pThis->IBase.pfnQueryInterface = serialQueryInterface;
 
     /* ICharPort */
-    pData->ICharPort.pfnNotifyRead = serialNotifyRead;
-    pData->ICharPort.pfnNotifyStatusLinesChanged = serialNotifyStatusLinesChanged;
-
-    rc = RTSemEventCreate(&pData->ReceiveSem);
+    pThis->ICharPort.pfnNotifyRead = serialNotifyRead;
+    pThis->ICharPort.pfnNotifyStatusLinesChanged = serialNotifyStatusLinesChanged;
+
+    rc = RTSemEventCreate(&pThis->ReceiveSem);
     AssertRC(rc);
 
@@ -765 +765 @@
     char szName[24];
     RTStrPrintf(szName, sizeof(szName), "Serial#%d", iInstance);
-    rc = PDMDevHlpCritSectInit(pDevIns, &pData->CritSect, szName);
+    rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, szName);
     if (RT_FAILURE(rc))
         return rc;
@@ -796 +796 @@
     Log(("serialConstruct instance %d iobase=%04x irq=%d\n", iInstance, io_base, irq_lvl));
 
-    pData->irq = irq_lvl;
-    pData->lsr = UART_LSR_TEMT | UART_LSR_THRE;
-    pData->iir = UART_IIR_NO_INT;
-    pData->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
+    pThis->irq = irq_lvl;
+    pThis->lsr = UART_LSR_TEMT | UART_LSR_THRE;
+    pThis->iir = UART_IIR_NO_INT;
+    pThis->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
 #ifdef VBOX_SERIAL_PCI
-    pData->base = -1;
-    pData->dev.config[0x00] = 0xee; /* Vendor: ??? */
-    pData->dev.config[0x01] = 0x80;
-    pData->dev.config[0x02] = 0x01; /* Device: ??? */
-    pData->dev.config[0x03] = 0x01;
-    pData->dev.config[0x04] = PCI_COMMAND_IOACCESS;
-    pData->dev.config[0x09] = 0x01; /* Programming interface: 16450 */
-    pData->dev.config[0x0a] = 0x00; /* Subclass: Serial controller */
-    pData->dev.config[0x0b] = 0x07; /* Class: Communication controller */
-    pData->dev.config[0x0e] = 0x00; /* Header type: standard */
-    pData->dev.config[0x3c] = irq_lvl; /* preconfigure IRQ number (0 = autoconfig)*/
-    pData->dev.config[0x3d] = 1;    /* interrupt pin 0 */
-    rc = PDMDevHlpPCIRegister(pDevIns, &pData->dev);
+    pThis->base = -1;
+    pThis->dev.config[0x00] = 0xee; /* Vendor: ??? */
+    pThis->dev.config[0x01] = 0x80;
+    pThis->dev.config[0x02] = 0x01; /* Device: ??? */
+    pThis->dev.config[0x03] = 0x01;
+    pThis->dev.config[0x04] = PCI_COMMAND_IOACCESS;
+    pThis->dev.config[0x09] = 0x01; /* Programming interface: 16450 */
+    pThis->dev.config[0x0a] = 0x00; /* Subclass: Serial controller */
+    pThis->dev.config[0x0b] = 0x07; /* Class: Communication controller */
+    pThis->dev.config[0x0e] = 0x00; /* Header type: standard */
+    pThis->dev.config[0x3c] = irq_lvl; /* preconfigure IRQ number (0 = autoconfig)*/
+    pThis->dev.config[0x3d] = 1;    /* interrupt pin 0 */
+    rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
     if (RT_FAILURE(rc))
         return rc;
@@ -823 +823 @@
         return rc;
 #else /* !VBOX_SERIAL_PCI */
-    pData->base = io_base;
+    pThis->base = io_base;
     rc = PDMDevHlpIOPortRegister(pDevIns, io_base, 8, 0,
                                  serialIOPortWrite, serialIOPortRead,
@@ -830 +830 @@
         return rc;
 
-    if (pData->fGCEnabled)
+    if (pThis->fGCEnabled)
         rc = PDMDevHlpIOPortRegisterGC(pDevIns, io_base, 8, 0, "serialIOPortWrite",
                                       "serialIOPortRead", NULL, NULL, "Serial");
 
-    if (pData->fR0Enabled)
+    if (pThis->fR0Enabled)
         rc = PDMDevHlpIOPortRegisterR0(pDevIns, io_base, 8, 0, "serialIOPortWrite",
                                       "serialIOPortRead", NULL, NULL, "Serial");
@@ -842 +842 @@
     /* Attach the char driver and get the interfaces. For now no run-time
      * changes are supported. */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pData->IBase, &pData->pDrvBase, "Serial Char");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "Serial Char");
     if (RT_SUCCESS(rc))
     {
-        pData->pDrvChar = (PDMICHAR *)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_CHAR);
-        if (!pData->pDrvChar)
+        pThis->pDrvChar = (PDMICHAR *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_CHAR);
+        if (!pThis->pDrvChar)
         {
             AssertMsgFailed(("Configuration error: instance %d has no char interface!\n", iInstance));
@@ -855 +855 @@
     else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
     {
-        pData->pDrvBase = NULL;
-        pData->pDrvChar = NULL;
+        pThis->pDrvBase = NULL;
+        pThis->pDrvChar = NULL;
         LogRel(("Serial%d: no unit\n", iInstance));
     }
@@ -871 +871 @@
         iInstance,              /* u32Instance */
         SERIAL_SAVED_STATE_VERSION, /* u32Version */
-        sizeof (*pData),        /* cbGuess */
+        sizeof (*pThis),        /* cbGuess */
         NULL,                   /* pfnSavePrep */
         serialSaveExec,         /* pfnSaveExec */

trunk/src/VBox/Devices/Serial/DrvChar.cpp

@@ -94 +94 @@
 {
     PPDMDRVINS  pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVCHAR    pData = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
+    PDRVCHAR    pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
     switch (enmInterface)
     {
@@ -100 +100 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_CHAR:
-            return &pData->IChar;
+            return &pThis->IChar;
         default:
             return NULL;
@@ -112 +112 @@
 static DECLCALLBACK(int) drvCharWrite(PPDMICHAR pInterface, const void *pvBuf, size_t cbWrite)
 {
-    PDRVCHAR pData = PDMICHAR_2_DRVCHAR(pInterface);
+    PDRVCHAR pThis = PDMICHAR_2_DRVCHAR(pInterface);
     const char *pBuffer = (const char *)pvBuf;
 
@@ -119 +119 @@
     for (uint32_t i=0;i<cbWrite;i++)
     {
-        uint32_t idx = pData->iSendQueueHead;
-
-        pData->aSendQueue[idx] = pBuffer[i];
+        uint32_t idx = pThis->iSendQueueHead;
+
+        pThis->aSendQueue[idx] = pBuffer[i];
         idx = (idx + 1) & CHAR_MAX_SEND_QUEUE_MASK;
 
-        STAM_COUNTER_INC(&pData->StatBytesWritten);
-        ASMAtomicXchgU32(&pData->iSendQueueHead, idx);
-    }
-    RTSemEventSignal(pData->SendSem);
+        STAM_COUNTER_INC(&pThis->StatBytesWritten);
+        ASMAtomicXchgU32(&pThis->iSendQueueHead, idx);
+    }
+    RTSemEventSignal(pThis->SendSem);
     return VINF_SUCCESS;
 }
@@ -134 +134 @@
 static DECLCALLBACK(int) drvCharSetParameters(PPDMICHAR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits)
 {
-    /*PDRVCHAR pData = PDMICHAR_2_DRVCHAR(pInterface); - unused*/
+    /*PDRVCHAR pThis = PDMICHAR_2_DRVCHAR(pInterface); - unused*/
 
     LogFlow(("%s: Bps=%u chParity=%c cDataBits=%u cStopBits=%u\n", __FUNCTION__, Bps, chParity, cDataBits, cStopBits));
@@ -152 +152 @@
 static DECLCALLBACK(int) drvCharSendLoop(RTTHREAD ThreadSelf, void *pvUser)
 {
-    PDRVCHAR pData = (PDRVCHAR)pvUser;
+    PDRVCHAR pThis = (PDRVCHAR)pvUser;
 
     for(;;)
     {
-        int rc = RTSemEventWait(pData->SendSem, RT_INDEFINITE_WAIT);
+        int rc = RTSemEventWait(pThis->SendSem, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc))
             break;
@@ -163 +163 @@
          * Write the character to the attached stream (if present).
          */
-        if (    !pData->fShutdown
-            &&  pData->pDrvStream)
+        if (    !pThis->fShutdown
+            &&  pThis->pDrvStream)
         {
-            while (pData->iSendQueueTail != pData->iSendQueueHead)
+            while (pThis->iSendQueueTail != pThis->iSendQueueHead)
             {
                 size_t cbProcessed = 1;
 
-                rc = pData->pDrvStream->pfnWrite(pData->pDrvStream, &pData->aSendQueue[pData->iSendQueueTail], &cbProcessed);
+                rc = pThis->pDrvStream->pfnWrite(pThis->pDrvStream, &pThis->aSendQueue[pThis->iSendQueueTail], &cbProcessed);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(cbProcessed);
-                    pData->iSendQueueTail++;
-                    pData->iSendQueueTail &= CHAR_MAX_SEND_QUEUE_MASK;
+                    pThis->iSendQueueTail++;
+                    pThis->iSendQueueTail &= CHAR_MAX_SEND_QUEUE_MASK;
                 }
                 else if (rc == VERR_TIMEOUT)
@@ -194 +194 @@
     }
 
-    pData->SendThread = NIL_RTTHREAD;
+    pThis->SendThread = NIL_RTTHREAD;
 
     return VINF_SUCCESS;
@@ -210 +210 @@
 static DECLCALLBACK(int) drvCharReceiveLoop(RTTHREAD ThreadSelf, void *pvUser)
 {
-    PDRVCHAR pData = (PDRVCHAR)pvUser;
+    PDRVCHAR pThis = (PDRVCHAR)pvUser;
     char aBuffer[256], *pBuffer;
     size_t cbRemaining, cbProcessed;
@@ -217 +217 @@
     cbRemaining = 0;
     pBuffer = aBuffer;
-    while (!pData->fShutdown)
+    while (!pThis->fShutdown)
     {
         if (!cbRemaining)
         {
             /* Get block of data from stream driver. */
-            if (pData->pDrvStream)
+            if (pThis->pDrvStream)
             {
                 cbRemaining = sizeof(aBuffer);
-                rc = pData->pDrvStream->pfnRead(pData->pDrvStream, aBuffer, &cbRemaining);
+                rc = pThis->pDrvStream->pfnRead(pThis->pDrvStream, aBuffer, &cbRemaining);
                 if (RT_FAILURE(rc))
                 {
@@ -243 +243 @@
             /* Send data to guest. */
             cbProcessed = cbRemaining;
-            rc = pData->pDrvCharPort->pfnNotifyRead(pData->pDrvCharPort, pBuffer, &cbProcessed);
+            rc = pThis->pDrvCharPort->pfnNotifyRead(pThis->pDrvCharPort, pBuffer, &cbProcessed);
             if (RT_SUCCESS(rc))
             {
@@ -249 +249 @@
                 pBuffer += cbProcessed;
                 cbRemaining -= cbProcessed;
-                STAM_COUNTER_ADD(&pData->StatBytesRead, cbProcessed);
+                STAM_COUNTER_ADD(&pThis->StatBytesRead, cbProcessed);
             }
             else if (rc == VERR_TIMEOUT)
@@ -265 +265 @@
     }
 
-    pData->ReceiveThread = NIL_RTTHREAD;
+    pThis->ReceiveThread = NIL_RTTHREAD;
 
     return VINF_SUCCESS;
@@ -300 +300 @@
 static DECLCALLBACK(int) drvCharConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVCHAR pData = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
+    PDRVCHAR pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
@@ -306 +306 @@
      * Init basic data members and interfaces.
      */
-    pData->ReceiveThread                    = NIL_RTTHREAD;
-    pData->fShutdown                        = false;
+    pThis->ReceiveThread                    = NIL_RTTHREAD;
+    pThis->fShutdown                        = false;
     /* IBase. */
     pDrvIns->IBase.pfnQueryInterface        = drvCharQueryInterface;
     /* IChar. */
-    pData->IChar.pfnWrite                   = drvCharWrite;
-    pData->IChar.pfnSetParameters           = drvCharSetParameters;
-    pData->IChar.pfnSetModemLines           = drvCharSetModemLines;
+    pThis->IChar.pfnWrite                   = drvCharWrite;
+    pThis->IChar.pfnSetParameters           = drvCharSetParameters;
+    pThis->IChar.pfnSetModemLines           = drvCharSetModemLines;
 
     /*
      * Get the ICharPort interface of the above driver/device.
      */
-    pData->pDrvCharPort = (PPDMICHARPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_CHAR_PORT);
-    if (!pData->pDrvCharPort)
+    pThis->pDrvCharPort = (PPDMICHARPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_CHAR_PORT);
+    if (!pThis->pDrvCharPort)
         return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("Char#%d has no char port interface above"), pDrvIns->iInstance);
 
@@ -329 +329 @@
     if (RT_FAILURE(rc))
         return rc; /* Don't call PDMDrvHlpVMSetError here as we assume that the driver already set an appropriate error */
-    pData->pDrvStream = (PPDMISTREAM)pBase->pfnQueryInterface(pBase, PDMINTERFACE_STREAM);
-    if (!pData->pDrvStream)
+    pThis->pDrvStream = (PPDMISTREAM)pBase->pfnQueryInterface(pBase, PDMINTERFACE_STREAM);
+    if (!pThis->pDrvStream)
         return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW, RT_SRC_POS, N_("Char#%d has no stream interface below"), pDrvIns->iInstance);
 
-    rc = RTThreadCreate(&pData->ReceiveThread, drvCharReceiveLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharRecv");
+    rc = RTThreadCreate(&pThis->ReceiveThread, drvCharReceiveLoop, (void *)pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharRecv");
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create receive thread"), pDrvIns->iInstance);
 
-    rc = RTSemEventCreate(&pData->SendSem);
+    rc = RTSemEventCreate(&pThis->SendSem);
     AssertRC(rc);
 
-    rc = RTThreadCreate(&pData->SendThread, drvCharSendLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharSend");
+    rc = RTThreadCreate(&pThis->SendThread, drvCharSendLoop, (void *)pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharSend");
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create send thread"), pDrvIns->iInstance);
 
 
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesWritten,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written",         "/Devices/Char%d/Written", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesRead,       STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read",            "/Devices/Char%d/Read", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written",         "/Devices/Char%d/Written", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead,       STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read",            "/Devices/Char%d/Read", pDrvIns->iInstance);
 
     return VINF_SUCCESS;
@@ -362 +362 @@
 static DECLCALLBACK(void) drvCharDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVCHAR     pData = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
+    PDRVCHAR     pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
 
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
-    pData->fShutdown = true;
-    if (pData->ReceiveThread)
-    {
-        RTThreadWait(pData->ReceiveThread, 1000, NULL);
-        if (pData->ReceiveThread != NIL_RTTHREAD)
+    pThis->fShutdown = true;
+    if (pThis->ReceiveThread)
+    {
+        RTThreadWait(pThis->ReceiveThread, 1000, NULL);
+        if (pThis->ReceiveThread != NIL_RTTHREAD)
             LogRel(("Char%d: receive thread did not terminate\n", pDrvIns->iInstance));
     }
 
     /* Empty the send queue */
-    pData->iSendQueueTail = pData->iSendQueueHead = 0;
-
-    RTSemEventSignal(pData->SendSem);
-    RTSemEventDestroy(pData->SendSem);
-    pData->SendSem = NIL_RTSEMEVENT;
-
-    if (pData->SendThread)
-    {
-        RTThreadWait(pData->SendThread, 1000, NULL);
-        if (pData->SendThread != NIL_RTTHREAD)
+    pThis->iSendQueueTail = pThis->iSendQueueHead = 0;
+
+    RTSemEventSignal(pThis->SendSem);
+    RTSemEventDestroy(pThis->SendSem);
+    pThis->SendSem = NIL_RTSEMEVENT;
+
+    if (pThis->SendThread)
+    {
+        RTThreadWait(pThis->SendThread, 1000, NULL);
+        if (pThis->SendThread != NIL_RTTHREAD)
             LogRel(("Char%d: send thread did not terminate\n", pDrvIns->iInstance));
     }

trunk/src/VBox/Devices/Serial/DrvHostSerial.cpp

@@ -146 +146 @@
 {
     PPDMDRVINS  pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVHOSTSERIAL    pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL    pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     switch (enmInterface)
     {
@@ -152 +152 @@
             return &pDrvIns->IBase;
         case PDMINTERFACE_CHAR:
-            return &pData->IChar;
+            return &pThis->IChar;
         default:
             return NULL;
@@ -164 +164 @@
 static DECLCALLBACK(int) drvHostSerialWrite(PPDMICHAR pInterface, const void *pvBuf, size_t cbWrite)
 {
-    PDRVHOSTSERIAL pData = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
+    PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
     const uint8_t *pbBuffer = (const uint8_t *)pvBuf;
 
@@ -171 +171 @@
     for (uint32_t i=0;i<cbWrite;i++)
     {
-        uint32_t idx = pData->iSendQueueHead;
-
-        pData->aSendQueue[idx] = pbBuffer[i];
+        uint32_t idx = pThis->iSendQueueHead;
+
+        pThis->aSendQueue[idx] = pbBuffer[i];
         idx = (idx + 1) & CHAR_MAX_SEND_QUEUE_MASK;
 
-        STAM_COUNTER_INC(&pData->StatBytesWritten);
-        ASMAtomicXchgU32(&pData->iSendQueueHead, idx);
-    }
-    RTSemEventSignal(pData->SendSem);
+        STAM_COUNTER_INC(&pThis->StatBytesWritten);
+        ASMAtomicXchgU32(&pThis->iSendQueueHead, idx);
+    }
+    RTSemEventSignal(pThis->SendSem);
     return VINF_SUCCESS;
 }
@@ -185 +185 @@
 static DECLCALLBACK(int) drvHostSerialSetParameters(PPDMICHAR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits)
 {
-    PDRVHOSTSERIAL pData = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
+    PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
 #ifdef RT_OS_LINUX
     struct termios *termiosSetup;
@@ -300 +300 @@
     termiosSetup->c_lflag = ~(ICANON | ECHO | ECHOE | ISIG);
 
-    tcsetattr(pData->DeviceFile, TCSANOW, termiosSetup);
+    tcsetattr(pThis->DeviceFile, TCSANOW, termiosSetup);
     RTMemTmpFree(termiosSetup);
 #elif defined(RT_OS_WINDOWS)
@@ -396 +396 @@
     comSetup->EvtChar = 0;
 
-    SetCommState(pData->hDeviceFile, comSetup);
+    SetCommState(pThis->hDeviceFile, comSetup);
     RTMemTmpFree(comSetup);
 #endif /* RT_OS_WINDOWS */
@@ -414 +414 @@
 static DECLCALLBACK(int) drvHostSerialSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
 
     if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
@@ -421 +421 @@
 #ifdef RT_OS_WINDOWS
     HANDLE haWait[2];
-    haWait[0] = pData->hEventSend;
-    haWait[1] = pData->hHaltEventSem;
+    haWait[0] = pThis->hEventSend;
+    haWait[1] = pThis->hHaltEventSem;
 #endif
 
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        int rc = RTSemEventWait(pData->SendSem, RT_INDEFINITE_WAIT);
+        int rc = RTSemEventWait(pThis->SendSem, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc))
             break;
@@ -435 +435 @@
          */
         while (   pThread->enmState == PDMTHREADSTATE_RUNNING
-               && pData->iSendQueueTail != pData->iSendQueueHead)
+               && pThis->iSendQueueTail != pThis->iSendQueueHead)
         {
             unsigned cbProcessed = 1;
@@ -441 +441 @@
 #if defined(RT_OS_LINUX)
 
-            rc = RTFileWrite(pData->DeviceFile, &pData->aSendQueue[pData->iSendQueueTail], cbProcessed, NULL);
+            rc = RTFileWrite(pThis->DeviceFile, &pThis->aSendQueue[pThis->iSendQueueTail], cbProcessed, NULL);
 
 #elif defined(RT_OS_WINDOWS)
 
             DWORD cbBytesWritten;
-            memset(&pData->overlappedSend, 0, sizeof(pData->overlappedSend));
-            pData->overlappedSend.hEvent = pData->hEventSend;
-
-            if (!WriteFile(pData->hDeviceFile, &pData->aSendQueue[pData->iSendQueueTail], cbProcessed, &cbBytesWritten, &pData->overlappedSend))
+            memset(&pThis->overlappedSend, 0, sizeof(pThis->overlappedSend));
+            pThis->overlappedSend.hEvent = pThis->hEventSend;
+
+            if (!WriteFile(pThis->hDeviceFile, &pThis->aSendQueue[pThis->iSendQueueTail], cbProcessed, &cbBytesWritten, &pThis->overlappedSend))
             {
                 DWORD dwRet = GetLastError();
@@ -470 +470 @@
             {
                 Assert(cbProcessed);
-                pData->iSendQueueTail++;
-                pData->iSendQueueTail &= CHAR_MAX_SEND_QUEUE_MASK;
+                pThis->iSendQueueTail++;
+                pThis->iSendQueueTail &= CHAR_MAX_SEND_QUEUE_MASK;
             }
             else if (RT_FAILURE(rc))
@@ -493 +493 @@
 static DECLCALLBACK(int) drvHostSerialWakeupSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     int rc;
 
-    rc = RTSemEventSignal(pData->SendSem);
+    rc = RTSemEventSignal(pThis->SendSem);
     if (RT_FAILURE(rc))
         return rc;
 
 #ifdef RT_OS_WINDOWS
-    if (!SetEvent(pData->hHaltEventSem))
+    if (!SetEvent(pThis->hHaltEventSem))
         return RTErrConvertFromWin32(GetLastError());
 #endif
@@ -522 +522 @@
 static DECLCALLBACK(int) drvHostSerialRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     uint8_t abBuffer[256];
     uint8_t *pbBuffer = NULL;
@@ -533 +533 @@
 #ifdef RT_OS_WINDOWS
     HANDLE haWait[2];
-    haWait[0] = pData->hEventRecv;
-    haWait[1] = pData->hHaltEventSem;
+    haWait[0] = pThis->hEventRecv;
+    haWait[1] = pThis->hHaltEventSem;
 #endif
 
@@ -547 +547 @@
             size_t cbRead;
             struct pollfd aFDs[2];
-            aFDs[0].fd      = pData->DeviceFile;
+            aFDs[0].fd      = pThis->DeviceFile;
             aFDs[0].events  = POLLIN;
             aFDs[0].revents = 0;
-            aFDs[1].fd      = pData->WakeupPipeR;
+            aFDs[1].fd      = pThis->WakeupPipeR;
             aFDs[1].events  = POLLIN | POLLERR | POLLHUP;
             aFDs[1].revents = 0;
@@ -569 +569 @@
                 char ch;
                 size_t cbRead;
-                RTFileRead(pData->WakeupPipeR, &ch, 1, &cbRead);
+                RTFileRead(pThis->WakeupPipeR, &ch, 1, &cbRead);
                 continue;
             }
-            rc = RTFileRead(pData->DeviceFile, abBuffer, sizeof(abBuffer), &cbRead);
+            rc = RTFileRead(pThis->DeviceFile, abBuffer, sizeof(abBuffer), &cbRead);
             if (RT_FAILURE(rc))
             {
@@ -585 +585 @@
             DWORD dwNumberOfBytesTransferred;
 
-            memset(&pData->overlappedRecv, 0, sizeof(pData->overlappedRecv));
-            pData->overlappedRecv.hEvent = pData->hEventRecv;
-
-            if (!WaitCommEvent(pData->hDeviceFile, &dwEventMask, &pData->overlappedRecv))
+            memset(&pThis->overlappedRecv, 0, sizeof(pThis->overlappedRecv));
+            pThis->overlappedRecv.hEvent = pThis->hEventRecv;
+
+            if (!WaitCommEvent(pThis->hDeviceFile, &dwEventMask, &pThis->overlappedRecv))
             {
                 DWORD dwRet = GetLastError();
@@ -613 +613 @@
             if (dwEventMask & EV_RXCHAR)
             {
-                if (!ReadFile(pData->hDeviceFile, abBuffer, sizeof(abBuffer), &dwNumberOfBytesTransferred, &pData->overlappedRecv))
+                if (!ReadFile(pThis->hDeviceFile, abBuffer, sizeof(abBuffer), &dwNumberOfBytesTransferred, &pThis->overlappedRecv))
                 {
                     LogRel(("HostSerial#%d: Read failed with error %Vrc; terminating the worker thread.\n", pDrvIns->iInstance, RTErrConvertFromWin32(GetLastError())));
@@ -627 +627 @@
 
                 /* Get the new state */
-                if (GetCommModemStatus(pData->hDeviceFile, &dwNewStatusLinesState))
+                if (GetCommModemStatus(pThis->hDeviceFile, &dwNewStatusLinesState))
                 {
                     if (dwNewStatusLinesState & MS_RLSD_ON)
@@ -637 +637 @@
                     if (dwNewStatusLinesState & MS_CTS_ON)
                         uNewStatusLinesState |= PDM_ICHAR_STATUS_LINES_CTS;
-                    rc = pData->pDrvCharPort->pfnNotifyStatusLinesChanged(pData->pDrvCharPort, uNewStatusLinesState);
+                    rc = pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, uNewStatusLinesState);
                     if (RT_FAILURE(rc))
                     {
@@ -659 +659 @@
             /* Send data to the guest. */
             size_t cbProcessed = cbRemaining;
-            rc = pData->pDrvCharPort->pfnNotifyRead(pData->pDrvCharPort, pbBuffer, &cbProcessed);
+            rc = pThis->pDrvCharPort->pfnNotifyRead(pThis->pDrvCharPort, pbBuffer, &cbProcessed);
             if (RT_SUCCESS(rc))
             {
@@ -665 +665 @@
                 pbBuffer += cbProcessed;
                 cbRemaining -= cbProcessed;
-                STAM_COUNTER_ADD(&pData->StatBytesRead, cbProcessed);
+                STAM_COUNTER_ADD(&pThis->StatBytesRead, cbProcessed);
             }
             else if (rc == VERR_TIMEOUT)
@@ -693 +693 @@
 static DECLCALLBACK(int) drvHostSerialWakeupRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
 #ifdef RT_OS_LINUX
-    return RTFileWrite(pData->WakeupPipeW, "", 1, NULL);
+    return RTFileWrite(pThis->WakeupPipeW, "", 1, NULL);
 #elif defined(RT_OS_WINDOWS)
-    if (!SetEvent(pData->hHaltEventSem))
+    if (!SetEvent(pThis->hHaltEventSem))
         return RTErrConvertFromWin32(GetLastError());
     return VINF_SUCCESS;
@@ -720 +720 @@
 static DECLCALLBACK(int) drvHostSerialMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     int rc = VINF_SUCCESS;
     unsigned uStatusLinesToCheck = 0;
@@ -737 +737 @@
          * Wait for status line change.
          */
-        rc = ioctl(pData->DeviceFile, TIOCMIWAIT, &uStatusLinesToCheck);
+        rc = ioctl(pThis->DeviceFile, TIOCMIWAIT, &uStatusLinesToCheck);
         if (pThread->enmState != PDMTHREADSTATE_RUNNING)
             break;
@@ -745 +745 @@
             PDMDrvHlpVMSetRuntimeError(pDrvIns, false, "DrvHostSerialFail",
                                        N_("Ioctl failed for serial host device '%s' (%Vrc). The device will not work properly"),
-                                       pData->pszDevicePath, RTErrConvertFromErrno(errno));
+                                       pThis->pszDevicePath, RTErrConvertFromErrno(errno));
             break;
         }
 
-        rc = ioctl(pData->DeviceFile, TIOCMGET, &statusLines);
+        rc = ioctl(pThis->DeviceFile, TIOCMGET, &statusLines);
         if (rc < 0)
             goto ioctl_error;
@@ -761 +761 @@
         if (statusLines & TIOCM_CTS)
             newStatusLine |= PDM_ICHAR_STATUS_LINES_CTS;
-        rc = pData->pDrvCharPort->pfnNotifyStatusLinesChanged(pData->pDrvCharPort, newStatusLine);
+        rc = pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, newStatusLine);
     }
 
@@ -778 +778 @@
 static DECLCALLBACK(int) drvHostSerialWakeupMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     int rc;
     unsigned int uSerialLineFlags;
@@ -793 +793 @@
 
     /* Get current status of control lines. */
-    rc = ioctl(pData->DeviceFile, TIOCMGET, &uSerialLineStatus);
+    rc = ioctl(pThis->DeviceFile, TIOCMGET, &uSerialLineStatus);
     if (rc < 0)
         goto ioctl_error;
 
     uSerialLineFlags = TIOCM_LOOP;
-    rc = ioctl(pData->DeviceFile, TIOCMBIS, &uSerialLineFlags);
+    rc = ioctl(pThis->DeviceFile, TIOCMBIS, &uSerialLineFlags);
     if (rc < 0)
         goto ioctl_error;
@@ -809 +809 @@
     uSerialLineFlags = TIOCM_RTS;
 
-    rc = ioctl(pData->DeviceFile, uIoctl, &uSerialLineFlags);
+    rc = ioctl(pThis->DeviceFile, uIoctl, &uSerialLineFlags);
     if (rc < 0)
         goto ioctl_error;
@@ -816 +816 @@
     uIoctl = (uIoctl == TIOCMBIC) ? TIOCMBIS : TIOCMBIC;
 
-    rc = ioctl(pData->DeviceFile, uIoctl, &uSerialLineFlags);
+    rc = ioctl(pThis->DeviceFile, uIoctl, &uSerialLineFlags);
     if (rc < 0)
         goto ioctl_error;
@@ -824 +824 @@
      */
     uSerialLineFlags = TIOCM_LOOP;
-    rc = ioctl(pData->DeviceFile, TIOCMBIC, &uSerialLineFlags);
+    rc = ioctl(pThis->DeviceFile, TIOCMBIC, &uSerialLineFlags);
     if (rc >= 0)
         return VINF_SUCCESS;
@@ -831 +831 @@
     PDMDrvHlpVMSetRuntimeError(pDrvIns, false, "DrvHostSerialFail",
                                 N_("Ioctl failed for serial host device '%s' (%Vrc). The device will not work properly"),
-                                pData->pszDevicePath, RTErrConvertFromErrno(errno));
+                                pThis->pszDevicePath, RTErrConvertFromErrno(errno));
     return VINF_SUCCESS;
 }
@@ -846 +846 @@
 static DECLCALLBACK(int) drvHostSerialSetModemLines(PPDMICHAR pInterface, bool RequestToSend, bool DataTerminalReady)
 {
-    PDRVHOSTSERIAL pData = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
+    PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
 
 #ifdef RT_OS_LINUX
@@ -863 +863 @@
 
     if (modemStateSet)
-        ioctl(pData->DeviceFile, TIOCMBIS, &modemStateSet);
+        ioctl(pThis->DeviceFile, TIOCMBIS, &modemStateSet);
 
     if (modemStateClear)
-        ioctl(pData->DeviceFile, TIOCMBIC, &modemStateClear);
+        ioctl(pThis->DeviceFile, TIOCMBIC, &modemStateClear);
 #elif defined(RT_OS_WINDOWS)
     if (RequestToSend)
-        EscapeCommFunction(pData->hDeviceFile, SETRTS);
+        EscapeCommFunction(pThis->hDeviceFile, SETRTS);
     else
-        EscapeCommFunction(pData->hDeviceFile, CLRRTS);
+        EscapeCommFunction(pThis->hDeviceFile, CLRRTS);
 
     if (DataTerminalReady)
-        EscapeCommFunction(pData->hDeviceFile, SETDTR);
+        EscapeCommFunction(pThis->hDeviceFile, SETDTR);
     else
-        EscapeCommFunction(pData->hDeviceFile, CLRDTR);
+        EscapeCommFunction(pThis->hDeviceFile, CLRDTR);
 #endif
 
@@ -898 +898 @@
 static DECLCALLBACK(int) drvHostSerialConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
@@ -905 +905 @@
      */
 #ifdef RT_OS_LINUX
-    pData->DeviceFile  = NIL_RTFILE;
-    pData->WakeupPipeR = NIL_RTFILE;
-    pData->WakeupPipeW = NIL_RTFILE;
+    pThis->DeviceFile  = NIL_RTFILE;
+    pThis->WakeupPipeR = NIL_RTFILE;
+    pThis->WakeupPipeW = NIL_RTFILE;
 #endif
     /* IBase. */
     pDrvIns->IBase.pfnQueryInterface        = drvHostSerialQueryInterface;
     /* IChar. */
-    pData->IChar.pfnWrite                   = drvHostSerialWrite;
-    pData->IChar.pfnSetParameters           = drvHostSerialSetParameters;
-    pData->IChar.pfnSetModemLines           = drvHostSerialSetModemLines;
+    pThis->IChar.pfnWrite                   = drvHostSerialWrite;
+    pThis->IChar.pfnSetParameters           = drvHostSerialSetParameters;
+    pThis->IChar.pfnSetModemLines           = drvHostSerialSetModemLines;
 
     /*
@@ -920 +920 @@
      */
     /* Device */
-    int rc = CFGMR3QueryStringAlloc(pCfgHandle, "DevicePath", &pData->pszDevicePath);
+    int rc = CFGMR3QueryStringAlloc(pCfgHandle, "DevicePath", &pThis->pszDevicePath);
     if (RT_FAILURE(rc))
     {
@@ -932 +932 @@
 #ifdef RT_OS_WINDOWS
 
-    pData->hHaltEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);
-    AssertReturn(pData->hHaltEventSem != NULL, VERR_NO_MEMORY);
-
-    pData->hEventRecv = CreateEvent(NULL, FALSE, FALSE, NULL);
-    AssertReturn(pData->hEventRecv != NULL, VERR_NO_MEMORY);
-
-    pData->hEventSend = CreateEvent(NULL, FALSE, FALSE, NULL);
-    AssertReturn(pData->hEventSend != NULL, VERR_NO_MEMORY);
-
-    HANDLE hFile = CreateFile(pData->pszDevicePath,
+    pThis->hHaltEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);
+    AssertReturn(pThis->hHaltEventSem != NULL, VERR_NO_MEMORY);
+
+    pThis->hEventRecv = CreateEvent(NULL, FALSE, FALSE, NULL);
+    AssertReturn(pThis->hEventRecv != NULL, VERR_NO_MEMORY);
+
+    pThis->hEventSend = CreateEvent(NULL, FALSE, FALSE, NULL);
+    AssertReturn(pThis->hEventSend != NULL, VERR_NO_MEMORY);
+
+    HANDLE hFile = CreateFile(pThis->pszDevicePath,
                               GENERIC_READ | GENERIC_WRITE,
                               0, // must be opened with exclusive access
@@ -952 +952 @@
     else
     {
-        pData->hDeviceFile = hFile;
+        pThis->hDeviceFile = hFile;
         /* for overlapped read */
         if (!SetCommMask(hFile, EV_RXCHAR | EV_CTS | EV_DSR | EV_RING | EV_RLSD))
@@ -964 +964 @@
 #else
 
-    rc = RTFileOpen(&pData->DeviceFile, pData->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
+    rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
 
 #endif
@@ -970 +970 @@
     if (RT_FAILURE(rc))
     {
-        AssertMsgFailed(("Could not open host device %s, rc=%Vrc\n", pData->pszDevicePath, rc));
+        AssertMsgFailed(("Could not open host device %s, rc=%Vrc\n", pThis->pszDevicePath, rc));
         switch (rc)
         {
@@ -984 +984 @@
                                               "of that device"),
 #endif
-                                           pData->pszDevicePath, pData->pszDevicePath);
+                                           pThis->pszDevicePath, pThis->pszDevicePath);
            default:
                 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
                                            N_("Failed to open host device '%s'"),
-                                           pData->pszDevicePath);
+                                           pThis->pszDevicePath);
         }
     }
@@ -995 +995 @@
 #ifdef RT_OS_LINUX
 
-    fcntl(pData->DeviceFile, F_SETFL, O_NONBLOCK);
+    fcntl(pThis->DeviceFile, F_SETFL, O_NONBLOCK);
     int aFDs[2];
     if (pipe(aFDs) != 0)
@@ -1003 +1003 @@
         return rc;
     }
-    pData->WakeupPipeR = aFDs[0];
-    pData->WakeupPipeW = aFDs[1];
+    pThis->WakeupPipeR = aFDs[0];
+    pThis->WakeupPipeW = aFDs[1];
 
 #elif defined(RT_OS_WINDOWS)
@@ -1017 +1017 @@
     comTimeout.WriteTotalTimeoutConstant   = 0;
 
-    SetCommTimeouts(pData->hDeviceFile, &comTimeout);
+    SetCommTimeouts(pThis->hDeviceFile, &comTimeout);
 
 #endif
@@ -1024 +1024 @@
      * Get the ICharPort interface of the above driver/device.
      */
-    pData->pDrvCharPort = (PPDMICHARPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_CHAR_PORT);
-    if (!pData->pDrvCharPort)
+    pThis->pDrvCharPort = (PPDMICHARPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_CHAR_PORT);
+    if (!pThis->pDrvCharPort)
         return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("HostSerial#%d has no char port interface above"), pDrvIns->iInstance);
 
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pRecvThread, pData, drvHostSerialRecvThread, drvHostSerialWakeupRecvThread, 0, RTTHREADTYPE_IO, "SerRecv");
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvHostSerialRecvThread, drvHostSerialWakeupRecvThread, 0, RTTHREADTYPE_IO, "SerRecv");
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create receive thread"), pDrvIns->iInstance);
 
-    rc = RTSemEventCreate(&pData->SendSem);
+    rc = RTSemEventCreate(&pThis->SendSem);
     AssertRC(rc);
 
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pSendThread, pData, drvHostSerialSendThread, drvHostSerialWakeupSendThread, 0, RTTHREADTYPE_IO, "SerSend");
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pSendThread, pThis, drvHostSerialSendThread, drvHostSerialWakeupSendThread, 0, RTTHREADTYPE_IO, "SerSend");
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create send thread"), pDrvIns->iInstance);
@@ -1041 +1041 @@
 #if defined(RT_OS_LINUX)
     /* Linux needs a separate thread which monitors the status lines. */
-    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pData->pMonitorThread, pData, drvHostSerialMonitorThread, drvHostSerialWakeupMonitorThread, 0, RTTHREADTYPE_IO, "SerMon");
+    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pMonitorThread, pThis, drvHostSerialMonitorThread, drvHostSerialWakeupMonitorThread, 0, RTTHREADTYPE_IO, "SerMon");
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create monitor thread"), pDrvIns->iInstance);
 #endif
 
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesWritten,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written",         "/Devices/HostSerial%d/Written", pDrvIns->iInstance);
-    PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesRead,       STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read",            "/Devices/HostSerial%d/Read", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written",         "/Devices/HostSerial%d/Written", pDrvIns->iInstance);
+    PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead,       STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read",            "/Devices/HostSerial%d/Read", pDrvIns->iInstance);
 
     return VINF_SUCCESS;
@@ -1063 +1063 @@
 static DECLCALLBACK(void) drvHostSerialDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVHOSTSERIAL pData = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
+    PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
 
     LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
 
     /* Empty the send queue */
-    pData->iSendQueueTail = pData->iSendQueueHead = 0;
-
-    RTSemEventDestroy(pData->SendSem);
-    pData->SendSem = NIL_RTSEMEVENT;
+    pThis->iSendQueueTail = pThis->iSendQueueHead = 0;
+
+    RTSemEventDestroy(pThis->SendSem);
+    pThis->SendSem = NIL_RTSEMEVENT;
 
 #if defined(RT_OS_LINUX)
 
-    if (pData->WakeupPipeW != NIL_RTFILE)
+    if (pThis->WakeupPipeW != NIL_RTFILE)
     {
-        int rc = RTFileClose(pData->WakeupPipeW);
+        int rc = RTFileClose(pThis->WakeupPipeW);
         AssertRC(rc);
-        pData->WakeupPipeW = NIL_RTFILE;
-    }
-    if (pData->WakeupPipeR != NIL_RTFILE)
+        pThis->WakeupPipeW = NIL_RTFILE;
+    }
+    if (pThis->WakeupPipeR != NIL_RTFILE)
     {
-        int rc = RTFileClose(pData->WakeupPipeR);
+        int rc = RTFileClose(pThis->WakeupPipeR);
         AssertRC(rc);
-        pData->WakeupPipeR = NIL_RTFILE;
-    }
-    if (pData->DeviceFile != NIL_RTFILE)
+        pThis->WakeupPipeR = NIL_RTFILE;
+    }
+    if (pThis->DeviceFile != NIL_RTFILE)
     {
-        int rc = RTFileClose(pData->DeviceFile);
+        int rc = RTFileClose(pThis->DeviceFile);
         AssertRC(rc);
-        pData->DeviceFile = NIL_RTFILE;
+        pThis->DeviceFile = NIL_RTFILE;
     }
 
 #elif defined(RT_OS_WINDOWS)
 
-    CloseHandle(pData->hEventRecv);
-    CloseHandle(pData->hEventSend);
-    CancelIo(pData->hDeviceFile);
-    CloseHandle(pData->hDeviceFile);
+    CloseHandle(pThis->hEventRecv);
+    CloseHandle(pThis->hEventSend);
+    CancelIo(pThis->hDeviceFile);
+    CloseHandle(pThis->hDeviceFile);
 
 #endif

trunk/src/VBox/Devices/Serial/DrvNamedPipe.cpp

@@ -103 +103 @@
 {
     int rc = VINF_SUCCESS;
-    PDRVNAMEDPIPE pData = PDMISTREAM_2_DRVNAMEDPIPE(pInterface);
-    LogFlow(("%s: pvBuf=%p cbRead=%#x (%s)\n", __FUNCTION__, pvBuf, cbRead, pData->pszLocation));
+    PDRVNAMEDPIPE pThis = PDMISTREAM_2_DRVNAMEDPIPE(pInterface);
+    LogFlow(("%s: pvBuf=%p cbRead=%#x (%s)\n", __FUNCTION__, pvBuf, cbRead, pThis->pszLocation));
 
     Assert(pvBuf);
 #ifdef RT_OS_WINDOWS
-    if (pData->NamedPipe != INVALID_HANDLE_VALUE)
+    if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
     {
         DWORD cbReallyRead;
-        pData->OverlappedRead.Offset     = 0;
-        pData->OverlappedRead.OffsetHigh = 0;
-        if (!ReadFile(pData->NamedPipe, pvBuf, *cbRead, &cbReallyRead, &pData->OverlappedRead))
+        pThis->OverlappedRead.Offset     = 0;
+        pThis->OverlappedRead.OffsetHigh = 0;
+        if (!ReadFile(pThis->NamedPipe, pvBuf, *cbRead, &cbReallyRead, &pThis->OverlappedRead))
         {
             DWORD uError = GetLastError();
@@ -133 +133 @@
 
                     /* Wait for incoming bytes. */
-                    if (GetOverlappedResult(pData->NamedPipe, &pData->OverlappedRead, &cbReallyRead, TRUE) == FALSE)
+                    if (GetOverlappedResult(pThis->NamedPipe, &pThis->OverlappedRead, &cbReallyRead, TRUE) == FALSE)
                         uError = GetLastError();
                 }
@@ -144 +144 @@
         if (RT_FAILURE(rc))
         {
-            Log(("drvNamedPipeRead: FileRead returned %Vrc fShutdown=%d\n", rc, pData->fShutdown));
-            if (    !pData->fShutdown
+            Log(("drvNamedPipeRead: FileRead returned %Vrc fShutdown=%d\n", rc, pThis->fShutdown));
+            if (    !pThis->fShutdown
                 &&  (   rc == VERR_EOF
                      || rc == VERR_BROKEN_PIPE
@@ -152 +152 @@
 
             {
-                FlushFileBuffers(pData->NamedPipe);
-                DisconnectNamedPipe(pData->NamedPipe);
-                if (!pData->fIsServer)
+                FlushFileBuffers(pThis->NamedPipe);
+                DisconnectNamedPipe(pThis->NamedPipe);
+                if (!pThis->fIsServer)
                 {
-                    CloseHandle(pData->NamedPipe);
-                    pData->NamedPipe = INVALID_HANDLE_VALUE;
+                    CloseHandle(pThis->NamedPipe);
+                    pThis->NamedPipe = INVALID_HANDLE_VALUE;
                 }
                 /* pretend success */
@@ -167 +167 @@
     }
 #else /* !RT_OS_WINDOWS */
-    if (pData->LocalSocket != NIL_RTSOCKET)
+    if (pThis->LocalSocket != NIL_RTSOCKET)
     {
         ssize_t cbReallyRead;
-        cbReallyRead = recv(pData->LocalSocket, pvBuf, *cbRead, 0);
+        cbReallyRead = recv(pThis->LocalSocket, pvBuf, *cbRead, 0);
         if (cbReallyRead == 0)
         {
-            RTSOCKET tmp = pData->LocalSocket;
-            pData->LocalSocket = NIL_RTSOCKET;
+            RTSOCKET tmp = pThis->LocalSocket;
+            pThis->LocalSocket = NIL_RTSOCKET;
             close(tmp);
         }
@@ -200 +200 @@
 {
     int rc = VINF_SUCCESS;
-    PDRVNAMEDPIPE pData = PDMISTREAM_2_DRVNAMEDPIPE(pInterface);
-    LogFlow(("%s: pvBuf=%p cbWrite=%#x (%s)\n", __FUNCTION__, pvBuf, cbWrite, pData->pszLocation));
+    PDRVNAMEDPIPE pThis = PDMISTREAM_2_DRVNAMEDPIPE(pInterface);
+    LogFlow(("%s: pvBuf=%p cbWrite=%#x (%s)\n", __FUNCTION__, pvBuf, cbWrite, pThis->pszLocation));
 
     Assert(pvBuf);
 #ifdef RT_OS_WINDOWS
-    if (pData->NamedPipe != INVALID_HANDLE_VALUE)
+    if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
     {
         unsigned cbWritten;
-        pData->OverlappedWrite.Offset     = 0;
-        pData->OverlappedWrite.OffsetHigh = 0;
-        if (!WriteFile(pData->NamedPipe, pvBuf, *cbWrite, NULL, &pData->OverlappedWrite))
+        pThis->OverlappedWrite.Offset     = 0;
+        pThis->OverlappedWrite.OffsetHigh = 0;
+        if (!WriteFile(pThis->NamedPipe, pvBuf, *cbWrite, NULL, &pThis->OverlappedWrite))
         {
             DWORD uError = GetLastError();
@@ -229 +229 @@
             {
                 /* Wait for the write to complete. */
-                if (GetOverlappedResult(pData->NamedPipe, &pData->OverlappedWrite, (DWORD *)&cbWritten, TRUE) == FALSE)
+                if (GetOverlappedResult(pThis->NamedPipe, &pThis->OverlappedWrite, (DWORD *)&cbWritten, TRUE) == FALSE)
                     uError = GetLastError();
             }
@@ -241 +241 @@
                 ||  rc == VERR_BROKEN_PIPE)
             {
-                FlushFileBuffers(pData->NamedPipe);
-                DisconnectNamedPipe(pData->NamedPipe);
-                if (!pData->fIsServer)
+                FlushFileBuffers(pThis->NamedPipe);
+                DisconnectNamedPipe(pThis->NamedPipe);
+                if (!pThis->fIsServer)
                 {
-                    CloseHandle(pData->NamedPipe);
-                    pData->NamedPipe = INVALID_HANDLE_VALUE;
+                    CloseHandle(pThis->NamedPipe);
+                    pThis->NamedPipe = INVALID_HANDLE_VALUE;
                 }
                 /* pretend success */
@@ -256 +256 @@
     }
 #else /* !RT_OS_WINDOWS */
-    if (pData->LocalSocket != NIL_RTSOCKET)
+    if (pThis->LocalSocket != NIL_RTSOCKET)
     {
         ssize_t cbWritten;
-        cbWritten = send(pData->LocalSocket, pvBuf, *cbWrite, 0);
+        cbWritten = send(pThis->LocalSocket, pvBuf, *cbWrite, 0);
         if (cbWritten == 0)
         {
-            RTSOCKET tmp = pData->LocalSocket;
-            pData->LocalSocket = NIL_RTSOCKET;
+            RTSOCKET tmp = pThis->LocalSocket;
+            pThis->LocalSocket = NIL_RTSOCKET;
             close(tmp);
         }
@@ -316 +316 @@
 static DECLCALLBACK(int) drvNamedPipeListenLoop(RTTHREAD ThreadSelf, void *pvUser)
 {
-    PDRVNAMEDPIPE   pData = (PDRVNAMEDPIPE)pvUser;
+    PDRVNAMEDPIPE   pThis = (PDRVNAMEDPIPE)pvUser;
     int             rc = VINF_SUCCESS;
 #ifdef RT_OS_WINDOWS
-    HANDLE          NamedPipe = pData->NamedPipe;
+    HANDLE          NamedPipe = pThis->NamedPipe;
     HANDLE          hEvent = CreateEvent(NULL, TRUE, FALSE, 0);
 #endif
 
-    while (RT_LIKELY(!pData->fShutdown))
+    while (RT_LIKELY(!pThis->fShutdown))
     {
 #ifdef RT_OS_WINDOWS
@@ -333 +333 @@
         BOOL fConnected = ConnectNamedPipe(NamedPipe, &overlapped);
         if (    !fConnected
-            &&  !pData->fShutdown)
+            &&  !pThis->fShutdown)
         {
             DWORD hrc = GetLastError();
@@ -342 +342 @@
 
                 hrc = 0;
-                if (GetOverlappedResult(pData->NamedPipe, &overlapped, &dummy, TRUE) == FALSE)
+                if (GetOverlappedResult(pThis->NamedPipe, &overlapped, &dummy, TRUE) == FALSE)
                     hrc = GetLastError();
 
             }
 
-            if (pData->fShutdown)
+            if (pThis->fShutdown)
                 break;
 
             if (hrc == ERROR_PIPE_CONNECTED)
             {
-                RTSemEventWait(pData->ListenSem, 250);
+                RTSemEventWait(pThis->ListenSem, 250);
             }
             else if (hrc != ERROR_SUCCESS)
             {
                 rc = RTErrConvertFromWin32(hrc);
-                LogRel(("NamedPipe%d: ConnectNamedPipe failed, rc=%Vrc\n", pData->pDrvIns->iInstance, rc));
+                LogRel(("NamedPipe%d: ConnectNamedPipe failed, rc=%Vrc\n", pThis->pDrvIns->iInstance, rc));
                 break;
             }
         }
 #else /* !RT_OS_WINDOWS */
-        if (listen(pData->LocalSocketServer, 0) == -1)
+        if (listen(pThis->LocalSocketServer, 0) == -1)
         {
             rc = RTErrConvertFromErrno(errno);
-            LogRel(("NamedPipe%d: listen failed, rc=%Vrc\n", pData->pDrvIns->iInstance, rc));
+            LogRel(("NamedPipe%d: listen failed, rc=%Vrc\n", pThis->pDrvIns->iInstance, rc));
             break;
         }
-        int s = accept(pData->LocalSocketServer, NULL, NULL);
+        int s = accept(pThis->LocalSocketServer, NULL, NULL);
         if (s == -1)
         {
             rc = RTErrConvertFromErrno(errno);
-            LogRel(("NamedPipe%d: accept failed, rc=%Vrc\n", pData->pDrvIns->iInstance, rc));
+            LogRel(("NamedPipe%d: accept failed, rc=%Vrc\n", pThis->pDrvIns->iInstance, rc));
             break;
         }
         else
         {
-            if (pData->LocalSocket != NIL_RTSOCKET)
-            {
-                LogRel(("NamedPipe%d: only single connection supported\n", pData->pDrvIns->iInstance));
+            if (pThis->LocalSocket != NIL_RTSOCKET)
+            {
+                LogRel(("NamedPipe%d: only single connection supported\n", pThis->pDrvIns->iInstance));
                 close(s);
             }
             else
-                pData->LocalSocket = s;
+                pThis->LocalSocket = s;
         }
 #endif /* !RT_OS_WINDOWS */
@@ -391 +391 @@
     CloseHandle(hEvent);
 #endif
-    pData->ListenThread = NIL_RTTHREAD;
+    pThis->ListenThread = NIL_RTTHREAD;
     return VINF_SUCCESS;
 }
@@ -410 +410 @@
     int rc;
     char *pszLocation = NULL;
-    PDRVNAMEDPIPE pData = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
+    PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
 
     /*
      * Init the static parts.
      */
-    pData->pDrvIns                      = pDrvIns;
-    pData->pszLocation                  = NULL;
-    pData->fIsServer                    = false;
-#ifdef RT_OS_WINDOWS
-    pData->NamedPipe                    = INVALID_HANDLE_VALUE;
-#else /* !RT_OS_WINDOWS */
-    pData->LocalSocketServer            = NIL_RTSOCKET;
-    pData->LocalSocket                  = NIL_RTSOCKET;
-#endif /* !RT_OS_WINDOWS */
-    pData->ListenThread                 = NIL_RTTHREAD;
-    pData->fShutdown                    = false;
+    pThis->pDrvIns                      = pDrvIns;
+    pThis->pszLocation                  = NULL;
+    pThis->fIsServer                    = false;
+#ifdef RT_OS_WINDOWS
+    pThis->NamedPipe                    = INVALID_HANDLE_VALUE;
+#else /* !RT_OS_WINDOWS */
+    pThis->LocalSocketServer            = NIL_RTSOCKET;
+    pThis->LocalSocket                  = NIL_RTSOCKET;
+#endif /* !RT_OS_WINDOWS */
+    pThis->ListenThread                 = NIL_RTTHREAD;
+    pThis->fShutdown                    = false;
     /* IBase */
     pDrvIns->IBase.pfnQueryInterface    = drvNamedPipeQueryInterface;
     /* IStream */
-    pData->IStream.pfnRead              = drvNamedPipeRead;
-    pData->IStream.pfnWrite             = drvNamedPipeWrite;
+    pThis->IStream.pfnRead              = drvNamedPipeRead;
+    pThis->IStream.pfnWrite             = drvNamedPipeWrite;
 
     /*
@@ -447 +447 @@
         goto out;
     }
-    pData->pszLocation = pszLocation;
+    pThis->pszLocation = pszLocation;
 
     bool fIsServer;
@@ -456 +456 @@
         goto out;
     }
-    pData->fIsServer = fIsServer;
+    pThis->fIsServer = fIsServer;
 
 #ifdef RT_OS_WINDOWS
     if (fIsServer)
     {
-        HANDLE hPipe = CreateNamedPipe(pData->pszLocation, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 32, 32, 10000, NULL);
+        HANDLE hPipe = CreateNamedPipe(pThis->pszLocation, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 32, 32, 10000, NULL);
         if (hPipe == INVALID_HANDLE_VALUE)
         {
             rc = RTErrConvertFromWin32(GetLastError());
-            LogRel(("NamedPipe%d: CreateNamedPipe failed rc=%Vrc\n", pData->pDrvIns->iInstance));
+            LogRel(("NamedPipe%d: CreateNamedPipe failed rc=%Vrc\n", pThis->pDrvIns->iInstance));
             return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NamedPipe#%d failed to create named pipe %s"), pDrvIns->iInstance, pszLocation);
         }
-        pData->NamedPipe = hPipe;
-
-        rc = RTSemEventCreate(&pData->ListenSem);
+        pThis->NamedPipe = hPipe;
+
+        rc = RTSemEventCreate(&pThis->ListenSem);
         AssertRC(rc);
 
-        rc = RTThreadCreate(&pData->ListenThread, drvNamedPipeListenLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
+        rc = RTThreadCreate(&pThis->ListenThread, drvNamedPipeListenLoop, (void *)pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
         if RT_FAILURE(rc)
             return PDMDrvHlpVMSetError(pDrvIns, rc,  RT_SRC_POS, N_("NamedPipe#%d failed to create listening thread"), pDrvIns->iInstance);
@@ -481 +481 @@
     {
         /* Connect to the named pipe. */
-        HANDLE hPipe = CreateFile(pData->pszLocation, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+        HANDLE hPipe = CreateFile(pThis->pszLocation, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
         if (hPipe == INVALID_HANDLE_VALUE)
         {
             rc = RTErrConvertFromWin32(GetLastError());
-            LogRel(("NamedPipe%d: CreateFile failed rc=%Vrc\n", pData->pDrvIns->iInstance));
+            LogRel(("NamedPipe%d: CreateFile failed rc=%Vrc\n", pThis->pDrvIns->iInstance));
             return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("NamedPipe#%d failed to connect to named pipe %s"), pDrvIns->iInstance, pszLocation);
         }
-        pData->NamedPipe = hPipe;
-    }
-
-    memset(&pData->OverlappedWrite, 0, sizeof(pData->OverlappedWrite));
-    memset(&pData->OverlappedRead, 0, sizeof(pData->OverlappedRead));
-    pData->OverlappedWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-    pData->OverlappedRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+        pThis->NamedPipe = hPipe;
+    }
+
+    memset(&pThis->OverlappedWrite, 0, sizeof(pThis->OverlappedWrite));
+    memset(&pThis->OverlappedRead, 0, sizeof(pThis->OverlappedRead));
+    pThis->OverlappedWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    pThis->OverlappedRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 #else /* !RT_OS_WINDOWS */
     int s;
@@ -512 +512 @@
         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1)
             return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS, N_("NamedPipe#%d failed to bind to local socket %s"), pDrvIns->iInstance, pszLocation);
-        pData->LocalSocketServer = s;
-        rc = RTThreadCreate(&pData->ListenThread, drvNamedPipeListenLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
+        pThis->LocalSocketServer = s;
+        rc = RTThreadCreate(&pThis->ListenThread, drvNamedPipeListenLoop, (void *)pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SerPipe");
         if RT_FAILURE(rc)
             return PDMDrvHlpVMSetError(pDrvIns, rc,  RT_SRC_POS, N_("NamedPipe#%d failed to create listening thread"), pDrvIns->iInstance);
@@ -522 +522 @@
         if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) == -1)
             return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS, N_("NamedPipe#%d failed to connect to local socket %s"), pDrvIns->iInstance, pszLocation);
-        pData->LocalSocket = s;
+        pThis->LocalSocket = s;
     }
 #endif /* !RT_OS_WINDOWS */
@@ -550 +550 @@
 static DECLCALLBACK(void) drvNamedPipeDestruct(PPDMDRVINS pDrvIns)
 {
-    PDRVNAMEDPIPE pData = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
-    LogFlow(("%s: %s\n", __FUNCTION__, pData->pszLocation));
-
-    if (pData->ListenThread)
-    {
-        RTThreadWait(pData->ListenThread, 250, NULL);
-        if (pData->ListenThread != NIL_RTTHREAD)
+    PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
+    LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
+
+    if (pThis->ListenThread)
+    {
+        RTThreadWait(pThis->ListenThread, 250, NULL);
+        if (pThis->ListenThread != NIL_RTTHREAD)
             LogRel(("NamedPipe%d: listen thread did not terminate\n", pDrvIns->iInstance));
     }
 
-    if (pData->pszLocation)
-        MMR3HeapFree(pData->pszLocation);
+    if (pThis->pszLocation)
+        MMR3HeapFree(pThis->pszLocation);
 }
 
@@ -574 +574 @@
 static DECLCALLBACK(void) drvNamedPipePowerOff(PPDMDRVINS pDrvIns)
 {
-    PDRVNAMEDPIPE pData = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
-    LogFlow(("%s: %s\n", __FUNCTION__, pData->pszLocation));
-
-    pData->fShutdown = true;
-
-#ifdef RT_OS_WINDOWS
-    if (pData->NamedPipe != INVALID_HANDLE_VALUE)
-    {
-        if (pData->fIsServer)
-        {
-            FlushFileBuffers(pData->NamedPipe);
-            DisconnectNamedPipe(pData->NamedPipe);
-        }
-
-        CloseHandle(pData->NamedPipe);
-        pData->NamedPipe = INVALID_HANDLE_VALUE;
-        CloseHandle(pData->OverlappedRead.hEvent);
-        CloseHandle(pData->OverlappedWrite.hEvent);
-    }
-    if (pData->fIsServer)
+    PDRVNAMEDPIPE pThis = PDMINS_2_DATA(pDrvIns, PDRVNAMEDPIPE);
+    LogFlow(("%s: %s\n", __FUNCTION__, pThis->pszLocation));
+
+    pThis->fShutdown = true;
+
+#ifdef RT_OS_WINDOWS
+    if (pThis->NamedPipe != INVALID_HANDLE_VALUE)
+    {
+        if (pThis->fIsServer)
+        {
+            FlushFileBuffers(pThis->NamedPipe);
+            DisconnectNamedPipe(pThis->NamedPipe);
+        }
+
+        CloseHandle(pThis->NamedPipe);
+        pThis->NamedPipe = INVALID_HANDLE_VALUE;
+        CloseHandle(pThis->OverlappedRead.hEvent);
+        CloseHandle(pThis->OverlappedWrite.hEvent);
+    }
+    if (pThis->fIsServer)
     {
         /* Wake up listen thread */
-        RTSemEventSignal(pData->ListenSem);
-        RTSemEventDestroy(pData->ListenSem);
-    }
-#else /* !RT_OS_WINDOWS */
-    if (pData->fIsServer)
-    {
-        if (pData->LocalSocketServer != NIL_RTSOCKET)
-            close(pData->LocalSocketServer);
-        if (pData->pszLocation)
-            RTFileDelete(pData->pszLocation);
+        RTSemEventSignal(pThis->ListenSem);
+        RTSemEventDestroy(pThis->ListenSem);
+    }
+#else /* !RT_OS_WINDOWS */
+    if (pThis->fIsServer)
+    {
+        if (pThis->LocalSocketServer != NIL_RTSOCKET)
+            close(pThis->LocalSocketServer);
+        if (pThis->pszLocation)
+            RTFileDelete(pThis->pszLocation);
     }
     else
     {
-        if (pData->LocalSocket != NIL_RTSOCKET)
-            close(pData->LocalSocket);
+        if (pThis->LocalSocket != NIL_RTSOCKET)
+            close(pThis->LocalSocket);
     }
 #endif /* !RT_OS_WINDOWS */

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. */

trunk/src/VBox/Devices/VMMDev/VBoxDev.cpp

@@ -284 +284 @@
 static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState *);
-
-    if (!pData->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
+
+    if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
     {
 
@@ -301 +301 @@
         if (u32 == '\n' || u32 == '\r')
         {
-            pData->szMsg[pData->iMsg] = '\0';
-            if (pData->iMsg)
-                LogRel(("Guest Log: %s\n", pData->szMsg));
-            pData->iMsg = 0;
+            pThis->szMsg[pThis->iMsg] = '\0';
+            if (pThis->iMsg)
+                LogRel(("Guest Log: %s\n", pThis->szMsg));
+            pThis->iMsg = 0;
         }
         else
         {
-            if (pData->iMsg >= sizeof(pData->szMsg)-1)
-            {
-                pData->szMsg[pData->iMsg] = '\0';
-                LogRel(("Guest Log: %s\n", pData->szMsg));
-                pData->iMsg = 0;
-            }
-            pData->szMsg[pData->iMsg] = (char )u32;
-            pData->szMsg[++pData->iMsg] = '\0';
+            if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
+            {
+                pThis->szMsg[pThis->iMsg] = '\0';
+                LogRel(("Guest Log: %s\n", pThis->szMsg));
+                pThis->iMsg = 0;
+            }
+            pThis->szMsg[pThis->iMsg] = (char )u32;
+            pThis->szMsg[++pThis->iMsg] = '\0';
         }
     }
@@ -340 +340 @@
     if (cb == 4)
     {
-        VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState *);
+        VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
         switch (u32)
         {
             case 0:
-                pData->fTimesyncBackdoorLo = false;
+                pThis->fTimesyncBackdoorLo = false;
                 break;
             case 1:
-                pData->fTimesyncBackdoorLo = true;
+                pThis->fTimesyncBackdoorLo = true;
         }
         return VINF_SUCCESS;
@@ -372 +372 @@
     if (cb == 4)
     {
-        VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState *);
+        VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
         RTTIMESPEC now;
 
-        if (pData->fTimesyncBackdoorLo)
-        {
-            *pu32 = (uint32_t)(pData->hostTime & (uint64_t)0xFFFFFFFF);
+        if (pThis->fTimesyncBackdoorLo)
+        {
+            *pu32 = (uint32_t)(pThis->hostTime & (uint64_t)0xFFFFFFFF);
         }
         else
         {
-            pData->hostTime = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
-            *pu32 = (uint32_t)(pData->hostTime >> 32);
+            pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
+            *pu32 = (uint32_t)(pThis->hostTime >> 32);
         }
         rc = VINF_SUCCESS;
@@ -398 +398 @@
 static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    VMMDevState *pData = (VMMDevState*)pvUser;
+    VMMDevState *pThis = (VMMDevState*)pvUser;
     int rcRet = VINF_SUCCESS;
 
@@ -429 +429 @@
 
     if (    requestHeader.requestType != VMMDevReq_ReportGuestInfo
-        && !pData->fu32AdditionsOk)
+        && !pThis->fu32AdditionsOk)
     {
         Log(("VMMDev: guest has not yet reported to us. Refusing operation.\n"));
@@ -484 +484 @@
                 VMMDevReportGuestInfo *guestInfo = (VMMDevReportGuestInfo*)pRequestHeader;
 
-                if (memcmp (&pData->guestInfo, &guestInfo->guestInfo, sizeof (guestInfo->guestInfo)) != 0)
+                if (memcmp (&pThis->guestInfo, &guestInfo->guestInfo, sizeof (guestInfo->guestInfo)) != 0)
                 {
                     /* make a copy of supplied information */
-                    pData->guestInfo = guestInfo->guestInfo;
+                    pThis->guestInfo = guestInfo->guestInfo;
 
                     /* Check additions version */
-                    pData->fu32AdditionsOk = VBOX_GUEST_ADDITIONS_VERSION_OK(pData->guestInfo.additionsVersion);
+                    pThis->fu32AdditionsOk = VBOX_GUEST_ADDITIONS_VERSION_OK(pThis->guestInfo.additionsVersion);
 
                     LogRel(("Guest Additions information report: additionsVersion = 0x%08X  osType = 0x%08X\n",
-                            pData->guestInfo.additionsVersion,
-                            pData->guestInfo.osType));
-                    pData->pDrv->pfnUpdateGuestVersion(pData->pDrv, &pData->guestInfo);
-                }
-
-                if (pData->fu32AdditionsOk)
+                            pThis->guestInfo.additionsVersion,
+                            pThis->guestInfo.osType));
+                    pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
+                }
+
+                if (pThis->fu32AdditionsOk)
                 {
                     pRequestHeader->rc = VINF_SUCCESS;
@@ -526 +526 @@
                 /** @todo change this when we next bump the interface version */
                 guestCaps->caps |= VMMDEV_GUEST_SUPPORTS_GRAPHICS;
-                if (pData->guestCaps != guestCaps->caps)
+                if (pThis->guestCaps != guestCaps->caps)
                 {
                     /* make a copy of supplied information */
-                    pData->guestCaps = guestCaps->caps;
+                    pThis->guestCaps = guestCaps->caps;
 
                     LogRel(("Guest Additions capability report: (0x%x) "
@@ -540 +540 @@
                             guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
 
-                    pData->pDrv->pfnUpdateGuestCapabilities(pData->pDrv, guestCaps->caps);
+                    pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, guestCaps->caps);
                 }
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -559 +559 @@
                 VMMDevReqGuestCapabilities2 *guestCaps = (VMMDevReqGuestCapabilities2*)pRequestHeader;
 
-                pData->guestCaps |= guestCaps->u32OrMask;
-                pData->guestCaps &= ~guestCaps->u32NotMask;
+                pThis->guestCaps |= guestCaps->u32OrMask;
+                pThis->guestCaps &= ~guestCaps->u32NotMask;
 
                 LogRel(("Guest Additions capability report: (0x%x) "
@@ -566 +566 @@
                         "hostWindowMapping: %s, "
                         "graphics: %s\n",
-                        pData->guestCaps,
-                        pData->guestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
-                        pData->guestCaps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
-                        pData->guestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
-
-                pData->pDrv->pfnUpdateGuestCapabilities(pData->pDrv, pData->guestCaps);
+                        pThis->guestCaps,
+                        pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
+                        pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
+                        pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
+
+                pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
                 pRequestHeader->rc = VINF_SUCCESS;
             }
@@ -591 +591 @@
                 VMMDevReqMouseStatus *mouseStatus = (VMMDevReqMouseStatus*)pRequestHeader;
                 mouseStatus->mouseFeatures = 0;
-                if (pData->mouseCapabilities & VMMDEV_MOUSEHOSTWANTSABS)
+                if (pThis->mouseCapabilities & VMMDEV_MOUSEHOSTWANTSABS)
                 {
                     mouseStatus->mouseFeatures |= VBOXGUEST_MOUSE_HOST_CAN_ABSOLUTE;
                 }
-                if (pData->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS)
+                if (pThis->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS)
                 {
                     mouseStatus->mouseFeatures |= VBOXGUEST_MOUSE_GUEST_CAN_ABSOLUTE;
                 }
-                if (pData->mouseCapabilities & VMMDEV_MOUSEHOSTCANNOTHWPOINTER)
+                if (pThis->mouseCapabilities & VMMDEV_MOUSEHOSTCANNOTHWPOINTER)
                 {
                     mouseStatus->mouseFeatures |= VBOXGUEST_MOUSE_HOST_CANNOT_HWPOINTER;
                 }
-                mouseStatus->pointerXPos = pData->mouseXAbs;
-                mouseStatus->pointerYPos = pData->mouseYAbs;
+                mouseStatus->pointerXPos = pThis->mouseXAbs;
+                mouseStatus->pointerYPos = pThis->mouseYAbs;
                 Log2(("returning mouse status: features = %d, absX = %d, absY = %d\n", mouseStatus->mouseFeatures,
                       mouseStatus->pointerXPos, mouseStatus->pointerYPos));
@@ -633 +633 @@
                 {
                     /* set the capability flag and the changed flag if it's actually a change */
-                    if (!(pData->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS))
+                    if (!(pThis->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS))
                     {
-                        pData->mouseCapabilities |= VMMDEV_MOUSEGUESTWANTSABS;
+                        pThis->mouseCapabilities |= VMMDEV_MOUSEGUESTWANTSABS;
                         bCapsChanged = true;
                         LogRel(("Guest requests mouse pointer integration\n"));
@@ -641 +641 @@
                 } else
                 {
-                    if (pData->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS)
+                    if (pThis->mouseCapabilities & VMMDEV_MOUSEGUESTWANTSABS)
                     {
-                        pData->mouseCapabilities &= ~VMMDEV_MOUSEGUESTWANTSABS;
+                        pThis->mouseCapabilities &= ~VMMDEV_MOUSEGUESTWANTSABS;
                         bCapsChanged = true;
                         LogRel(("Guest disables mouse pointer integration\n"));
@@ -649 +649 @@
                 }
                 if (mouseStatus->mouseFeatures & VBOXGUEST_MOUSE_GUEST_NEEDS_HOST_CURSOR)
-                    pData->mouseCapabilities |= VMMDEV_MOUSEGUESTNEEDSHOSTCUR;
+                    pThis->mouseCapabilities |= VMMDEV_MOUSEGUESTNEEDSHOSTCUR;
                 else
-                    pData->mouseCapabilities &= ~VMMDEV_MOUSEGUESTNEEDSHOSTCUR;
+                    pThis->mouseCapabilities &= ~VMMDEV_MOUSEGUESTNEEDSHOSTCUR;
 
                 /*
@@ -658 +658 @@
                 if (bCapsChanged)
                 {
-                    Log(("VMMDevReq_SetMouseStatus: capabilities changed (%x), informing connector\n", pData->mouseCapabilities));
-                    pData->pDrv->pfnUpdateMouseCapabilities(pData->pDrv, pData->mouseCapabilities);
+                    Log(("VMMDevReq_SetMouseStatus: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
+                    pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
                 }
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -699 +699 @@
                 if (fShape)
                 {
-                    pData->pDrv->pfnUpdatePointerShape(pData->pDrv,
+                    pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
                                                        fVisible,
                                                        fAlpha,
@@ -708 +708 @@
                 else
                 {
-                    pData->pDrv->pfnUpdatePointerShape(pData->pDrv,
+                    pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
                                                        fVisible,
                                                        0,
@@ -730 +730 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (RT_UNLIKELY(pData->fGetHostTimeDisabled))
+            else if (RT_UNLIKELY(pThis->fGetHostTimeDisabled))
                 pRequestHeader->rc = VERR_NOT_SUPPORTED;
             else
@@ -863 +863 @@
                 {
                     /* Remember which resolution the client has queried, subsequent reads will return the same values. */
-                    pData->lastReadDisplayChangeRequest = pData->displayChangeRequest;
+                    pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
                 }
 
                 /* just pass on the information */
                 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
-                     pData->displayChangeRequest.xres, pData->displayChangeRequest.yres, pData->displayChangeRequest.bpp));
-                displayChangeRequest->xres = pData->lastReadDisplayChangeRequest.xres;
-                displayChangeRequest->yres = pData->lastReadDisplayChangeRequest.yres;
-                displayChangeRequest->bpp  = pData->lastReadDisplayChangeRequest.bpp;
+                     pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp));
+                displayChangeRequest->xres = pThis->lastReadDisplayChangeRequest.xres;
+                displayChangeRequest->yres = pThis->lastReadDisplayChangeRequest.yres;
+                displayChangeRequest->bpp  = pThis->lastReadDisplayChangeRequest.bpp;
 
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -891 +891 @@
                 {
                     /* Remember which resolution the client has queried, subsequent reads will return the same values. */
-                    pData->lastReadDisplayChangeRequest = pData->displayChangeRequest;
+                    pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
                 }
 
                 /* just pass on the information */
                 Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
-                     pData->displayChangeRequest.xres, pData->displayChangeRequest.yres, pData->displayChangeRequest.bpp, pData->displayChangeRequest.display));
-                displayChangeRequest->xres    = pData->lastReadDisplayChangeRequest.xres;
-                displayChangeRequest->yres    = pData->lastReadDisplayChangeRequest.yres;
-                displayChangeRequest->bpp     = pData->lastReadDisplayChangeRequest.bpp;
-                displayChangeRequest->display = pData->lastReadDisplayChangeRequest.display;
+                     pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp, pThis->displayChangeRequest.display));
+                displayChangeRequest->xres    = pThis->lastReadDisplayChangeRequest.xres;
+                displayChangeRequest->yres    = pThis->lastReadDisplayChangeRequest.yres;
+                displayChangeRequest->bpp     = pThis->lastReadDisplayChangeRequest.bpp;
+                displayChangeRequest->display = pThis->lastReadDisplayChangeRequest.display;
 
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -921 +921 @@
                 VMMDevVideoModeSupportedRequest *videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest*)pRequestHeader;
                 /* forward the call */
-                pRequestHeader->rc = pData->pDrv->pfnVideoModeSupported(pData->pDrv,
+                pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
                                                                        videoModeSupportedRequest->width,
                                                                        videoModeSupportedRequest->height,
@@ -944 +944 @@
                 VMMDevGetHeightReductionRequest *heightReductionRequest = (VMMDevGetHeightReductionRequest*)pRequestHeader;
                 /* forward the call */
-                pRequestHeader->rc = pData->pDrv->pfnGetHeightReduction(pData->pDrv,
+                pRequestHeader->rc = pThis->pDrv->pfnGetHeightReduction(pThis->pDrv,
                                                                        &heightReductionRequest->heightReduction);
             }
@@ -962 +962 @@
             else
             {
-                if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pData))
-                {
-                    vmmdevSetIRQ_Legacy_EMT (pData);
+                if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pThis))
+                {
+                    vmmdevSetIRQ_Legacy_EMT (pThis);
                 }
                 else
@@ -970 +970 @@
                     VMMDevEvents *pAckRequest;
 
-                    if (pData->fNewGuestFilterMask)
+                    if (pThis->fNewGuestFilterMask)
                     {
-                        pData->fNewGuestFilterMask = false;
-                        pData->u32GuestFilterMask = pData->u32NewGuestFilterMask;
+                        pThis->fNewGuestFilterMask = false;
+                        pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
                     }
 
                     pAckRequest = (VMMDevEvents *)pRequestHeader;
                     pAckRequest->events =
-                        pData->u32HostEventFlags & pData->u32GuestFilterMask;
-
-                    pData->u32HostEventFlags &= ~pData->u32GuestFilterMask;
-                    pData->pVMMDevRAMHC->V.V1_04.fHaveEvents = false;
-                    PDMDevHlpPCISetIrqNoWait (pData->pDevIns, 0, 0);
+                        pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
+
+                    pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
+                    pThis->pVMMDevRAMHC->V.V1_04.fHaveEvents = false;
+                    PDMDevHlpPCISetIrqNoWait (pThis->pDevIns, 0, 0);
                 }
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -1007 +1007 @@
                  * HGCM command is issued. The guest then can not disable these events.
                  */
-                vmmdevCtlGuestFilterMask_EMT (pData,
+                vmmdevCtlGuestFilterMask_EMT (pThis,
                                               pCtlMaskRequest->u32OrMask,
                                               pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
@@ -1027 +1027 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pHGCMDrv)
+            else if (!pThis->pHGCMDrv)
             {
                 Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
@@ -1038 +1038 @@
                 Log(("VMMDevReq_HGCMConnect\n"));
 
-                pRequestHeader->rc = vmmdevHGCMConnect (pData, pHGCMConnect, (RTGCPHYS)u32);
+                pRequestHeader->rc = vmmdevHGCMConnect (pThis, pHGCMConnect, (RTGCPHYS)u32);
             }
             break;
@@ -1050 +1050 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pHGCMDrv)
+            else if (!pThis->pHGCMDrv)
             {
                 Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
@@ -1060 +1060 @@
 
                 Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
-                pRequestHeader->rc = vmmdevHGCMDisconnect (pData, pHGCMDisconnect, (RTGCPHYS)u32);
+                pRequestHeader->rc = vmmdevHGCMDisconnect (pThis, pHGCMDisconnect, (RTGCPHYS)u32);
             }
             break;
@@ -1077 +1077 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pHGCMDrv)
+            else if (!pThis->pHGCMDrv)
             {
                 Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
@@ -1095 +1095 @@
 #endif /* VBOX_WITH_64_BITS_GUESTS */
 
-                pRequestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32, f64Bits);
+                pRequestHeader->rc = vmmdevHGCMCall (pThis, pHGCMCall, (RTGCPHYS)u32, f64Bits);
             }
             break;
@@ -1108 +1108 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pHGCMDrv)
+            else if (!pThis->pHGCMDrv)
             {
                 Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
@@ -1118 +1118 @@
 
                 Log(("VMMDevReq_VMMDevHGCMCancel\n"));
-                pRequestHeader->rc = vmmdevHGCMCancel (pData, pHGCMCancel, (RTGCPHYS)u32);
+                pRequestHeader->rc = vmmdevHGCMCancel (pThis, pHGCMCancel, (RTGCPHYS)u32);
             }
             break;
@@ -1130 +1130 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pDrv)
+            else if (!pThis->pDrv)
             {
                 Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
@@ -1153 +1153 @@
 
                     pRequestHeader->rc = ptr->u32Enable?
-                        pData->pDrv->pfnVideoAccelEnable (pData->pDrv, true, &pData->pVMMDevRAMHC->vbvaMemory):
-                        pData->pDrv->pfnVideoAccelEnable (pData->pDrv, false, NULL);
+                        pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, true, &pThis->pVMMDevRAMHC->vbvaMemory):
+                        pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, false, NULL);
 
                     if (   ptr->u32Enable
@@ -1164 +1164 @@
                          * We need to reestablish it on restoring the VM from saved state.
                          */
-                        pData->u32VideoAccelEnabled = 1;
+                        pThis->u32VideoAccelEnabled = 1;
                     }
                     else
                     {
                         /* The acceleration was not enabled. Remember that. */
-                        pData->u32VideoAccelEnabled = 0;
+                        pThis->u32VideoAccelEnabled = 0;
                     }
                 }
@@ -1183 +1183 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pDrv)
+            else if (!pThis->pDrv)
             {
                 Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
@@ -1190 +1190 @@
             else
             {
-                pData->pDrv->pfnVideoAccelFlush (pData->pDrv);
+                pThis->pDrv->pfnVideoAccelFlush (pThis->pDrv);
 
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -1204 +1204 @@
                 pRequestHeader->rc = VERR_INVALID_PARAMETER;
             }
-            else if (!pData->pDrv)
+            else if (!pThis->pDrv)
             {
                 Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
@@ -1228 +1228 @@
                     Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
                     /* forward the call */
-                    pRequestHeader->rc = pData->pDrv->pfnSetVisibleRegion(pData->pDrv, ptr->cRect, &ptr->Rect);
+                    pRequestHeader->rc = pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, ptr->cRect, &ptr->Rect);
                 }
             }
@@ -1244 +1244 @@
                 VMMDevSeamlessChangeRequest *seamlessChangeRequest = (VMMDevSeamlessChangeRequest*)pRequestHeader;
                 /* just pass on the information */
-                Log(("VMMDev: returning seamless change request mode=%d\n", pData->fSeamlessEnabled));
-                if (pData->fSeamlessEnabled)
+                Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
+                if (pThis->fSeamlessEnabled)
                     seamlessChangeRequest->mode = VMMDev_Seamless_Visible_Region;
                 else
@@ -1253 +1253 @@
                 {
                     /* Remember which mode the client has queried. */
-                    pData->fLastSeamlessEnabled = pData->fSeamlessEnabled;
+                    pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
                 }
 
@@ -1271 +1271 @@
                 VMMDevVRDPChangeRequest *vrdpChangeRequest = (VMMDevVRDPChangeRequest*)pRequestHeader;
                 /* just pass on the information */
-                Log(("VMMDev: returning VRDP status %d level %d\n", pData->fVRDPEnabled, pData->u32VRDPExperienceLevel));
-
-                vrdpChangeRequest->u8VRDPActive = pData->fVRDPEnabled;
-                vrdpChangeRequest->u32VRDPExperienceLevel = pData->u32VRDPExperienceLevel;
+                Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->u32VRDPExperienceLevel));
+
+                vrdpChangeRequest->u8VRDPActive = pThis->fVRDPEnabled;
+                vrdpChangeRequest->u32VRDPExperienceLevel = pThis->u32VRDPExperienceLevel;
 
                 pRequestHeader->rc = VINF_SUCCESS;
@@ -1293 +1293 @@
                 VMMDevGetMemBalloonChangeRequest *memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest*)pRequestHeader;
                 /* just pass on the information */
-                Log(("VMMDev: returning memory balloon size =%d\n", pData->u32MemoryBalloonSize));
-                memBalloonChangeRequest->u32BalloonSize = pData->u32MemoryBalloonSize;
-                memBalloonChangeRequest->u32PhysMemSize = pData->cbGuestRAM / (uint64_t)_1M;
+                Log(("VMMDev: returning memory balloon size =%d\n", pThis->u32MemoryBalloonSize));
+                memBalloonChangeRequest->u32BalloonSize = pThis->u32MemoryBalloonSize;
+                memBalloonChangeRequest->u32PhysMemSize = pThis->cbGuestRAM / (uint64_t)_1M;
 
                 if (memBalloonChangeRequest->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
                 {
                     /* Remember which mode the client has queried. */
-                    pData->u32LastMemoryBalloonSize = pData->u32MemoryBalloonSize;
+                    pThis->u32LastMemoryBalloonSize = pThis->u32MemoryBalloonSize;
                 }
 
@@ -1322 +1322 @@
             else
             {
-                pRequestHeader->rc = pData->pDrv->pfnChangeMemoryBalloon(pData->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
+                pRequestHeader->rc = pThis->pDrv->pfnChangeMemoryBalloon(pThis->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
             }
             break;
@@ -1339 +1339 @@
                 VMMDevGetStatisticsChangeRequest *statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest*)pRequestHeader;
                 /* just pass on the information */
-                Log(("VMMDev: returning statistics interval %d seconds\n", pData->u32StatIntervalSize));
-                statIntervalChangeRequest->u32StatInterval = pData->u32StatIntervalSize;
+                Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
+                statIntervalChangeRequest->u32StatInterval = pThis->u32StatIntervalSize;
 
                 if (statIntervalChangeRequest->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
                 {
                     /* Remember which mode the client has queried. */
-                    pData->u32LastStatIntervalSize= pData->u32StatIntervalSize;
+                    pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
                 }
 
@@ -1424 +1424 @@
 
                 /* forward the call */
-                pRequestHeader->rc = pData->pDrv->pfnReportStatistics(pData->pDrv, &stats->guestStats);
+                pRequestHeader->rc = pThis->pDrv->pfnReportStatistics(pThis->pDrv, &stats->guestStats);
             }
             break;
@@ -1448 +1448 @@
                 if (credentials->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
                 {
-                    if (   pData->credentialsLogon.szUserName[0]
-                        || pData->credentialsLogon.szPassword[0]
-                        || pData->credentialsLogon.szDomain[0])
+                    if (   pThis->credentialsLogon.szUserName[0]
+                        || pThis->credentialsLogon.szPassword[0]
+                        || pThis->credentialsLogon.szDomain[0])
                     {
                         credentials->u32Flags |= VMMDEV_CREDENTIALS_PRESENT;
@@ -1463 +1463 @@
                 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READ)
                 {
-                    if (pData->credentialsLogon.szUserName[0])
-                        strcpy(credentials->szUserName, pData->credentialsLogon.szUserName);
-                    if (pData->credentialsLogon.szPassword[0])
-                        strcpy(credentials->szPassword, pData->credentialsLogon.szPassword);
-                    if (pData->credentialsLogon.szDomain[0])
-                        strcpy(credentials->szDomain, pData->credentialsLogon.szDomain);
-                    if (!pData->credentialsLogon.fAllowInteractiveLogon)
+                    if (pThis->credentialsLogon.szUserName[0])
+                        strcpy(credentials->szUserName, pThis->credentialsLogon.szUserName);
+                    if (pThis->credentialsLogon.szPassword[0])
+                        strcpy(credentials->szPassword, pThis->credentialsLogon.szPassword);
+                    if (pThis->credentialsLogon.szDomain[0])
+                        strcpy(credentials->szDomain, pThis->credentialsLogon.szDomain);
+                    if (!pThis->credentialsLogon.fAllowInteractiveLogon)
                         credentials->u32Flags |= VMMDEV_CREDENTIALS_NOLOCALLOGON;
                     else
@@ -1475 +1475 @@
                 }
 
-                if (!pData->fKeepCredentials)
+                if (!pThis->fKeepCredentials)
                 {
                     /* does the caller want us to destroy the logon credentials? */
                     if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
                     {
-                        memset(pData->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
-                        memset(pData->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
-                        memset(pData->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                        memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                        memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                        memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
                     }
                 }
@@ -1489 +1489 @@
                 if (credentials->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
                 {
-                    if (pData->credentialsJudge.szUserName[0])
-                        strcpy(credentials->szUserName, pData->credentialsJudge.szUserName);
-                    if (pData->credentialsJudge.szPassword[0])
-                        strcpy(credentials->szPassword, pData->credentialsJudge.szPassword);
-                    if (pData->credentialsJudge.szDomain[0])
-                        strcpy(credentials->szDomain, pData->credentialsJudge.szDomain);
+                    if (pThis->credentialsJudge.szUserName[0])
+                        strcpy(credentials->szUserName, pThis->credentialsJudge.szUserName);
+                    if (pThis->credentialsJudge.szPassword[0])
+                        strcpy(credentials->szPassword, pThis->credentialsJudge.szPassword);
+                    if (pThis->credentialsJudge.szDomain[0])
+                        strcpy(credentials->szDomain, pThis->credentialsJudge.szDomain);
                 }
 
@@ -1500 +1500 @@
                 if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
                 {
-                    memset(pData->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
-                    memset(pData->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
-                    memset(pData->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                    memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                    memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
+                    memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
                 }
 
@@ -1524 +1524 @@
                 if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
                 {
-                    pData->pDrv->pfnSetCredentialsJudgementResult(pData->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
+                    pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
                 }
                 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
                 {
-                    pData->pDrv->pfnSetCredentialsJudgementResult(pData->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
+                    pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
                 }
                 else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
                 {
-                    pData->pDrv->pfnSetCredentialsJudgementResult(pData->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
+                    pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
                 }
                 else
@@ -1604 +1604 @@
 {
     LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%VGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
-    VMMDevState *pData = PCIDEV_2_VMMDEVSTATE(pPciDev);
+    VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
     int rc;
 
     AssertReturn(iRegion == 1 && enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
-    Assert(pData->pVMMDevRAMHC != NULL);
+    Assert(pThis->pVMMDevRAMHC != NULL);
 
     if (GCPhysAddress != NIL_RTGCPHYS)
@@ -1615 +1615 @@
          * Map the MMIO2 memory.
          */
-        pData->GCPhysVMMDevRAM = GCPhysAddress;
-        Assert(pData->GCPhysVMMDevRAM == GCPhysAddress);
+        pThis->GCPhysVMMDevRAM = GCPhysAddress;
+        Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
         rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
     }
@@ -1624 +1624 @@
          * It is about to be unmapped, just clean up.
          */
-        pData->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
+        pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
         rc = VINF_SUCCESS;
     }
@@ -1645 +1645 @@
 static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
 {
-    VMMDevState *pData = PCIDEV_2_VMMDEVSTATE(pPciDev);
+    VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
     int         rc = VINF_SUCCESS;
 
@@ -1655 +1655 @@
      * Save the base port address to simplify Port offset calculations.
      */
-    pData->PortBase = (RTIOPORT)GCPhysAddress;
+    pThis->PortBase = (RTIOPORT)GCPhysAddress;
 
     /*
@@ -1662 +1662 @@
     rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns,
                                  (RTIOPORT)GCPhysAddress + PORT_VMMDEV_REQUEST_OFFSET, 1,
-                                 (void*)pData, vmmdevRequestHandler,
+                                 (void*)pThis, vmmdevRequestHandler,
                                  NULL, NULL, NULL, "VMMDev Request Handler");
     AssertRC(rc);
@@ -1679 +1679 @@
 static DECLCALLBACK(void *) vmmdevPortQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
 {
-    VMMDevState *pData = (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Base));
+    VMMDevState *pThis = (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Base));
     switch (enmInterface)
     {
         case PDMINTERFACE_BASE:
-            return &pData->Base;
+            return &pThis->Base;
         case PDMINTERFACE_VMMDEV_PORT:
-            return &pData->Port;
+            return &pThis->Port;
 #ifdef VBOX_HGCM
         case PDMINTERFACE_HGCM_PORT:
-            return &pData->HGCMPort;
+            return &pThis->HGCMPort;
 #endif
         case PDMINTERFACE_LED_PORTS:
             /* Currently only for shared folders */
-            return &pData->SharedFolders.ILeds;
+            return &pThis->SharedFolders.ILeds;
         default:
             return NULL;
@@ -1708 +1708 @@
 static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
 {
-    VMMDevState *pData = (VMMDevState *)( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
+    VMMDevState *pThis = (VMMDevState *)( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
     if (iLUN == 0) /* LUN 0 is shared folders */
     {
-        *ppLed = &pData->SharedFolders.Led;
+        *ppLed = &pThis->SharedFolders.Led;
         return VINF_SUCCESS;
     }
@@ -1732 +1732 @@
 static DECLCALLBACK(int) vmmdevQueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t *pAbsX, uint32_t *pAbsY)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
     if (pAbsX)
-        *pAbsX = pData->mouseXAbs;
+        *pAbsX = pThis->mouseXAbs;
     if (pAbsY)
-        *pAbsY = pData->mouseYAbs;
+        *pAbsY = pThis->mouseYAbs;
     return VINF_SUCCESS;
 }
@@ -1749 +1749 @@
 static DECLCALLBACK(int) vmmdevSetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t absX, uint32_t absY)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
     Log2(("vmmdevSetAbsoluteMouse: settings absolute position to x = %d, y = %d\n", absX, absY));
-    pData->mouseXAbs = absX;
-    pData->mouseYAbs = absY;
+    pThis->mouseXAbs = absX;
+    pThis->mouseYAbs = absY;
     return VINF_SUCCESS;
 }
@@ -1764 +1764 @@
 static DECLCALLBACK(int) vmmdevQueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pCapabilities)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
     if (!pCapabilities)
         return VERR_INVALID_PARAMETER;
-    *pCapabilities = pData->mouseCapabilities;
+    *pCapabilities = pThis->mouseCapabilities;
     return VINF_SUCCESS;
 }
@@ -1779 +1779 @@
 static DECLCALLBACK(int) vmmdevSetMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t capabilities)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     bool bCapsChanged = ((capabilities & VMMDEV_MOUSEHOSTWANTSABS)
-                         != (pData->mouseCapabilities & VMMDEV_MOUSEHOSTWANTSABS));
+                         != (pThis->mouseCapabilities & VMMDEV_MOUSEHOSTWANTSABS));
 
     Log(("vmmdevSetMouseCapabilities: bCapsChanged %d\n", bCapsChanged));
 
     if (capabilities & VMMDEV_MOUSEHOSTCANNOTHWPOINTER)
-        pData->mouseCapabilities |= VMMDEV_MOUSEHOSTCANNOTHWPOINTER;
+        pThis->mouseCapabilities |= VMMDEV_MOUSEHOSTCANNOTHWPOINTER;
     else
-        pData->mouseCapabilities &= ~VMMDEV_MOUSEHOSTCANNOTHWPOINTER;
+        pThis->mouseCapabilities &= ~VMMDEV_MOUSEHOSTCANNOTHWPOINTER;
 
     if (capabilities & VMMDEV_MOUSEHOSTWANTSABS)
-        pData->mouseCapabilities |= VMMDEV_MOUSEHOSTWANTSABS;
+        pThis->mouseCapabilities |= VMMDEV_MOUSEHOSTWANTSABS;
     else
-        pData->mouseCapabilities &= ~VMMDEV_MOUSEHOSTWANTSABS;
+        pThis->mouseCapabilities &= ~VMMDEV_MOUSEHOSTWANTSABS;
 
     if (bCapsChanged)
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
 
     return VINF_SUCCESS;
@@ -1805 +1805 @@
 static DECLCALLBACK(int) vmmdevRequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t xres, uint32_t yres, uint32_t bpp, uint32_t display)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     /* Verify that the new resolution is different and that guest does not yet know about it. */
-    bool fSameResolution = (!xres || (pData->lastReadDisplayChangeRequest.xres == xres)) &&
-                           (!yres || (pData->lastReadDisplayChangeRequest.yres == yres)) &&
-                           (!bpp || (pData->lastReadDisplayChangeRequest.bpp == bpp)) &&
-                           pData->lastReadDisplayChangeRequest.display == display;
+    bool fSameResolution = (!xres || (pThis->lastReadDisplayChangeRequest.xres == xres)) &&
+                           (!yres || (pThis->lastReadDisplayChangeRequest.yres == yres)) &&
+                           (!bpp || (pThis->lastReadDisplayChangeRequest.bpp == bpp)) &&
+                           pThis->lastReadDisplayChangeRequest.display == display;
 
     if (!xres && !yres && !bpp)
@@ -1820 +1820 @@
 
     Log3(("vmmdevRequestDisplayChange: same=%d. new: xres=%d, yres=%d, bpp=%d, display=%d. old: xres=%d, yres=%d, bpp=%d, display=%d.\n",
-          fSameResolution, xres, yres, bpp, display, pData->lastReadDisplayChangeRequest.xres, pData->lastReadDisplayChangeRequest.yres, pData->lastReadDisplayChangeRequest.bpp, pData->lastReadDisplayChangeRequest.display));
+          fSameResolution, xres, yres, bpp, display, pThis->lastReadDisplayChangeRequest.xres, pThis->lastReadDisplayChangeRequest.yres, pThis->lastReadDisplayChangeRequest.bpp, pThis->lastReadDisplayChangeRequest.display));
 
     if (!fSameResolution)
@@ -1828 +1828 @@
 
         /* we could validate the information here but hey, the guest can do that as well! */
-        pData->displayChangeRequest.xres    = xres;
-        pData->displayChangeRequest.yres    = yres;
-        pData->displayChangeRequest.bpp     = bpp;
-        pData->displayChangeRequest.display = display;
+        pThis->displayChangeRequest.xres    = xres;
+        pThis->displayChangeRequest.yres    = yres;
+        pThis->displayChangeRequest.bpp     = bpp;
+        pThis->displayChangeRequest.display = display;
 
         /* IRQ so the guest knows what's going on */
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
     }
 
@@ -1842 +1842 @@
 static DECLCALLBACK(int) vmmdevRequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     /* Verify that the new resolution is different and that guest does not yet know about it. */
-    bool fSameMode = (pData->fLastSeamlessEnabled == fEnabled);
+    bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
 
     Log(("vmmdevRequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
@@ -1852 +1852 @@
     {
         /* we could validate the information here but hey, the guest can do that as well! */
-        pData->fSeamlessEnabled = fEnabled;
+        pThis->fSeamlessEnabled = fEnabled;
 
         /* IRQ so the guest knows what's going on */
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
     }
 
@@ -1863 +1863 @@
 static DECLCALLBACK(int) vmmdevSetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     /* Verify that the new resolution is different and that guest does not yet know about it. */
-    bool fSame = (pData->u32LastMemoryBalloonSize == ulBalloonSize);
-
-    Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pData->u32LastMemoryBalloonSize, ulBalloonSize));
+    bool fSame = (pThis->u32LastMemoryBalloonSize == ulBalloonSize);
+
+    Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pThis->u32LastMemoryBalloonSize, ulBalloonSize));
 
     if (!fSame)
     {
         /* we could validate the information here but hey, the guest can do that as well! */
-        pData->u32MemoryBalloonSize = ulBalloonSize;
+        pThis->u32MemoryBalloonSize = ulBalloonSize;
 
         /* IRQ so the guest knows what's going on */
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
     }
 
@@ -1884 +1884 @@
 static DECLCALLBACK(int) vmmdevVRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
-
-    bool fSame = (pData->fVRDPEnabled == fVRDPEnabled);
-
-    Log(("vmmdevVRDPChange: old=%d. new=%d\n", pData->fVRDPEnabled, fVRDPEnabled));
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+
+    bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
+
+    Log(("vmmdevVRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
 
     if (!fSame)
     {
-        pData->fVRDPEnabled = fVRDPEnabled;
-        pData->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
-
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_VRDP);
+        pThis->fVRDPEnabled = fVRDPEnabled;
+        pThis->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
+
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_VRDP);
     }
 
@@ -1903 +1903 @@
 static DECLCALLBACK(int) vmmdevSetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     /* Verify that the new resolution is different and that guest does not yet know about it. */
-    bool fSame = (pData->u32LastStatIntervalSize == ulStatInterval);
-
-    Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pData->u32LastStatIntervalSize, ulStatInterval));
+    bool fSame = (pThis->u32LastStatIntervalSize == ulStatInterval);
+
+    Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, ulStatInterval));
 
     if (!fSame)
     {
         /* we could validate the information here but hey, the guest can do that as well! */
-        pData->u32StatIntervalSize = ulStatInterval;
+        pThis->u32StatIntervalSize = ulStatInterval;
 
         /* IRQ so the guest knows what's going on */
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
     }
 
@@ -1927 +1927 @@
                                               uint32_t u32Flags)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     /* logon mode? */
@@ -1933 +1933 @@
     {
         /* memorize the data */
-        strcpy(pData->credentialsLogon.szUserName, pszUsername);
-        strcpy(pData->credentialsLogon.szPassword, pszPassword);
-        strcpy(pData->credentialsLogon.szDomain,   pszDomain);
-        pData->credentialsLogon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
+        strcpy(pThis->credentialsLogon.szUserName, pszUsername);
+        strcpy(pThis->credentialsLogon.szPassword, pszPassword);
+        strcpy(pThis->credentialsLogon.szDomain,   pszDomain);
+        pThis->credentialsLogon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
     }
     /* credentials verification mode? */
@@ -1942 +1942 @@
     {
         /* memorize the data */
-        strcpy(pData->credentialsJudge.szUserName, pszUsername);
-        strcpy(pData->credentialsJudge.szPassword, pszPassword);
-        strcpy(pData->credentialsJudge.szDomain,   pszDomain);
-
-        VMMDevNotifyGuest (pData, VMMDEV_EVENT_JUDGE_CREDENTIALS);
+        strcpy(pThis->credentialsJudge.szUserName, pszUsername);
+        strcpy(pThis->credentialsJudge.szPassword, pszPassword);
+        strcpy(pThis->credentialsJudge.szDomain,   pszDomain);
+
+        VMMDevNotifyGuest (pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
     }
     else
@@ -1962 +1962 @@
 static DECLCALLBACK(void) vmmdevVBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
 {
-    VMMDevState *pData = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
+    VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
 
     Log(("vmmdevVBVAChange: fEnabled = %d\n", fEnabled));
 
-    if (pData)
-    {
-        pData->u32VideoAccelEnabled = fEnabled;
+    if (pThis)
+    {
+        pThis->u32VideoAccelEnabled = fEnabled;
     }
 
@@ -1993 +1993 @@
 static DECLCALLBACK(int) vmmdevSaveState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState*);
-    SSMR3PutU32(pSSMHandle, pData->hypervisorSize);
-    SSMR3PutU32(pSSMHandle, pData->mouseCapabilities);
-    SSMR3PutU32(pSSMHandle, pData->mouseXAbs);
-    SSMR3PutU32(pSSMHandle, pData->mouseYAbs);
-
-    SSMR3PutBool(pSSMHandle, pData->fNewGuestFilterMask);
-    SSMR3PutU32(pSSMHandle, pData->u32NewGuestFilterMask);
-    SSMR3PutU32(pSSMHandle, pData->u32GuestFilterMask);
-    SSMR3PutU32(pSSMHandle, pData->u32HostEventFlags);
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
+    SSMR3PutU32(pSSMHandle, pThis->hypervisorSize);
+    SSMR3PutU32(pSSMHandle, pThis->mouseCapabilities);
+    SSMR3PutU32(pSSMHandle, pThis->mouseXAbs);
+    SSMR3PutU32(pSSMHandle, pThis->mouseYAbs);
+
+    SSMR3PutBool(pSSMHandle, pThis->fNewGuestFilterMask);
+    SSMR3PutU32(pSSMHandle, pThis->u32NewGuestFilterMask);
+    SSMR3PutU32(pSSMHandle, pThis->u32GuestFilterMask);
+    SSMR3PutU32(pSSMHandle, pThis->u32HostEventFlags);
     // here be dragons (probably)
-//    SSMR3PutBool(pSSMHandle, pData->pVMMDevRAMHC->V.V1_04.fHaveEvents);
-    SSMR3PutMem(pSSMHandle, &pData->pVMMDevRAMHC->V, sizeof (pData->pVMMDevRAMHC->V));
-
-    SSMR3PutMem(pSSMHandle, &pData->guestInfo, sizeof (pData->guestInfo));
-    SSMR3PutU32(pSSMHandle, pData->fu32AdditionsOk);
-    SSMR3PutU32(pSSMHandle, pData->u32VideoAccelEnabled);
-
-    SSMR3PutU32(pSSMHandle, pData->guestCaps);
+//    SSMR3PutBool(pSSMHandle, pThis->pVMMDevRAMHC->V.V1_04.fHaveEvents);
+    SSMR3PutMem(pSSMHandle, &pThis->pVMMDevRAMHC->V, sizeof (pThis->pVMMDevRAMHC->V));
+
+    SSMR3PutMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
+    SSMR3PutU32(pSSMHandle, pThis->fu32AdditionsOk);
+    SSMR3PutU32(pSSMHandle, pThis->u32VideoAccelEnabled);
+
+    SSMR3PutU32(pSSMHandle, pThis->guestCaps);
 
 #ifdef VBOX_HGCM
-    vmmdevHGCMSaveState (pData, pSSMHandle);
+    vmmdevHGCMSaveState (pThis, pSSMHandle);
 #endif /* VBOX_HGCM */
 
@@ -2031 +2031 @@
 {
     /** @todo The code load code is assuming we're always loaded into a fresh VM. */
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState*);
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
     if (   SSM_VERSION_MAJOR_CHANGED(u32Version, VMMDEV_SSM_VERSION)
         || (SSM_VERSION_MINOR(u32Version) < 6))
         return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
 
-    SSMR3GetU32(pSSMHandle, &pData->hypervisorSize);
-    SSMR3GetU32(pSSMHandle, &pData->mouseCapabilities);
-    SSMR3GetU32(pSSMHandle, &pData->mouseXAbs);
-    SSMR3GetU32(pSSMHandle, &pData->mouseYAbs);
-
-    SSMR3GetBool(pSSMHandle, &pData->fNewGuestFilterMask);
-    SSMR3GetU32(pSSMHandle, &pData->u32NewGuestFilterMask);
-    SSMR3GetU32(pSSMHandle, &pData->u32GuestFilterMask);
-    SSMR3GetU32(pSSMHandle, &pData->u32HostEventFlags);
-//    SSMR3GetBool(pSSMHandle, &pData->pVMMDevRAMHC->fHaveEvents);
+    SSMR3GetU32(pSSMHandle, &pThis->hypervisorSize);
+    SSMR3GetU32(pSSMHandle, &pThis->mouseCapabilities);
+    SSMR3GetU32(pSSMHandle, &pThis->mouseXAbs);
+    SSMR3GetU32(pSSMHandle, &pThis->mouseYAbs);
+
+    SSMR3GetBool(pSSMHandle, &pThis->fNewGuestFilterMask);
+    SSMR3GetU32(pSSMHandle, &pThis->u32NewGuestFilterMask);
+    SSMR3GetU32(pSSMHandle, &pThis->u32GuestFilterMask);
+    SSMR3GetU32(pSSMHandle, &pThis->u32HostEventFlags);
+//    SSMR3GetBool(pSSMHandle, &pThis->pVMMDevRAMHC->fHaveEvents);
     // here be dragons (probably)
-    SSMR3GetMem(pSSMHandle, &pData->pVMMDevRAMHC->V, sizeof (pData->pVMMDevRAMHC->V));
-
-    SSMR3GetMem(pSSMHandle, &pData->guestInfo, sizeof (pData->guestInfo));
-    SSMR3GetU32(pSSMHandle, &pData->fu32AdditionsOk);
-    SSMR3GetU32(pSSMHandle, &pData->u32VideoAccelEnabled);
-
-    SSMR3GetU32(pSSMHandle, &pData->guestCaps);
+    SSMR3GetMem(pSSMHandle, &pThis->pVMMDevRAMHC->V, sizeof (pThis->pVMMDevRAMHC->V));
+
+    SSMR3GetMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
+    SSMR3GetU32(pSSMHandle, &pThis->fu32AdditionsOk);
+    SSMR3GetU32(pSSMHandle, &pThis->u32VideoAccelEnabled);
+
+    SSMR3GetU32(pSSMHandle, &pThis->guestCaps);
 
     /* Attributes which were temporarily introduced in r30072 */
@@ -2065 +2065 @@
 
 #ifdef VBOX_HGCM
-    vmmdevHGCMLoadState (pData, pSSMHandle);
+    vmmdevHGCMLoadState (pThis, pSSMHandle);
 #endif /* VBOX_HGCM */
 
@@ -2072 +2072 @@
      * that listeners can sync their state again
      */
-    Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pData->mouseCapabilities));
-    if (pData->pDrv)
-        pData->pDrv->pfnUpdateMouseCapabilities(pData->pDrv, pData->mouseCapabilities);
+    Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
+    if (pThis->pDrv)
+        pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
 
     /* Reestablish the acceleration status. */
-    if (    pData->u32VideoAccelEnabled
-        &&  pData->pDrv)
-    {
-        pData->pDrv->pfnVideoAccelEnable (pData->pDrv, !!pData->u32VideoAccelEnabled, &pData->pVMMDevRAMHC->vbvaMemory);
-    }
-
-    if (pData->fu32AdditionsOk)
+    if (    pThis->u32VideoAccelEnabled
+        &&  pThis->pDrv)
+    {
+        pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMHC->vbvaMemory);
+    }
+
+    if (pThis->fu32AdditionsOk)
     {
         LogRel(("Guest Additions information report: additionsVersion = 0x%08X, osType = 0x%08X\n",
-                pData->guestInfo.additionsVersion,
-                pData->guestInfo.osType));
-        if (pData->pDrv)
-            pData->pDrv->pfnUpdateGuestVersion(pData->pDrv, &pData->guestInfo);
-    }
-    if (pData->pDrv)
-        pData->pDrv->pfnUpdateGuestCapabilities(pData->pDrv, pData->guestCaps);
+                pThis->guestInfo.additionsVersion,
+                pThis->guestInfo.osType));
+        if (pThis->pDrv)
+            pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
+    }
+    if (pThis->pDrv)
+        pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
 
     return VINF_SUCCESS;
@@ -2106 +2106 @@
 static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState*);
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
 
 #ifdef VBOX_HGCM
-    vmmdevHGCMLoadStateDone (pData, pSSMHandle);
+    vmmdevHGCMLoadStateDone (pThis, pSSMHandle);
 #endif /* VBOX_HGCM */
 
-    VMMDevNotifyGuest (pData, VMMDEV_EVENT_RESTORED);
+    VMMDevNotifyGuest (pThis, VMMDEV_EVENT_RESTORED);
 
     return VINF_SUCCESS;
@@ -2120 +2120 @@
  * (Re-)initializes the MMIO2 data.
  *
- * @param   pData           Pointer to the VMMDev instance data.
+ * @param   pThis           Pointer to the VMMDev instance data.
  */
-static void vmmdevInitRam(VMMDevState *pData)
-{
-    memset(pData->pVMMDevRAMHC, 0, sizeof(VMMDevMemory));
-    pData->pVMMDevRAMHC->u32Size = sizeof(VMMDevMemory);
-    pData->pVMMDevRAMHC->u32Version = VMMDEV_MEMORY_VERSION;
+static void vmmdevInitRam(VMMDevState *pThis)
+{
+    memset(pThis->pVMMDevRAMHC, 0, sizeof(VMMDevMemory));
+    pThis->pVMMDevRAMHC->u32Size = sizeof(VMMDevMemory);
+    pThis->pVMMDevRAMHC->u32Version = VMMDEV_MEMORY_VERSION;
 }
 
@@ -2145 +2145 @@
 {
     int rc;
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState *);
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
 
     Assert(iInstance == 0);
@@ -2155 +2155 @@
         return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
 
-    rc = CFGMR3QueryBool(pCfgHandle, "GetHostTimeDisabled", &pData->fGetHostTimeDisabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fGetHostTimeDisabled = false;
+        pThis->fGetHostTimeDisabled = false;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
 
-    rc = CFGMR3QueryBool(pCfgHandle, "BackdoorLogDisabled", &pData->fBackdoorLogDisabled);
+    rc = CFGMR3QueryBool(pCfgHandle, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fBackdoorLogDisabled = false;
+        pThis->fBackdoorLogDisabled = false;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
 
-    rc = CFGMR3QueryBool(pCfgHandle, "KeepCredentials", &pData->fKeepCredentials);
+    rc = CFGMR3QueryBool(pCfgHandle, "KeepCredentials", &pThis->fKeepCredentials);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pData->fKeepCredentials = false;
+        pThis->fKeepCredentials = false;
     else if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -2180 +2180 @@
      */
     /* Save PDM device instance data for future reference. */
-    pData->pDevIns = pDevIns;
+    pThis->pDevIns = pDevIns;
 
     /* PCI vendor, just a free bogus value */
-    pData->dev.config[0x00] = 0xee;
-    pData->dev.config[0x01] = 0x80;
+    pThis->dev.config[0x00] = 0xee;
+    pThis->dev.config[0x01] = 0x80;
     /* device ID */
-    pData->dev.config[0x02] = 0xfe;
-    pData->dev.config[0x03] = 0xca;
+    pThis->dev.config[0x02] = 0xfe;
+    pThis->dev.config[0x03] = 0xca;
     /* class sub code (other type of system peripheral) */
-    pData->dev.config[0x0a] = 0x80;
+    pThis->dev.config[0x0a] = 0x80;
     /* class base code (base system peripheral) */
-    pData->dev.config[0x0b] = 0x08;
+    pThis->dev.config[0x0b] = 0x08;
     /* header type */
-    pData->dev.config[0x0e] = 0x00;
+    pThis->dev.config[0x0e] = 0x00;
     /* interrupt on pin 0 */
-    pData->dev.config[0x3d] = 0x01;
+    pThis->dev.config[0x3d] = 0x01;
 
     /*
@@ -2201 +2201 @@
      */
     /* Base */
-    pData->Base.pfnQueryInterface         = vmmdevPortQueryInterface;
+    pThis->Base.pfnQueryInterface         = vmmdevPortQueryInterface;
 
     /* VMMDev port */
-    pData->Port.pfnQueryAbsoluteMouse     = vmmdevQueryAbsoluteMouse;
-    pData->Port.pfnSetAbsoluteMouse       = vmmdevSetAbsoluteMouse;
-    pData->Port.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
-    pData->Port.pfnSetMouseCapabilities   = vmmdevSetMouseCapabilities;
-    pData->Port.pfnRequestDisplayChange   = vmmdevRequestDisplayChange;
-    pData->Port.pfnSetCredentials         = vmmdevSetCredentials;
-    pData->Port.pfnVBVAChange             = vmmdevVBVAChange;
-    pData->Port.pfnRequestSeamlessChange  = vmmdevRequestSeamlessChange;
-    pData->Port.pfnSetMemoryBalloon       = vmmdevSetMemoryBalloon;
-    pData->Port.pfnSetStatisticsInterval  = vmmdevSetStatisticsInterval;
-    pData->Port.pfnVRDPChange             = vmmdevVRDPChange;
+    pThis->Port.pfnQueryAbsoluteMouse     = vmmdevQueryAbsoluteMouse;
+    pThis->Port.pfnSetAbsoluteMouse       = vmmdevSetAbsoluteMouse;
+    pThis->Port.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
+    pThis->Port.pfnSetMouseCapabilities   = vmmdevSetMouseCapabilities;
+    pThis->Port.pfnRequestDisplayChange   = vmmdevRequestDisplayChange;
+    pThis->Port.pfnSetCredentials         = vmmdevSetCredentials;
+    pThis->Port.pfnVBVAChange             = vmmdevVBVAChange;
+    pThis->Port.pfnRequestSeamlessChange  = vmmdevRequestSeamlessChange;
+    pThis->Port.pfnSetMemoryBalloon       = vmmdevSetMemoryBalloon;
+    pThis->Port.pfnSetStatisticsInterval  = vmmdevSetStatisticsInterval;
+    pThis->Port.pfnVRDPChange             = vmmdevVRDPChange;
 
     /* Shared folder LED */
-    pData->SharedFolders.Led.u32Magic     = PDMLED_MAGIC;
-    pData->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
+    pThis->SharedFolders.Led.u32Magic     = PDMLED_MAGIC;
+    pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
 
 #ifdef VBOX_HGCM
     /* HGCM port */
-    pData->HGCMPort.pfnCompleted          = hgcmCompleted;
+    pThis->HGCMPort.pfnCompleted          = hgcmCompleted;
 #endif
 
     /** @todo convert this into a config parameter like we do everywhere else.*/
-    pData->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
+    pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
 
     /*
@@ -2245 +2245 @@
      * Allocate and initialize the MMIO2 memory.
      */
-    rc = PDMDevHlpMMIO2Register(pDevIns, 1 /*iRegion*/, VMMDEV_RAM_SIZE, 0, (void **)&pData->pVMMDevRAMHC, "VMMDev");
+    rc = PDMDevHlpMMIO2Register(pDevIns, 1 /*iRegion*/, VMMDEV_RAM_SIZE, 0, (void **)&pThis->pVMMDevRAMHC, "VMMDev");
     if (RT_FAILURE(rc))
         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                    N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
-    vmmdevInitRam(pData);
+    vmmdevInitRam(pThis);
 
     /*
      * Register the PCI device.
      */
-    rc = PDMDevHlpPCIRegister(pDevIns, &pData->dev);
+    rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
     if (RT_FAILURE(rc))
         return rc;
-    if (pData->dev.devfn == 32 || iInstance != 0)
-        Log(("!!WARNING!!: pData->dev.devfn=%d (ignore if testcase or no started by Main)\n", pData->dev.devfn));
+    if (pThis->dev.devfn == 32 || iInstance != 0)
+        Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or no started by Main)\n", pThis->dev.devfn));
     rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
     if (RT_FAILURE(rc))
@@ -2269 +2269 @@
      * Get the corresponding connector interface
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pData->Base, &pData->pDrvBase, "VMM Driver Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->Base, &pThis->pDrvBase, "VMM Driver Port");
     if (RT_SUCCESS(rc))
     {
-        pData->pDrv = (PPDMIVMMDEVCONNECTOR)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_VMMDEV_CONNECTOR);
-        if (!pData->pDrv)
+        pThis->pDrv = (PPDMIVMMDEVCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_VMMDEV_CONNECTOR);
+        if (!pThis->pDrv)
             AssertMsgFailedReturn(("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
 #ifdef VBOX_HGCM
-        pData->pHGCMDrv = (PPDMIHGCMCONNECTOR)pData->pDrvBase->pfnQueryInterface(pData->pDrvBase, PDMINTERFACE_HGCM_CONNECTOR);
-        if (!pData->pHGCMDrv)
+        pThis->pHGCMDrv = (PPDMIHGCMCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_HGCM_CONNECTOR);
+        if (!pThis->pHGCMDrv)
         {
             Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Vrc\n", rc));
@@ -2296 +2296 @@
      */
     PPDMIBASE pBase;
-    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pData->Base, &pBase, "Status Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->Base, &pBase, "Status Port");
     if (RT_SUCCESS(rc))
-        pData->SharedFolders.pLedsConnector = (PPDMILEDCONNECTORS)
+        pThis->SharedFolders.pLedsConnector = (PPDMILEDCONNECTORS)
             pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
     else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
@@ -2309 +2309 @@
      * Register saved state and init the HGCM CmdList critsect.
      */
-    rc = PDMDevHlpSSMRegister(pDevIns, "VMMDev", iInstance, VMMDEV_SSM_VERSION, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, "VMMDev", iInstance, VMMDEV_SSM_VERSION, sizeof(*pThis),
                               NULL, vmmdevSaveState, NULL,
                               NULL, vmmdevLoadState, vmmdevLoadStateDone);
@@ -2315 +2315 @@
 
 #ifdef VBOX_HGCM
-    pData->pHGCMCmdList = NULL;
-    rc = RTCritSectInit(&pData->critsectHGCMCmdList);
+    pThis->pHGCMCmdList = NULL;
+    rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
     AssertRCReturn(rc, rc);
-    pData->u32HGCMEnabled = 0;
+    pThis->u32HGCMEnabled = 0;
 #endif /* VBOX_HGCM */
 
@@ -2332 +2332 @@
 static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
 {
-    VMMDevState *pData = PDMINS_2_DATA(pDevIns, VMMDevState*);
+    VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState*);
 
     /*
      * Reset the mouse integration feature bit
      */
-    if (pData->mouseCapabilities & (VMMDEV_MOUSEGUESTWANTSABS|VMMDEV_MOUSEGUESTNEEDSHOSTCUR))
-    {
-        pData->mouseCapabilities &= ~VMMDEV_MOUSEGUESTWANTSABS;
+    if (pThis->mouseCapabilities & (VMMDEV_MOUSEGUESTWANTSABS|VMMDEV_MOUSEGUESTNEEDSHOSTCUR))
+    {
+        pThis->mouseCapabilities &= ~VMMDEV_MOUSEGUESTWANTSABS;
         /* notify the connector */
-        Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pData->mouseCapabilities));
-        pData->pDrv->pfnUpdateMouseCapabilities(pData->pDrv, pData->mouseCapabilities);
-    }
-
-    pData->hypervisorSize = 0;
-
-    pData->u32HostEventFlags = 0;
+        Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
+        pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
+    }
+
+    pThis->hypervisorSize = 0;
+
+    pThis->u32HostEventFlags = 0;
 
     /* re-initialize the VMMDev memory */
-    if (pData->pVMMDevRAMHC)
-        vmmdevInitRam(pData);
+    if (pThis->pVMMDevRAMHC)
+        vmmdevInitRam(pThis);
 
     /* credentials have to go away (by default) */
-    if (!pData->fKeepCredentials)
-    {
-        memset(pData->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
-        memset(pData->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
-        memset(pData->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
-    }
-    memset(pData->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
-    memset(pData->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
-    memset(pData->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
+    if (!pThis->fKeepCredentials)
+    {
+        memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
+        memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
+        memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
+    }
+    memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
+    memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
+    memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
 
     /* Reset means that additions will report again. */
-    const bool fVersionChanged = pData->fu32AdditionsOk
-                              || pData->guestInfo.additionsVersion
-                              || pData->guestInfo.osType != VBOXOSTYPE_Unknown;
+    const bool fVersionChanged = pThis->fu32AdditionsOk
+                              || pThis->guestInfo.additionsVersion
+                              || pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
     if (fVersionChanged)
         Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
-             pData->fu32AdditionsOk, pData->guestInfo.additionsVersion, pData->guestInfo.osType));
-    pData->fu32AdditionsOk = false;
-    memset (&pData->guestInfo, 0, sizeof (pData->guestInfo));
+             pThis->fu32AdditionsOk, pThis->guestInfo.additionsVersion, pThis->guestInfo.osType));
+    pThis->fu32AdditionsOk = false;
+    memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
 
     /* clear pending display change request. */
-    memset (&pData->lastReadDisplayChangeRequest, 0, sizeof (pData->lastReadDisplayChangeRequest));
+    memset (&pThis->lastReadDisplayChangeRequest, 0, sizeof (pThis->lastReadDisplayChangeRequest));
 
     /* disable seamless mode */
-    pData->fLastSeamlessEnabled = false;
+    pThis->fLastSeamlessEnabled = false;
 
     /* disabled memory ballooning */
-    pData->u32LastMemoryBalloonSize = 0;
+    pThis->u32LastMemoryBalloonSize = 0;
 
     /* disabled statistics updating */
-    pData->u32LastStatIntervalSize = 0;
+    pThis->u32LastStatIntervalSize = 0;
 
     /*
      * Clear the event variables.
      *
-     *   Note: The pData->u32HostEventFlags is not cleared.
+     *   Note: The pThis->u32HostEventFlags is not cleared.
      *         It is designed that way so host events do not
      *         depend on guest resets.
      */
-    pData->u32GuestFilterMask    = 0;
-    pData->u32NewGuestFilterMask = 0;
-    pData->fNewGuestFilterMask   = 0;
+    pThis->u32GuestFilterMask    = 0;
+    pThis->u32NewGuestFilterMask = 0;
+    pThis->fNewGuestFilterMask   = 0;
 
     /* This is the default, as Windows and OS/2 guests take this for granted. (Actually, neither does...) */
     /** @todo change this when we next bump the interface version */
-    const bool fCapsChanged = pData->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
+    const bool fCapsChanged = pThis->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
     if (fCapsChanged)
-        Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pData->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
-    pData->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
+        Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pThis->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
+    pThis->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
 
     /*
@@ -2408 +2408 @@
      */
     if (fVersionChanged)
-        pData->pDrv->pfnUpdateGuestVersion(pData->pDrv, &pData->guestInfo);
+        pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
     if (fCapsChanged)
-        pData->pDrv->pfnUpdateGuestCapabilities(pData->pDrv, pData->guestCaps);
+        pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
 }