Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxDev-haiku.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxDev-haiku.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxDev-haiku.c	(revision 58053)
@@ -115,5 +115,5 @@
      * Create a new session.
      */
-    rc = VbgdCommonCreateUserSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -174,5 +174,5 @@
     if (VALID_PTR(pSession))
     {
-        VbgdCommonCloseSession(&g_DevExt, pSession);
+        VGDrvCommonCloseSession(&g_DevExt, pSession);
         ASMAtomicDecU32(&cUsers);
     }
@@ -257,5 +257,5 @@
      */
     size_t cbDataReturned;
-    rc = VbgdCommonIoCtl(op, &g_DevExt, pSession, pvBuf, len, &cbDataReturned);
+    rc = VGDrvCommonIoCtl(op, &g_DevExt, pSession, pvBuf, len, &cbDataReturned);
     if (RT_SUCCESS(rc))
     {
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-darwin.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-darwin.cpp	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-darwin.cpp	(revision 58053)
@@ -561,5 +561,5 @@
      */
     size_t cbReqRet = 0;
-    int rc = VbgdCommonIoCtl(iCmd, &g_DevExt, pSession, pvReqData, cbReq, &cbReqRet);
+    int rc = VGDrvCommonIoCtl(iCmd, &g_DevExt, pSession, pvReqData, cbReq, &cbReqRet);
     if (RT_SUCCESS(rc))
     {
@@ -618,5 +618,5 @@
 
 
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
 {
     NOREF(pDevExt);
@@ -726,5 +726,5 @@
     NOREF(pOwner); NOREF(pSrc); NOREF(cInts);
 
-    VbgdCommonWaitDoWakeUps(&g_DevExt);
+    VGDrvCommonWaitDoWakeUps(&g_DevExt);
 }
 
@@ -738,5 +738,5 @@
         return false;
 
-    bool fTaken = VbgdCommonISR(&g_DevExt);
+    bool fTaken = VGDrvCommonISR(&g_DevExt);
     if (!fTaken) /** @todo r=bird: This looks bogus as we might actually be sharing interrupts with someone. */
         PDEBUG("VbgdCommonISR error\n");
@@ -849,14 +849,14 @@
                     }
 
-                    int rc = VbgdCommonInitDevExt(&g_DevExt,
-                                                  IOPortBase,
-                                                  pvMMIOBase,
-                                                  cbMMIO,
+                    int rc = VGDrvCommonInitDevExt(&g_DevExt,
+                                                   IOPortBase,
+                                                   pvMMIOBase,
+                                                   cbMMIO,
 #if ARCH_BITS == 64
-                                                  VBOXOSTYPE_MacOS_x64,
+                                                   VBOXOSTYPE_MacOS_x64,
 #else
-                                                  VBOXOSTYPE_MacOS,
+                                                   VBOXOSTYPE_MacOS,
 #endif
-                                                  0);
+                                                   0);
                     if (RT_SUCCESS(rc))
                     {
@@ -878,5 +878,5 @@
                             LogRel(("VBoxGuest: Failed to initialize character device (rc=%d).\n", rc));
 
-                        VbgdCommonDeleteDevExt(&g_DevExt);
+                        VGDrvCommonDeleteDevExt(&g_DevExt);
                     }
                     else
@@ -924,5 +924,5 @@
 
     VbgdDarwinCharDevRemove();
-    VbgdCommonDeleteDevExt(&g_DevExt);
+    VGDrvCommonDeleteDevExt(&g_DevExt);
 
     if (m_pMap)
@@ -1021,5 +1021,5 @@
              * Create a new session.
              */
-            int rc = VbgdCommonCreateUserSession(&g_DevExt, &m_pSession);
+            int rc = VGDrvCommonCreateUserSession(&g_DevExt, &m_pSession);
             if (RT_SUCCESS(rc))
             {
@@ -1059,5 +1059,5 @@
 
                 LogFlow(("org_virtualbox_VBoxGuestClient::start: already got a session for this process (%p)\n", pCur));
-                VbgdCommonCloseSession(&g_DevExt, m_pSession);
+                VGDrvCommonCloseSession(&g_DevExt, m_pSession);
             }
 
@@ -1135,5 +1135,5 @@
      * Close the session.
      */
-    VbgdCommonCloseSession(&g_DevExt, pSession);
+    VGDrvCommonCloseSession(&g_DevExt, pSession);
 }
 
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-freebsd.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-freebsd.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-freebsd.c	(revision 58053)
@@ -220,5 +220,5 @@
      * Create a new session.
      */
-    rc = VbgdCommonCreateUserSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -230,5 +230,5 @@
         }
 
-        VbgdCommonCloseSession(&g_DevExt, pSession);
+        VGDrvCommonCloseSession(&g_DevExt, pSession);
     }
 
@@ -251,5 +251,5 @@
     if (VALID_PTR(pSession))
     {
-        VbgdCommonCloseSession(&g_DevExt, pSession);
+        VGDrvCommonCloseSession(&g_DevExt, pSession);
         if (!ASMAtomicCmpXchgPtr(&pDev->si_drv1, NULL, pSession))
             Log(("VBoxGuestFreeBSDClose: si_drv1=%p expected %p!\n", pDev->si_drv1, pSession));
@@ -332,5 +332,5 @@
      */
     size_t cbDataReturned;
-    rc = VbgdCommonIoCtl(ulCmd, &g_DevExt, pSession, pvBuf, ReqWrap->cbData, &cbDataReturned);
+    rc = VGDrvCommonIoCtl(ulCmd, &g_DevExt, pSession, pvBuf, ReqWrap->cbData, &cbDataReturned);
     if (RT_SUCCESS(rc))
     {
@@ -420,5 +420,5 @@
         bus_release_resource(pDevice, SYS_RES_IOPORT, pState->iIOPortResId, pState->pIOPortRes);
 
-    VbgdCommonDeleteDevExt(&g_DevExt);
+    VGDrvCommonDeleteDevExt(&g_DevExt);
 
     RTR0Term();
@@ -437,12 +437,12 @@
     LogFlow((DEVICE_NAME ":VBoxGuestFreeBSDISR pvState=%p\n", pvState));
 
-    bool fOurIRQ = VbgdCommonISR(&g_DevExt);
+    bool fOurIRQ = VGDrvCommonISR(&g_DevExt);
 
     return fOurIRQ ? 0 : 1;
 }
 
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
-{
-    LogFlow((DEVICE_NAME "::NativeISRMousePollEvent:\n"));
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+{
+    LogFlow((DEVICE_NAME ":VGDrvNativeISRMousePollEvent:\n"));
 
     /*
@@ -546,12 +546,12 @@
              * Call the common device extension initializer.
              */
-            rc = VbgdCommonInitDevExt(&g_DevExt, pState->uIOPortBase,
-                                      pState->pMMIOBase, pState->VMMDevMemSize,
+            rc = VGDrvCommonInitDevExt(&g_DevExt, pState->uIOPortBase,
+                                       pState->pMMIOBase, pState->VMMDevMemSize,
 #if ARCH_BITS == 64
-                                      VBOXOSTYPE_FreeBSD_x64,
+                                       VBOXOSTYPE_FreeBSD_x64,
 #else
-                                      VBOXOSTYPE_FreeBSD,
+                                       VBOXOSTYPE_FreeBSD,
 #endif
-                                      VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
+                                       VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
             if (RT_SUCCESS(rc))
             {
@@ -579,5 +579,5 @@
                 else
                     printf((DEVICE_NAME ":VbgdCommonInitDevExt failed.\n"));
-                VbgdCommonDeleteDevExt(&g_DevExt);
+                VGDrvCommonDeleteDevExt(&g_DevExt);
             }
             else
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku-stubs.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku-stubs.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku-stubs.c	(revision 58053)
@@ -347,15 +347,15 @@
     return g_VBoxGuest->_RTErrConvertToErrno(iErr);
 }
-int VbgdCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, void *pvData, size_t cbData, size_t *pcbDataReturned)
-{
-    return g_VBoxGuest->_VbgdCommonIoCtl(iFunction, pDevExt, pSession, pvData, cbData, pcbDataReturned);
-}
-int VbgdCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
-{
-    return g_VBoxGuest->_VbgdCommonCreateUserSession(pDevExt, ppSession);
-}
-void VbgdCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
-{
-    g_VBoxGuest->_VbgdCommonCloseSession(pDevExt, pSession);
+int VGDrvCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, void *pvData, size_t cbData, size_t *pcbDataReturned)
+{
+    return g_VBoxGuest->_VGDrvCommonIoCtl(iFunction, pDevExt, pSession, pvData, cbData, pcbDataReturned);
+}
+int VGDrvCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
+{
+    return g_VBoxGuest->_VGDrvCommonCreateUserSession(pDevExt, ppSession);
+}
+void VGDrvCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+{
+    g_VBoxGuest->_VGDrvCommonCloseSession(pDevExt, pSession);
 }
 void* VBoxGuestIDCOpen(uint32_t *pu32Version)
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.c	(revision 58053)
@@ -182,7 +182,7 @@
     RTLogRelGetDefaultInstanceEx,
     RTErrConvertToErrno,
-    VbgdCommonIoCtl,
-    VbgdCommonCreateUserSession,
-    VbgdCommonCloseSession,
+    VGDrvCommonIoCtl,
+    VGDrvCommonCreateUserSession,
+    VGDrvCommonCloseSession,
     VBoxGuestIDCOpen,
     VBoxGuestIDCClose,
@@ -281,5 +281,5 @@
         delete_area(pState->iVMMDevMemAreaId);
 
-    VbgdCommonDeleteDevExt(&g_DevExt);
+    VGDrvCommonDeleteDevExt(&g_DevExt);
 
 #ifdef DO_LOG
@@ -307,5 +307,5 @@
     LogFlow((MODULE_NAME ":VBoxGuestHaikuISR pvState=%p\n", pvState));
 
-    bool fOurIRQ = VbgdCommonISR(&g_DevExt);
+    bool fOurIRQ = VGDrvCommonISR(&g_DevExt);
     if (fOurIRQ)
         return B_HANDLED_INTERRUPT;
@@ -314,7 +314,7 @@
 
 
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
-{
-    LogFlow((MODULE_NAME "::NativeISRMousePollEvent:\n"));
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+{
+    LogFlow((MODULE_NAME ":VGDrvNativeISRMousePollEvent:\n"));
 
     status_t err = B_OK;
@@ -449,11 +449,11 @@
              * Call the common device extension initializer.
              */
-            rc = VbgdCommonInitDevExt(&g_DevExt, pState->uIOPortBase, pState->pMMIOBase, pState->VMMDevMemSize,
+            rc = VGDrvCommonInitDevExt(&g_DevExt, pState->uIOPortBase, pState->pMMIOBase, pState->VMMDevMemSize,
 #if ARCH_BITS == 64
-                                      VBOXOSTYPE_Haiku_x64,
+                                       VBOXOSTYPE_Haiku_x64,
 #else
-                                      VBOXOSTYPE_Haiku,
+                                       VBOXOSTYPE_Haiku,
 #endif
-                                      VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
+                                       VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
             if (RT_SUCCESS(rc))
             {
@@ -470,5 +470,5 @@
 
                 LogRel((MODULE_NAME ":VbgdCommonInitDevExt failed.\n"));
-                VbgdCommonDeleteDevExt(&g_DevExt);
+                VGDrvCommonDeleteDevExt(&g_DevExt);
             }
             else
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.h
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.h	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku.h	(revision 58053)
@@ -184,8 +184,8 @@
     PRTLOGGER(*_RTLogRelGetDefaultInstanceEx)(uint32_t fFlagsAndGroup);
     int (*_RTErrConvertToErrno)(int iErr);
-    int (*_VbgdCommonIoCtl)(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                 void *pvData, size_t cbData, size_t *pcbDataReturned);
-    int (*_VbgdCommonCreateUserSession)(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
-    void (*_VbgdCommonCloseSession)(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
+    int (*_VGDrvCommonIoCtl)(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                             void *pvData, size_t cbData, size_t *pcbDataReturned);
+    int (*_VGDrvCommonCreateUserSession)(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
+    void (*_VGDrvCommonCloseSession)(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
     void* (*_VBoxGuestIDCOpen)(uint32_t *pu32Version);
     int (*_VBoxGuestIDCClose)(void *pvSession);
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-linux.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-linux.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-linux.c	(revision 58053)
@@ -342,5 +342,5 @@
 #endif
 {
-    bool fTaken = VbgdCommonISR(&g_DevExt);
+    bool fTaken = VGDrvCommonISR(&g_DevExt);
     return IRQ_RETVAL(fTaken);
 }
@@ -387,7 +387,5 @@
 static int vboxguestLinuxSetMouseStatus(uint32_t fStatus)
 {
-    return VbgdCommonIoCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &g_DevExt,
-                           g_pKernelSession, &fStatus, sizeof(fStatus),
-                           NULL);
+    return VGDrvCommonIoCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &g_DevExt, g_pKernelSession, &fStatus, sizeof(fStatus), NULL);
 }
 
@@ -397,9 +395,8 @@
 static int vboxguestOpenInputDevice(struct input_dev *pDev)
 {
+    int rc= vboxguestLinuxSetMouseStatus(VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE | VMMDEV_MOUSE_NEW_PROTOCOL);
+    if (RT_FAILURE(rc))
+        return ENODEV;
     NOREF(pDev);
-    if (RT_FAILURE(vboxguestLinuxSetMouseStatus
-                                   (  VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
-                                    | VMMDEV_MOUSE_NEW_PROTOCOL)))
-        return ENODEV;
     return 0;
 }
@@ -596,10 +593,10 @@
             VBOXOSTYPE enmOsType = VBOXOSTYPE_Linux;
 #endif
-            rc = VbgdCommonInitDevExt(&g_DevExt,
-                                      g_IOPortBase,
-                                      g_pvMMIOBase,
-                                      g_cbMMIO,
-                                      enmOSType,
-                                      VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
+            rc = VGDrvCommonInitDevExt(&g_DevExt,
+                                       g_IOPortBase,
+                                       g_pvMMIOBase,
+                                       g_cbMMIO,
+                                       enmOSType,
+                                       VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
             if (RT_SUCCESS(rc))
             {
@@ -607,6 +604,5 @@
                  * Create the kernel session for this driver.
                  */
-                rc = VbgdCommonCreateKernelSession(&g_DevExt,
-                                                  &g_pKernelSession);
+                rc = VGDrvCommonCreateKernelSession(&g_DevExt, &g_pKernelSession);
                 if (RT_SUCCESS(rc))
                 {
@@ -643,7 +639,7 @@
                     }
 #endif
-                    VbgdCommonCloseSession(&g_DevExt, g_pKernelSession);
+                    VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
                 }
-                VbgdCommonDeleteDevExt(&g_DevExt);
+                VGDrvCommonDeleteDevExt(&g_DevExt);
             }
             else
@@ -680,6 +676,6 @@
     vboxguestLinuxTermInputDevice();
 #endif
-    VbgdCommonCloseSession(&g_DevExt, g_pKernelSession);
-    VbgdCommonDeleteDevExt(&g_DevExt);
+    VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
+    VGDrvCommonDeleteDevExt(&g_DevExt);
     vboxguestLinuxTermISR();
     pci_unregister_driver(&g_PciDriver);
@@ -706,5 +702,5 @@
      * the file so we can access it in the other methods.
      */
-    rc = VbgdCommonCreateUserSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -737,5 +733,5 @@
     vboxguestFAsync(-1, pFilp, 0);
 #endif
-    VbgdCommonCloseSession(&g_DevExt, (PVBOXGUESTSESSION)pFilp->private_data);
+    VGDrvCommonCloseSession(&g_DevExt, (PVBOXGUESTSESSION)pFilp->private_data);
     pFilp->private_data = NULL;
     return 0;
@@ -788,5 +784,5 @@
          */
         size_t cbDataReturned;
-        rc = VbgdCommonIoCtl(uCmd, &g_DevExt, pSession, pvBuf, cbData, &cbDataReturned);
+        rc = VGDrvCommonIoCtl(uCmd, &g_DevExt, pSession, pvBuf, cbData, &cbDataReturned);
 
         /*
@@ -907,5 +903,5 @@
 
 
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
 {
 #ifdef VBOXGUEST_WITH_INPUT_DRIVER
@@ -918,7 +914,7 @@
      * subscribed to async notifications.
      */
-    Log3(("VbgdNativeISRMousePollEvent: wake_up_all\n"));
+    Log3(("VGDrvNativeISRMousePollEvent: wake_up_all\n"));
     wake_up_all(&g_PollEventQueue);
-    Log3(("VbgdNativeISRMousePollEvent: kill_fasync\n"));
+    Log3(("VGDrvNativeISRMousePollEvent: kill_fasync\n"));
     kill_fasync(&g_pFAsyncQueue, SIGIO, POLL_IN);
 #ifdef VBOXGUEST_WITH_INPUT_DRIVER
@@ -939,5 +935,5 @@
     }
 #endif
-    Log3(("VbgdNativeISRMousePollEvent: done\n"));
+    Log3(("VGDrvNativeISRMousePollEvent: done\n"));
 }
 
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-os2.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-os2.cpp	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-os2.cpp	(revision 58053)
@@ -150,11 +150,11 @@
              */
             if (g_MemMapMMIO != NIL_RTR0MEMOBJ)
-                rc = VbgdCommonInitDevExt(&g_DevExt, g_IOPortBase,
-                                          RTR0MemObjAddress(g_MemMapMMIO),
-                                          RTR0MemObjSize(g_MemMapMMIO),
-                                          vboxGuestOS2DetectVersion(),
-                                          0);
+                rc = VGDrvCommonInitDevExt(&g_DevExt, g_IOPortBase,
+                                           RTR0MemObjAddress(g_MemMapMMIO),
+                                           RTR0MemObjSize(g_MemMapMMIO),
+                                           vboxGuestOS2DetectVersion(),
+                                           0);
             else
-                rc = VbgdCommonInitDevExt(&g_DevExt, g_IOPortBase, NULL, 0, vboxGuestOS2DetectVersion(), 0);
+                rc = VGDrvCommonInitDevExt(&g_DevExt, g_IOPortBase, NULL, 0, vboxGuestOS2DetectVersion(), 0);
             if (RT_SUCCESS(rc))
             {
@@ -199,5 +199,5 @@
                 else
                     g_cchInitText = RTStrPrintf(&g_szInitText[0], g_cchInitTextMax, "VBoxGuest.sys: RTSpinlockCreate failed, rc=%Rrc\n", rc);
-                VbgdCommonDeleteDevExt(&g_DevExt);
+                VGDrvCommonDeleteDevExt(&g_DevExt);
             }
             else
@@ -359,5 +359,5 @@
      * Create a new session.
      */
-    rc = VbgdCommonCreateUserSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -430,5 +430,5 @@
      * Close the session.
      */
-    VbgdCommonCloseSession(&g_DevExt, pSession);
+    VGDrvCommonCloseSession(&g_DevExt, pSession);
     return 0;
 }
@@ -463,5 +463,5 @@
      * Dispatch the fast IOCtl.
      */
-    *prc = VbgdCommonIoCtlFast(iFunction, &g_DevExt, pSession);
+    *prc = VGDrvCommonIoCtlFast(iFunction, &g_DevExt, pSession);
     return 0;
 }
@@ -495,10 +495,10 @@
     {
         default:
-            rc = VbgdCommonIoCtl(iFunction, &g_DevExt, pSession, pvData, cbData, pcbDataReturned);
+            rc = VGDrvCommonIoCtl(iFunction, &g_DevExt, pSession, pvData, cbData, pcbDataReturned);
             break;
 
         case VBOXGUEST_IOCTL_OS2_IDC_DISCONNECT:
             pSession->sfn = 0;
-            VbgdCommonCloseSession(&g_DevExt, pSession);
+            VGDrvCommonCloseSession(&g_DevExt, pSession);
             rc = VINF_SUCCESS;
             break;
@@ -516,5 +516,5 @@
 {
     PVBOXGUESTSESSION pSession;
-    int rc = VbgdCommonCreateKernelSession(&g_DevExt, &pSession);
+    int rc = VGDrvCommonCreateKernelSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -598,5 +598,5 @@
          */
         size_t cbDataReturned;
-        rc = VbgdCommonIoCtl(iFunction, &g_DevExt, pSession, pvParm, *pcbParm, &cbDataReturned);
+        rc = VGDrvCommonIoCtl(iFunction, &g_DevExt, pSession, pvParm, *pcbParm, &cbDataReturned);
 
         /*
@@ -637,9 +637,9 @@
     Log(("VBoxGuestOS2ISR\n"));
 
-    return VbgdCommonISR(&g_DevExt);
-}
-
-
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+    return VGDrvCommonISR(&g_DevExt);
+}
+
+
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
 {
     /* No polling on OS/2 */
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.c
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.c	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.c	(revision 58053)
@@ -331,11 +331,11 @@
                                  * Call the common device extension initializer.
                                  */
-                                rc = VbgdCommonInitDevExt(&g_DevExt, g_uIOPortBase, g_pMMIOBase, g_cbMMIO,
+                                rc = VGDrvCommonInitDevExt(&g_DevExt, g_uIOPortBase, g_pMMIOBase, g_cbMMIO,
 #if ARCH_BITS == 64
-                                                          VBOXOSTYPE_Solaris_x64,
+                                                           VBOXOSTYPE_Solaris_x64,
 #else
-                                                          VBOXOSTYPE_Solaris,
+                                                           VBOXOSTYPE_Solaris,
 #endif
-                                                          VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
+                                                           VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
                                 if (RT_SUCCESS(rc))
                                 {
@@ -349,5 +349,5 @@
 
                                     LogRel((DEVICE_NAME "::Attach: ddi_create_minor_node failed.\n"));
-                                    VbgdCommonDeleteDevExt(&g_DevExt);
+                                    VGDrvCommonDeleteDevExt(&g_DevExt);
                                 }
                                 else
@@ -406,5 +406,5 @@
             ddi_regs_map_free(&g_PciMMIOHandle);
             ddi_remove_minor_node(pDip, NULL);
-            VbgdCommonDeleteDevExt(&g_DevExt);
+            VGDrvCommonDeleteDevExt(&g_DevExt);
             g_pDip = NULL;
             return DDI_SUCCESS;
@@ -517,5 +517,5 @@
      * Create a new session.
      */
-    rc = VbgdCommonCreateUserSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -561,5 +561,5 @@
      * Close the session.
      */
-    VbgdCommonCloseSession(&g_DevExt, pSession);
+    VGDrvCommonCloseSession(&g_DevExt, pSession);
     return 0;
 }
@@ -696,5 +696,5 @@
      */
     size_t cbDataReturned = 0;
-    rc = VbgdCommonIoCtl(Cmd, &g_DevExt, pSession, pvBuf, ReqWrap.cbData, &cbDataReturned);
+    rc = VGDrvCommonIoCtl(Cmd, &g_DevExt, pSession, pvBuf, ReqWrap.cbData, &cbDataReturned);
     if (RT_SUCCESS(rc))
     {
@@ -898,5 +898,5 @@
 
     mutex_enter(&g_IrqMtx);
-    bool fOurIRQ = VbgdCommonISR(&g_DevExt);
+    bool fOurIRQ = VGDrvCommonISR(&g_DevExt);
     mutex_exit(&g_IrqMtx);
 
@@ -905,7 +905,7 @@
 
 
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
-{
-    LogFlow((DEVICE_NAME "::NativeISRMousePollEvent:\n"));
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+{
+    LogFlow((DEVICE_NAME "::VGDrvNativeISRMousePollEvent:\n"));
 
     /*
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win-pnp.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win-pnp.cpp	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win-pnp.cpp	(revision 58053)
@@ -277,5 +277,5 @@
 
             /* Destroy device extension and clean up everything else. */
-            VbgdCommonDeleteDevExt(&pDevExt->Core);
+            VGDrvCommonDeleteDevExt(&pDevExt->Core);
 
             /* Remove DOS device + symbolic link. */
@@ -468,6 +468,6 @@
                                 {
                                     Log(("VBoxGuest::vbgdNtGuestPower: Returning from hibernation!\n"));
-                                    int rc = VbgdCommonReinitDevExtAfterHibernation(&pDevExt->Core,
-                                                                                   vbgdNtVersionToOSType(g_enmVbgdNtVer));
+                                    int rc = VGDrvCommonReinitDevExtAfterHibernation(&pDevExt->Core,
+                                                                                     vbgdNtVersionToOSType(g_enmVbgdNtVer));
                                     if (RT_FAILURE(rc))
                                         Log(("VBoxGuest::vbgdNtGuestPower: Cannot re-init VMMDev chain, rc = %d!\n", rc));
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win.cpp	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win.cpp	(revision 58053)
@@ -427,9 +427,9 @@
                      pvMMIOBase, pDevExt, pDevExt ? pDevExt->Core.pVMMDevMemory : NULL));
 
-            int vrc = VbgdCommonInitDevExt(&pDevExt->Core,
-                                           pDevExt->Core.IOPortBase,
-                                           pvMMIOBase, cbMMIO,
-                                           vbgdNtVersionToOSType(g_enmVbgdNtVer),
-                                           VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
+            int vrc = VGDrvCommonInitDevExt(&pDevExt->Core,
+                                            pDevExt->Core.IOPortBase,
+                                            pvMMIOBase, cbMMIO,
+                                            vbgdNtVersionToOSType(g_enmVbgdNtVer),
+                                            VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
             if (RT_FAILURE(vrc))
             {
@@ -516,5 +516,5 @@
 #ifdef VBOX_WITH_HGCM
     LogFunc(("Allocating kernel session data ...\n"));
-    int vrc = VbgdCommonCreateKernelSession(&pDevExt->Core, &pDevExt->pKernelSession);
+    int vrc = VGDrvCommonCreateKernelSession(&pDevExt->Core, &pDevExt->pKernelSession);
     if (RT_FAILURE(vrc))
     {
@@ -609,5 +609,5 @@
     /* Destroy device extension and clean up everything else. */
     if (pDrvObj->DeviceObject && pDrvObj->DeviceObject->DeviceExtension)
-        VbgdCommonDeleteDevExt((PVBOXGUESTDEVEXT)pDrvObj->DeviceObject->DeviceExtension);
+        VGDrvCommonDeleteDevExt((PVBOXGUESTDEVEXT)pDrvObj->DeviceObject->DeviceExtension);
 
     /*
@@ -674,10 +674,10 @@
                  * exists for every R3 process.
                  */
-                vrc = VbgdCommonCreateUserSession(&pDevExt->Core, &pSession);
+                vrc = VGDrvCommonCreateUserSession(&pDevExt->Core, &pSession);
             }
             else
             {
                 /* ... otherwise we've been called from R0! */
-                vrc = VbgdCommonCreateKernelSession(&pDevExt->Core, &pSession);
+                vrc = VGDrvCommonCreateKernelSession(&pDevExt->Core, &pSession);
             }
             if (RT_SUCCESS(vrc))
@@ -716,5 +716,5 @@
     PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFileObj->FsContext;
     if (pSession)
-        VbgdCommonCloseSession(&pDevExt->Core, pSession);
+        VGDrvCommonCloseSession(&pDevExt->Core, pSession);
 #endif
 
@@ -774,5 +774,5 @@
          */
         size_t cbDataReturned;
-        int vrc = VbgdCommonIoCtl(uCmd, &pDevExt->Core, pSession, pBuf, cbData, &cbDataReturned);
+        int vrc = VGDrvCommonIoCtl(uCmd, &pDevExt->Core, pSession, pBuf, cbData, &cbDataReturned);
 
         LogFlowFunc(("rc=%Rrc, pBuf=0x%p, cbData=%u, cbDataReturned=%u\n",
@@ -977,5 +977,5 @@
     /* Process the wake-up list we were asked by the scheduling a DPC
      * in vbgdNtIsrHandler(). */
-    VbgdCommonWaitDoWakeUps(&pDevExt->Core);
+    VGDrvCommonWaitDoWakeUps(&pDevExt->Core);
 }
 
@@ -997,5 +997,5 @@
 
     /* Enter the common ISR routine and do the actual work. */
-    BOOLEAN fIRQTaken = VbgdCommonISR(&pDevExt->Core);
+    BOOLEAN fIRQTaken = VGDrvCommonISR(&pDevExt->Core);
 
     /* If we need to wake up some events we do that in a DPC to make
@@ -1020,5 +1020,5 @@
  * @param pDevExt     Device extension structure.
  */
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
 {
     NOREF(pDevExt);
@@ -1481,5 +1481,5 @@
  * @returns VBox status code.
  */
-int VbgdNtIOCtl_DpcLatencyChecker(void)
+int VGDrvNtIOCtl_DpcLatencyChecker(void)
 {
     /*
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp	(revision 58053)
@@ -23,4 +23,26 @@
  * You may elect to license modified versions of this file under the
  * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+/** @page pg_vbdrv VBoxGuest
+ *
+ * VBoxGuest is the device driver for VMMDev.
+ *
+ * The device driver is shipped as part of the guest additions.  It has roots in
+ * the host VMM support driver (usually known as VBoxDrv), so fixes in platform
+ * specific code may apply to both drivers.
+ *
+ * The common code lives in VBoxGuest.cpp and is compiled both as C++ and C.
+ * The VBoxGuest.cpp source file shall not contain platform specific code,
+ * though it must occationally do a few \#ifdef RT_OS_XXX tests to cater for
+ * platform differences.  Though, in those cases, it is common that more than
+ * one platform needs special handling.
+ *
+ * On most platforms the device driver should create two device nodes, one for
+ * full (unrestricted) access to the feature set, and one which only provides a
+ * restrict set of functions.  These are generally referred to as 'vboxguest'
+ * and 'vboxuser' respectively.  Currently, this two device approach is only
+ * implemented on Linux!
+ *
  */
 
@@ -70,21 +92,21 @@
 *********************************************************************************************************************************/
 #ifdef VBOX_WITH_HGCM
-static DECLCALLBACK(int) vbgdHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdrNonVolatile, void *pvUser, uint32_t u32User);
+static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdrNonVolatile, void *pvUser, uint32_t u32User);
 #endif
-static int      vbgdIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
-static void     vbgdBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker);
-static uint32_t vbgdGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
-static int      vbgdResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents);
-static int      vbgdResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt);
-static int      vbgdResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt);
-static int      vbgdSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                          uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
-static int      vbgdSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                          uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
-static int      vbgdSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                           uint32_t fOrMask, uint32_t fNoMask, bool fSessionTermination);
-static int      vbgdAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fOrMask,
-                                               uint32_t fNotMask, VBOXGUESTCAPSACQUIRE_FLAGS enmFlags, bool fSessionTermination);
-static int      vbgdDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents);
+static int      vgdrvIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
+static void     vgdrvBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker);
+static uint32_t vgdrvGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
+static int      vgdrvResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents);
+static int      vgdrvResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt);
+static int      vgdrvResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt);
+static int      vgdrvSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                           uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
+static int      vgdrvSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                           uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
+static int      vgdrvSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                            uint32_t fOrMask, uint32_t fNoMask, bool fSessionTermination);
+static int      vgdrvAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fOrMask,
+                                                uint32_t fNotMask, VBOXGUESTCAPSACQUIRE_FLAGS enmFlags, bool fSessionTermination);
+static int      vgdrvDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents);
 
 
@@ -128,5 +150,5 @@
  * @param   pDevExt     The device extension.
  */
-static int vbgdInitFixateGuestMappings(PVBOXGUESTDEVEXT pDevExt)
+static int vgdrvInitFixateGuestMappings(PVBOXGUESTDEVEXT pDevExt)
 {
     /*
@@ -151,5 +173,5 @@
      */
     if (pReq->hypervisorSize == 0)
-        Log(("vbgdInitFixateGuestMappings: nothing to do\n"));
+        Log(("vgdrvInitFixateGuestMappings: nothing to do\n"));
     else
     {
@@ -163,5 +185,5 @@
         uint32_t    iTry;
         bool        fBitched = false;
-        Log(("vbgdInitFixateGuestMappings: cbHypervisor=%#x\n", cbHypervisor));
+        Log(("vgdrvInitFixateGuestMappings: cbHypervisor=%#x\n", cbHypervisor));
         for (iTry = 0; iTry < RT_ELEMENTS(ahTries); iTry++)
         {
@@ -258,9 +280,9 @@
 
 /**
- * Undo what vbgdInitFixateGuestMappings did.
+ * Undo what vgdrvInitFixateGuestMappings did.
  *
  * @param   pDevExt     The device extension.
  */
-static void vbgdTermUnfixGuestMappings(PVBOXGUESTDEVEXT pDevExt)
+static void vgdrvTermUnfixGuestMappings(PVBOXGUESTDEVEXT pDevExt)
 {
     if (pDevExt->hGuestMappings != NIL_RTR0PTR)
@@ -285,5 +307,5 @@
         }
         else
-            LogRel(("vbgdTermUnfixGuestMappings: Failed to unfix the guest mappings! rc=%Rrc\n", rc));
+            LogRel(("vgdrvTermUnfixGuestMappings: Failed to unfix the guest mappings! rc=%Rrc\n", rc));
 
         pDevExt->hGuestMappings = NIL_RTR0MEMOBJ;
@@ -299,5 +321,5 @@
  * @param   enmOSType       The OS type to report.
  */
-static int vbgdReportGuestInfo(VBOXOSTYPE enmOSType)
+static int vgdrvReportGuestInfo(VBOXOSTYPE enmOSType)
 {
     /*
@@ -307,5 +329,5 @@
     VMMDevReportGuestInfo  *pReqInfo1 = NULL;
     int rc = VbglGRAlloc((VMMDevRequestHeader **)&pReqInfo2, sizeof (VMMDevReportGuestInfo2), VMMDevReq_ReportGuestInfo2);
-    Log(("vbgdReportGuestInfo: VbglGRAlloc VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
+    Log(("vgdrvReportGuestInfo: VbglGRAlloc VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
     if (RT_SUCCESS(rc))
     {
@@ -318,5 +340,5 @@
 
         rc = VbglGRAlloc((VMMDevRequestHeader **)&pReqInfo1, sizeof (VMMDevReportGuestInfo), VMMDevReq_ReportGuestInfo);
-        Log(("vbgdReportGuestInfo: VbglGRAlloc VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
+        Log(("vgdrvReportGuestInfo: VbglGRAlloc VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
         if (RT_SUCCESS(rc))
         {
@@ -333,9 +355,9 @@
              */
             rc = VbglGRPerform(&pReqInfo2->header);
-            Log(("vbgdReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
+            Log(("vgdrvReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
             if (RT_SUCCESS(rc))
             {
                 rc = VbglGRPerform(&pReqInfo1->header);
-                Log(("vbgdReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
+                Log(("vgdrvReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
             }
             else if (   rc == VERR_NOT_SUPPORTED
@@ -343,9 +365,9 @@
             {
                 rc = VbglGRPerform(&pReqInfo1->header);
-                Log(("vbgdReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
+                Log(("vgdrvReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
                 if (RT_SUCCESS(rc))
                 {
                     rc = VbglGRPerform(&pReqInfo2->header);
-                    Log(("vbgdReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
+                    Log(("vgdrvReportGuestInfo: VbglGRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
                     if (rc == VERR_NOT_IMPLEMENTED)
                         rc = VINF_SUCCESS;
@@ -367,5 +389,5 @@
  * @param   fActive         Flag whether the driver is now active or not.
  */
-static int vbgdReportDriverStatus(bool fActive)
+static int vgdrvReportDriverStatus(bool fActive)
 {
     /*
@@ -374,5 +396,5 @@
     VMMDevReportGuestStatus *pReq2 = NULL;
     int rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq2, sizeof(*pReq2), VMMDevReq_ReportGuestStatus);
-    Log(("vbgdReportDriverStatus: VbglGRAlloc VMMDevReportGuestStatus completed with rc=%Rrc\n", rc));
+    Log(("vgdrvReportDriverStatus: VbglGRAlloc VMMDevReportGuestStatus completed with rc=%Rrc\n", rc));
     if (RT_SUCCESS(rc))
     {
@@ -383,5 +405,5 @@
         pReq2->guestStatus.flags = 0;
         rc = VbglGRPerform(&pReq2->header);
-        Log(("vbgdReportDriverStatus: VbglGRPerform VMMDevReportGuestStatus completed with fActive=%d, rc=%Rrc\n",
+        Log(("vgdrvReportDriverStatus: VbglGRPerform VMMDevReportGuestStatus completed with fActive=%d, rc=%Rrc\n",
              fActive ? 1 : 0, rc));
         if (rc == VERR_NOT_IMPLEMENTED) /* Compatibility with older hosts. */
@@ -407,5 +429,5 @@
  * @param   pReq        The pre-allocated request for performing the VMMDev call.
  */
-static int vbgdBalloonInflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
+static int vgdrvBalloonInflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
 {
     uint32_t iPage;
@@ -424,5 +446,5 @@
     rc = VbglGRPerform(&pReq->header);
     if (RT_FAILURE(rc))
-        LogRel(("vbgdBalloonInflate: VbglGRPerform failed. rc=%Rrc\n", rc));
+        LogRel(("vgdrvBalloonInflate: VbglGRPerform failed. rc=%Rrc\n", rc));
     return rc;
 }
@@ -439,5 +461,5 @@
  * @param   pReq        The pre-allocated request for performing the VMMDev call.
  */
-static int vbgdBalloonDeflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
+static int vgdrvBalloonDeflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
 {
     uint32_t iPage;
@@ -457,5 +479,5 @@
     if (RT_FAILURE(rc))
     {
-        LogRel(("vbgdBalloonDeflate: VbglGRPerform failed. rc=%Rrc\n", rc));
+        LogRel(("vgdrvBalloonDeflate: VbglGRPerform failed. rc=%Rrc\n", rc));
         return rc;
     }
@@ -464,5 +486,5 @@
     if (RT_FAILURE(rc))
     {
-        LogRel(("vbgdBalloonDeflate: RTR0MemObjFree(%p,true) -> %Rrc; this is *BAD*!\n", *pMemObj, rc));
+        LogRel(("vgdrvBalloonDeflate: RTR0MemObjFree(%p,true) -> %Rrc; this is *BAD*!\n", *pMemObj, rc));
         return rc;
     }
@@ -476,5 +498,5 @@
  * Inflate/deflate the memory balloon and notify the host.
  *
- * This is a worker used by vbgdIoCtl_CheckMemoryBalloon - it takes the mutex.
+ * This is a worker used by vgdrvIoCtl_CheckMemoryBalloon - it takes the mutex.
  *
  * @returns VBox status code.
@@ -485,5 +507,5 @@
  *                          (VINF_SUCCESS if set).
  */
-static int vbgdSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t cBalloonChunks, uint32_t *pfHandleInR3)
+static int vgdrvSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t cBalloonChunks, uint32_t *pfHandleInR3)
 {
     int rc = VINF_SUCCESS;
@@ -496,5 +518,5 @@
         if (cBalloonChunks > pDevExt->MemBalloon.cMaxChunks)
         {
-            LogRel(("vbgdSetBalloonSizeKernel: illegal balloon size %u (max=%u)\n",
+            LogRel(("vgdrvSetBalloonSizeKernel: illegal balloon size %u (max=%u)\n",
                     cBalloonChunks, pDevExt->MemBalloon.cMaxChunks));
             return VERR_INVALID_PARAMETER;
@@ -510,5 +532,5 @@
             if (!pDevExt->MemBalloon.paMemObj)
             {
-                LogRel(("vbgdSetBalloonSizeKernel: no memory for paMemObj!\n"));
+                LogRel(("vgdrvSetBalloonSizeKernel: no memory for paMemObj!\n"));
                 return VERR_NO_MEMORY;
             }
@@ -542,5 +564,5 @@
                 }
 
-                rc = vbgdBalloonInflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
+                rc = vgdrvBalloonInflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
                 if (RT_FAILURE(rc))
                 {
@@ -558,5 +580,5 @@
             for (i = pDevExt->MemBalloon.cChunks; i-- > cBalloonChunks;)
             {
-                rc = vbgdBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
+                rc = vgdrvBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
                 if (RT_FAILURE(rc))
                 {
@@ -584,5 +606,5 @@
  * Inflate/deflate the balloon by one chunk.
  *
- * Worker for vbgdIoCtl_ChangeMemoryBalloon - it takes the mutex.
+ * Worker for vgdrvIoCtl_ChangeMemoryBalloon - it takes the mutex.
  *
  * @returns VBox status code.
@@ -593,5 +615,5 @@
  * @param   fInflate        Inflate if true, deflate if false.
  */
-static int vbgdSetBalloonSizeFromUser(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint64_t u64ChunkAddr, bool fInflate)
+static int vgdrvSetBalloonSizeFromUser(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint64_t u64ChunkAddr, bool fInflate)
 {
     VMMDevChangeMemBalloon *pReq;
@@ -673,5 +695,5 @@
         if (RT_SUCCESS(rc))
         {
-            rc = vbgdBalloonInflate(pMemObj, pReq);
+            rc = vgdrvBalloonInflate(pMemObj, pReq);
             if (RT_SUCCESS(rc))
                 pDevExt->MemBalloon.cChunks++;
@@ -686,5 +708,5 @@
     else
     {
-        rc = vbgdBalloonDeflate(pMemObj, pReq);
+        rc = vgdrvBalloonDeflate(pMemObj, pReq);
         if (RT_SUCCESS(rc))
             pDevExt->MemBalloon.cChunks--;
@@ -707,5 +729,5 @@
  * @param   pDevExt     The session.  Can be NULL at unload.
  */
-static void vbgdCloseMemBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+static void vgdrvCloseMemBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
 {
     RTSemFastMutexRequest(pDevExt->MemBalloon.hMtx);
@@ -722,8 +744,8 @@
                 for (i = pDevExt->MemBalloon.cChunks; i-- > 0;)
                 {
-                    rc = vbgdBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
+                    rc = vgdrvBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
                     if (RT_FAILURE(rc))
                     {
-                        LogRel(("vbgdCloseMemBalloon: Deflate failed with rc=%Rrc.  Will leak %u chunks.\n",
+                        LogRel(("vgdrvCloseMemBalloon: Deflate failed with rc=%Rrc.  Will leak %u chunks.\n",
                                 rc, pDevExt->MemBalloon.cChunks));
                         break;
@@ -735,5 +757,5 @@
             }
             else
-                LogRel(("vbgdCloseMemBalloon: Failed to allocate VMMDev request buffer (rc=%Rrc).  Will leak %u chunks.\n",
+                LogRel(("vgdrvCloseMemBalloon: Failed to allocate VMMDev request buffer (rc=%Rrc).  Will leak %u chunks.\n",
                         rc, pDevExt->MemBalloon.cChunks));
             RTMemFree(pDevExt->MemBalloon.paMemObj);
@@ -759,5 +781,5 @@
  * @returns VBox status code.
  */
-static int vbgdHeartbeatSend(PVBOXGUESTDEVEXT pDevExt)
+static int vgdrvHeartbeatSend(PVBOXGUESTDEVEXT pDevExt)
 {
     int rc;
@@ -765,5 +787,5 @@
     {
         rc = VbglGRPerform(pDevExt->pReqGuestHeartbeat);
-        Log(("vbgdHeartbeatSend: VbglGRPerform vbgdHeartbeatSend completed with rc=%Rrc\n", rc));
+        Log(("vgdrvHeartbeatSend: VbglGRPerform vgdrvHeartbeatSend completed with rc=%Rrc\n", rc));
     }
     else
@@ -776,5 +798,5 @@
  * Callback for heartbeat timer.
  */
-static DECLCALLBACK(void) vbgdHeartbeatTimerHandler(PRTTIMER hTimer, void *pvUser, uint64_t iTick)
+static DECLCALLBACK(void) vgdrvHeartbeatTimerHandler(PRTTIMER hTimer, void *pvUser, uint64_t iTick)
 {
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
@@ -782,7 +804,7 @@
     AssertReturnVoid(pDevExt);
 
-    rc = vbgdHeartbeatSend(pDevExt);
+    rc = vgdrvHeartbeatSend(pDevExt);
     if (RT_FAILURE(rc))
-        Log(("HB Timer: vbgdHeartbeatSend failed: rc=%Rrc\n", rc));
+        Log(("HB Timer: vgdrvHeartbeatSend failed: rc=%Rrc\n", rc));
 
     NOREF(hTimer); NOREF(iTick);
@@ -798,9 +820,9 @@
  * @param   fEnabled        Set true to enable guest heartbeat checks on host.
  */
-static int vbgdHeartbeatHostConfigure(PVBOXGUESTDEVEXT pDevExt, bool fEnabled)
+static int vgdrvHeartbeatHostConfigure(PVBOXGUESTDEVEXT pDevExt, bool fEnabled)
 {
     VMMDevReqHeartbeat *pReq;
     int rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, sizeof(*pReq), VMMDevReq_HeartbeatConfigure);
-    Log(("vbgdHeartbeatHostConfigure: VbglGRAlloc vbgdHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
+    Log(("vgdrvHeartbeatHostConfigure: VbglGRAlloc vgdrvHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
     if (RT_SUCCESS(rc))
     {
@@ -808,5 +830,5 @@
         pReq->cNsInterval = 0;
         rc = VbglGRPerform(&pReq->header);
-        Log(("vbgdHeartbeatHostConfigure: VbglGRPerform vbgdHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
+        Log(("vgdrvHeartbeatHostConfigure: VbglGRPerform vgdrvHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
         pDevExt->cNsHeartbeatInterval = pReq->cNsInterval;
         VbglGRFree(&pReq->header);
@@ -824,13 +846,13 @@
  * @param   pDevExt             The device extension.
  */
-static int vbgdHeartbeatInit(PVBOXGUESTDEVEXT pDevExt)
+static int vgdrvHeartbeatInit(PVBOXGUESTDEVEXT pDevExt)
 {
     /*
      * Make sure that heartbeat checking is disabled.
      */
-    int rc = vbgdHeartbeatHostConfigure(pDevExt, false);
+    int rc = vgdrvHeartbeatHostConfigure(pDevExt, false);
     if (RT_SUCCESS(rc))
     {
-        rc = vbgdHeartbeatHostConfigure(pDevExt, true);
+        rc = vgdrvHeartbeatHostConfigure(pDevExt, true);
         if (RT_SUCCESS(rc))
         {
@@ -844,8 +866,8 @@
             if (RT_SUCCESS(rc))
             {
-                LogRel(("VbgdCommonInitDevExt: Setting up heartbeat to trigger every %RU64 milliseconds\n",
+                LogRel(("vgdrvHeartbeatInit: Setting up heartbeat to trigger every %RU64 milliseconds\n",
                         pDevExt->cNsHeartbeatInterval / RT_NS_1MS));
                 rc = RTTimerCreateEx(&pDevExt->pHeartbeatTimer, pDevExt->cNsHeartbeatInterval, 0 /*fFlags*/,
-                                     (PFNRTTIMER)vbgdHeartbeatTimerHandler, pDevExt);
+                                     (PFNRTTIMER)vgdrvHeartbeatTimerHandler, pDevExt);
                 if (RT_SUCCESS(rc))
                 {
@@ -854,8 +876,8 @@
                         return VINF_SUCCESS;
 
-                    LogRel(("VbgdCommonInitDevExt: Heartbeat timer failed to start, rc=%Rrc\n", rc));
+                    LogRel(("vgdrvHeartbeatInit: Heartbeat timer failed to start, rc=%Rrc\n", rc));
                 }
                 else
-                    LogRel(("VbgdCommonInitDevExt: Failed to create heartbeat timer: %Rrc\n", rc));
+                    LogRel(("vgdrvHeartbeatInit: Failed to create heartbeat timer: %Rrc\n", rc));
 
                 VbglGRFree(pDevExt->pReqGuestHeartbeat);
@@ -863,11 +885,11 @@
             }
             else
-                LogRel(("VbgdCommonInitDevExt: VbglGRAlloc(VMMDevReq_GuestHeartbeat): %Rrc\n", rc));
-
-            LogRel(("VbgdCommonInitDevExt: Failed to set up the timer, guest heartbeat is disabled\n"));
-            vbgdHeartbeatHostConfigure(pDevExt, false);
+                LogRel(("vgdrvHeartbeatInit: VbglGRAlloc(VMMDevReq_GuestHeartbeat): %Rrc\n", rc));
+
+            LogRel(("vgdrvHeartbeatInit: Failed to set up the timer, guest heartbeat is disabled\n"));
+            vgdrvHeartbeatHostConfigure(pDevExt, false);
         }
         else
-            LogRel(("VbgdCommonInitDevExt: Failed to configure host for heartbeat checking: rc=%Rrc\n", rc));
+            LogRel(("vgdrvHeartbeatInit: Failed to configure host for heartbeat checking: rc=%Rrc\n", rc));
     }
     return rc;
@@ -886,16 +908,16 @@
  * @todo Call this on all platforms, not just windows.
  */
-int VbgdCommonReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType)
-{
-    int rc = vbgdReportGuestInfo(enmOSType);
+int VGDrvCommonReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType)
+{
+    int rc = vgdrvReportGuestInfo(enmOSType);
     if (RT_SUCCESS(rc))
     {
-        rc = vbgdReportDriverStatus(true /* Driver is active */);
+        rc = vgdrvReportDriverStatus(true /* Driver is active */);
         if (RT_FAILURE(rc))
-            Log(("VbgdCommonReinitDevExtAfterHibernation: could not report guest driver status, rc=%Rrc\n", rc));
+            Log(("VGDrvCommonReinitDevExtAfterHibernation: could not report guest driver status, rc=%Rrc\n", rc));
     }
     else
-        Log(("VbgdCommonReinitDevExtAfterHibernation: could not report guest information to host, rc=%Rrc\n", rc));
-    LogFlow(("VbgdCommonReinitDevExtAfterHibernation: returned with rc=%Rrc\n", rc));
+        Log(("VGDrvCommonReinitDevExtAfterHibernation: could not report guest information to host, rc=%Rrc\n", rc));
+    LogFlow(("VGDrvCommonReinitDevExtAfterHibernation: returned with rc=%Rrc\n", rc));
     return rc;
 }
@@ -923,6 +945,6 @@
  *                          will ever be allowed to mask.
  */
-int VbgdCommonInitDevExt(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase,
-                         void *pvMMIOBase, uint32_t cbMMIO, VBOXOSTYPE enmOSType, uint32_t fFixedEvents)
+int VGDrvCommonInitDevExt(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase,
+                          void *pvMMIOBase, uint32_t cbMMIO, VBOXOSTYPE enmOSType, uint32_t fFixedEvents)
 {
     int rc, rc2;
@@ -984,8 +1006,8 @@
 
     pDevExt->fFixedEvents = fFixedEvents;
-    vbgdBitUsageTrackerClear(&pDevExt->EventFilterTracker);
+    vgdrvBitUsageTrackerClear(&pDevExt->EventFilterTracker);
     pDevExt->fEventFilterHost = UINT32_MAX;  /* forces a report */
 
-    vbgdBitUsageTrackerClear(&pDevExt->MouseStatusTracker);
+    vgdrvBitUsageTrackerClear(&pDevExt->MouseStatusTracker);
     pDevExt->fMouseStatusHost = UINT32_MAX;  /* forces a report */
 
@@ -993,5 +1015,5 @@
     pDevExt->fSetModeGuestCaps = 0;
     pDevExt->fAcquiredGuestCaps = 0;
-    vbgdBitUsageTrackerClear(&pDevExt->SetGuestCapsTracker);
+    vgdrvBitUsageTrackerClear(&pDevExt->SetGuestCapsTracker);
     pDevExt->fGuestCapsHost = UINT32_MAX; /* forces a report */
 
@@ -1008,9 +1030,9 @@
         {
             pDevExt->pVMMDevMemory = pVMMDev;
-            Log(("VbgdCommonInitDevExt: VMMDevMemory: mapping=%p size=%#RX32 (%#RX32) version=%#RX32\n",
+            Log(("VGDrvCommonInitDevExt: VMMDevMemory: mapping=%p size=%#RX32 (%#RX32) version=%#RX32\n",
                  pVMMDev, pVMMDev->u32Size, cbMMIO, pVMMDev->u32Version));
         }
         else /* try live without it. */
-            LogRel(("VbgdCommonInitDevExt: Bogus VMMDev memory; u32Version=%RX32 (expected %RX32) u32Size=%RX32 (expected <= %RX32)\n",
+            LogRel(("VGDrvCommonInitDevExt: Bogus VMMDev memory; u32Version=%RX32 (expected %RX32) u32Size=%RX32 (expected <= %RX32)\n",
                     pVMMDev->u32Version, VMMDEV_MEMORY_VERSION, pVMMDev->u32Size, cbMMIO));
     }
@@ -1024,5 +1046,5 @@
     if (RT_FAILURE(rc))
     {
-        LogRel(("VbgdCommonInitDevExt: failed to create spinlock, rc=%Rrc!\n", rc));
+        LogRel(("VGDrvCommonInitDevExt: failed to create spinlock, rc=%Rrc!\n", rc));
         if (pDevExt->EventSpinlock != NIL_RTSPINLOCK)
             RTSpinlockDestroy(pDevExt->EventSpinlock);
@@ -1033,5 +1055,5 @@
     if (RT_FAILURE(rc))
     {
-        LogRel(("VbgdCommonInitDevExt: failed to create mutex, rc=%Rrc!\n", rc));
+        LogRel(("VGDrvCommonInitDevExt: failed to create mutex, rc=%Rrc!\n", rc));
         RTSpinlockDestroy(pDevExt->SessionSpinlock);
         RTSpinlockDestroy(pDevExt->EventSpinlock);
@@ -1053,5 +1075,5 @@
             Assert(pDevExt->PhysIrqAckEvents != 0);
 
-            rc = vbgdReportGuestInfo(enmOSType);
+            rc = vgdrvReportGuestInfo(enmOSType);
             if (RT_SUCCESS(rc))
             {
@@ -1060,11 +1082,11 @@
                  * the guest capabilities or mouse status bits set.
                  */
-                rc = vbgdResetEventFilterOnHost(pDevExt, pDevExt->fFixedEvents);
+                rc = vgdrvResetEventFilterOnHost(pDevExt, pDevExt->fFixedEvents);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = vbgdResetCapabilitiesOnHost(pDevExt);
+                    rc = vgdrvResetCapabilitiesOnHost(pDevExt);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = vbgdResetMouseStatusOnHost(pDevExt);
+                        rc = vgdrvResetMouseStatusOnHost(pDevExt);
                         if (RT_SUCCESS(rc))
                         {
@@ -1072,36 +1094,36 @@
                              * Initialize stuff which may fail without requiring the driver init to fail.
                              */
-                            vbgdInitFixateGuestMappings(pDevExt);
-                            vbgdHeartbeatInit(pDevExt);
+                            vgdrvInitFixateGuestMappings(pDevExt);
+                            vgdrvHeartbeatInit(pDevExt);
 
                             /*
                              * Done!
                              */
-                            rc = vbgdReportDriverStatus(true /* Driver is active */);
+                            rc = vgdrvReportDriverStatus(true /* Driver is active */);
                             if (RT_FAILURE(rc))
-                                LogRel(("VbgdCommonInitDevExt: VBoxReportGuestDriverStatus failed, rc=%Rrc\n", rc));
-
-                            LogFlowFunc(("VbgdCommonInitDevExt: returns success\n"));
+                                LogRel(("VGDrvCommonInitDevExt: VBoxReportGuestDriverStatus failed, rc=%Rrc\n", rc));
+
+                            LogFlowFunc(("VGDrvCommonInitDevExt: returns success\n"));
                             return VINF_SUCCESS;
                         }
-                        LogRel(("VbgdCommonInitDevExt: failed to clear mouse status: rc=%Rrc\n", rc));
+                        LogRel(("VGDrvCommonInitDevExt: failed to clear mouse status: rc=%Rrc\n", rc));
                     }
                     else
-                        LogRel(("VbgdCommonInitDevExt: failed to clear guest capabilities: rc=%Rrc\n", rc));
+                        LogRel(("VGDrvCommonInitDevExt: failed to clear guest capabilities: rc=%Rrc\n", rc));
                 }
                 else
-                    LogRel(("VbgdCommonInitDevExt: failed to set fixed event filter: rc=%Rrc\n", rc));
+                    LogRel(("VGDrvCommonInitDevExt: failed to set fixed event filter: rc=%Rrc\n", rc));
             }
             else
-                LogRel(("VbgdCommonInitDevExt: VBoxReportGuestInfo failed: rc=%Rrc\n", rc));
+                LogRel(("VGDrvCommonInitDevExt: VBoxReportGuestInfo failed: rc=%Rrc\n", rc));
             VbglGRFree((VMMDevRequestHeader *)pDevExt->pIrqAckEvents);
         }
         else
-            LogRel(("VbgdCommonInitDevExt: VBoxGRAlloc failed: rc=%Rrc\n", rc));
+            LogRel(("VGDrvCommonInitDevExt: VBoxGRAlloc failed: rc=%Rrc\n", rc));
 
         VbglTerminate();
     }
     else
-        LogRel(("VbgdCommonInitDevExt: VbglInit failed: rc=%Rrc\n", rc));
+        LogRel(("VGDrvCommonInitDevExt: VbglInit failed: rc=%Rrc\n", rc));
 
     rc2 = RTSemFastMutexDestroy(pDevExt->MemBalloon.hMtx); AssertRC(rc2);
@@ -1121,5 +1143,5 @@
  * @param   pList       The head of the chain.
  */
-static void vbgdDeleteWaitList(PRTLISTNODE pList)
+static void vgdrvDeleteWaitList(PRTLISTNODE pList)
 {
     while (!RTListIsEmpty(pList))
@@ -1145,8 +1167,8 @@
  * @param   pDevExt         The device extension.
  */
-void VbgdCommonDeleteDevExt(PVBOXGUESTDEVEXT pDevExt)
+void VGDrvCommonDeleteDevExt(PVBOXGUESTDEVEXT pDevExt)
 {
     int rc2;
-    Log(("VbgdCommonDeleteDevExt:\n"));
+    Log(("VGDrvCommonDeleteDevExt:\n"));
     Log(("VBoxGuest: The additions driver is terminating.\n"));
 
@@ -1158,5 +1180,5 @@
     {
         RTTimerDestroy(pDevExt->pHeartbeatTimer);
-        vbgdHeartbeatHostConfigure(pDevExt, false);
+        vgdrvHeartbeatHostConfigure(pDevExt, false);
     }
 
@@ -1167,5 +1189,5 @@
      * Clean up the bits that involves the host first.
      */
-    vbgdTermUnfixGuestMappings(pDevExt);
+    vgdrvTermUnfixGuestMappings(pDevExt);
     if (!RTListIsEmpty(&pDevExt->SessionList))
     {
@@ -1175,9 +1197,9 @@
     /* Update the host flags (mouse status etc) not to reflect this session. */
     pDevExt->fFixedEvents = 0;
-    vbgdResetEventFilterOnHost(pDevExt, 0 /*fFixedEvents*/);
-    vbgdResetCapabilitiesOnHost(pDevExt);
-    vbgdResetMouseStatusOnHost(pDevExt);
-
-    vbgdCloseMemBalloon(pDevExt, (PVBOXGUESTSESSION)NULL);
+    vgdrvResetEventFilterOnHost(pDevExt, 0 /*fFixedEvents*/);
+    vgdrvResetCapabilitiesOnHost(pDevExt);
+    vgdrvResetMouseStatusOnHost(pDevExt);
+
+    vgdrvCloseMemBalloon(pDevExt, (PVBOXGUESTSESSION)NULL);
 
     /*
@@ -1188,13 +1210,13 @@
     rc2 = RTSemFastMutexDestroy(pDevExt->MemBalloon.hMtx); AssertRC(rc2);
 
-    vbgdDeleteWaitList(&pDevExt->WaitList);
+    vgdrvDeleteWaitList(&pDevExt->WaitList);
 #ifdef VBOX_WITH_HGCM
-    vbgdDeleteWaitList(&pDevExt->HGCMWaitList);
+    vgdrvDeleteWaitList(&pDevExt->HGCMWaitList);
 #endif
 #ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
-    vbgdDeleteWaitList(&pDevExt->WakeUpList);
+    vgdrvDeleteWaitList(&pDevExt->WakeUpList);
 #endif
-    vbgdDeleteWaitList(&pDevExt->WokenUpList);
-    vbgdDeleteWaitList(&pDevExt->FreeList);
+    vgdrvDeleteWaitList(&pDevExt->WokenUpList);
+    vgdrvDeleteWaitList(&pDevExt->FreeList);
 
     VbglTerminate();
@@ -1217,5 +1239,5 @@
  *
  * The native code calls this when a ring-3 client opens the device.
- * Use VbgdCommonCreateKernelSession when a ring-0 client connects.
+ * Use VGDrvCommonCreateKernelSession when a ring-0 client connects.
  *
  * @returns VBox status code.
@@ -1223,10 +1245,10 @@
  * @param   ppSession       Where to store the session on success.
  */
-int VbgdCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
+int VGDrvCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
 {
     PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
     if (RT_UNLIKELY(!pSession))
     {
-        LogRel(("VbgdCommonCreateUserSession: no memory!\n"));
+        LogRel(("VGDrvCommonCreateUserSession: no memory!\n"));
         return VERR_NO_MEMORY;
     }
@@ -1241,5 +1263,5 @@
 
     *ppSession = pSession;
-    LogFlow(("VbgdCommonCreateUserSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
+    LogFlow(("VGDrvCommonCreateUserSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
              pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
     return VINF_SUCCESS;
@@ -1251,5 +1273,5 @@
  *
  * The native code calls this when a ring-0 client connects to the device.
- * Use VbgdCommonCreateUserSession when a ring-3 client opens the device.
+ * Use VGDrvCommonCreateUserSession when a ring-3 client opens the device.
  *
  * @returns VBox status code.
@@ -1257,10 +1279,10 @@
  * @param   ppSession       Where to store the session on success.
  */
-int VbgdCommonCreateKernelSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
+int VGDrvCommonCreateKernelSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
 {
     PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
     if (RT_UNLIKELY(!pSession))
     {
-        LogRel(("VbgdCommonCreateKernelSession: no memory!\n"));
+        LogRel(("VGDrvCommonCreateKernelSession: no memory!\n"));
         return VERR_NO_MEMORY;
     }
@@ -1275,5 +1297,5 @@
 
     *ppSession = pSession;
-    LogFlow(("VbgdCommonCreateKernelSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
+    LogFlow(("VGDrvCommonCreateKernelSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
              pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
     return VINF_SUCCESS;
@@ -1287,10 +1309,10 @@
  * @param   pSession        The session to close (and free).
  */
-void VbgdCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+void VGDrvCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
 {
 #ifdef VBOX_WITH_HGCM
     unsigned i;
 #endif
-    LogFlow(("VbgdCommonCloseSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
+    LogFlow(("VGDrvCommonCloseSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
              pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
 
@@ -1299,11 +1321,11 @@
     pDevExt->cSessions--;
     RTSpinlockRelease(pDevExt->SessionSpinlock);
-    vbgdAcquireSessionCapabilities(pDevExt, pSession, 0, UINT32_MAX, VBOXGUESTCAPSACQUIRE_FLAGS_NONE,
+    vgdrvAcquireSessionCapabilities(pDevExt, pSession, 0, UINT32_MAX, VBOXGUESTCAPSACQUIRE_FLAGS_NONE,
                                    true /*fSessionTermination*/);
-    vbgdSetSessionCapabilities(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
-    vbgdSetSessionEventFilter(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
-    vbgdSetSessionMouseStatus(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
-
-    vbgdIoCtl_CancelAllWaitEvents(pDevExt, pSession);
+    vgdrvSetSessionCapabilities(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
+    vgdrvSetSessionEventFilter(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
+    vgdrvSetSessionMouseStatus(pDevExt, pSession, 0 /*fOrMask*/, UINT32_MAX /*fNotMask*/, true /*fSessionTermination*/);
+
+    vgdrvIoCtl_CancelAllWaitEvents(pDevExt, pSession);
 
 #ifdef VBOX_WITH_HGCM
@@ -1315,6 +1337,6 @@
             Info.u32ClientID = pSession->aHGCMClientIds[i];
             pSession->aHGCMClientIds[i] = 0;
-            Log(("VbgdCommonCloseSession: disconnecting client id %#RX32\n", Info.u32ClientID));
-            VbglR0HGCMInternalDisconnect(&Info, vbgdHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
+            Log(("VGDrvCommonCloseSession: disconnecting client id %#RX32\n", Info.u32ClientID));
+            VbglR0HGCMInternalDisconnect(&Info, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
         }
 #endif
@@ -1323,5 +1345,5 @@
     pSession->Process = NIL_RTPROCESS;
     pSession->R0Process = NIL_RTR0PROCESS;
-    vbgdCloseMemBalloon(pDevExt, pSession);
+    vgdrvCloseMemBalloon(pDevExt, pSession);
     RTMemFree(pSession);
 }
@@ -1335,5 +1357,5 @@
  * @param   pSession        The session that's allocating this. Can be NULL.
  */
-static PVBOXGUESTWAIT vbgdWaitAlloc(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+static PVBOXGUESTWAIT vgdrvWaitAlloc(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
 {
     /*
@@ -1358,5 +1380,5 @@
         if (!pWait)
         {
-            LogRelMax(32, ("vbgdWaitAlloc: out-of-memory!\n"));
+            LogRelMax(32, ("vgdrvWaitAlloc: out-of-memory!\n"));
             return NULL;
         }
@@ -1365,5 +1387,5 @@
         if (RT_FAILURE(rc))
         {
-            LogRelMax(32, ("VbgdCommonIoCtl: RTSemEventMultiCreate failed with rc=%Rrc!\n", rc));
+            LogRelMax(32, ("vgdrvWaitAlloc: RTSemEventMultiCreate failed with rc=%Rrc!\n", rc));
             RTMemFree(pWait);
             return NULL;
@@ -1401,5 +1423,5 @@
  * @param   pWait           The wait-for-event entry to free.
  */
-static void vbgdWaitFreeLocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
+static void vgdrvWaitFreeLocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
 {
     pWait->fReqEvents = 0;
@@ -1427,8 +1449,8 @@
  * @param   pWait           The wait-for-event entry to free.
  */
-static void vbgdWaitFreeUnlocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
+static void vgdrvWaitFreeUnlocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
 {
     RTSpinlockAcquire(pDevExt->EventSpinlock);
-    vbgdWaitFreeLocked(pDevExt, pWait);
+    vgdrvWaitFreeLocked(pDevExt, pWait);
     RTSpinlockRelease(pDevExt->EventSpinlock);
 }
@@ -1444,5 +1466,5 @@
  * @param   pDevExt         The device extension.
  */
-void VbgdCommonWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt)
+void VGDrvCommonWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt)
 {
     if (!RTListIsEmpty(&pDevExt->WakeUpList))
@@ -1471,5 +1493,5 @@
             {
                 pWait->fFreeMe = false;
-                vbgdWaitFreeLocked(pDevExt, pWait);
+                vgdrvWaitFreeLocked(pDevExt, pWait);
             }
         }
@@ -1490,7 +1512,7 @@
  * @param   pSession    The session.
  */
-int  VbgdCommonIoCtlFast(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
-{
-    LogFlow(("VbgdCommonIoCtlFast: iFunction=%#x pDevExt=%p pSession=%p\n", iFunction, pDevExt, pSession));
+int VGDrvCommonIoCtlFast(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+{
+    LogFlow(("VGDrvCommonIoCtlFast: iFunction=%#x pDevExt=%p pSession=%p\n", iFunction, pDevExt, pSession));
 
     NOREF(iFunction);
@@ -1509,5 +1531,5 @@
  * @param   pcbDataReturned (out) contains the number of bytes to return.
  */
-static int vbgdIoCtl_GetVMMDevPort(PVBOXGUESTDEVEXT pDevExt, VBoxGuestPortInfo *pInfo, size_t *pcbDataReturned)
+static int vgdrvIoCtl_GetVMMDevPort(PVBOXGUESTDEVEXT pDevExt, VBoxGuestPortInfo *pInfo, size_t *pcbDataReturned)
 {
     LogFlow(("VBOXGUEST_IOCTL_GETVMMDEVPORT\n"));
@@ -1529,5 +1551,5 @@
  * @param   pNotify         The new callback information.
  */
-int vbgdIoCtl_SetMouseNotifyCallback(PVBOXGUESTDEVEXT pDevExt, VBoxGuestMouseSetNotifyCallback *pNotify)
+int vgdrvIoCtl_SetMouseNotifyCallback(PVBOXGUESTDEVEXT pDevExt, VBoxGuestMouseSetNotifyCallback *pNotify)
 {
     LogFlow(("VBOXGUEST_IOCTL_SET_MOUSE_NOTIFY_CALLBACK: pfnNotify=%p pvUser=%p\n", pNotify->pfnNotify, pNotify->pvUser));
@@ -1542,5 +1564,5 @@
 
 /**
- * Worker vbgdIoCtl_WaitEvent.
+ * Worker vgdrvIoCtl_WaitEvent.
  *
  * The caller enters the spinlock, we leave it.
@@ -1553,5 +1575,5 @@
     uint32_t fMatches = pDevExt->f32PendingEvents & fReqEvents;
     if (fMatches & VBOXGUEST_ACQUIRE_STYLE_EVENTS)
-        fMatches &= vbgdGetAllowedEventMaskForSession(pDevExt, pSession);
+        fMatches &= vgdrvGetAllowedEventMaskForSession(pDevExt, pSession);
     if (fMatches || pSession->fPendingCancelWaitEvents)
     {
@@ -1574,6 +1596,6 @@
 
 
-static int vbgdIoCtl_WaitEvent(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                               VBoxGuestWaitEventInfo *pInfo,  size_t *pcbDataReturned, bool fInterruptible)
+static int vgdrvIoCtl_WaitEvent(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                VBoxGuestWaitEventInfo *pInfo,  size_t *pcbDataReturned, bool fInterruptible)
 {
     const uint32_t  fReqEvents = pInfo->u32EventMaskIn;
@@ -1613,5 +1635,5 @@
     }
 
-    pWait = vbgdWaitAlloc(pDevExt, pSession);
+    pWait = vgdrvWaitAlloc(pDevExt, pSession);
     if (!pWait)
         return VERR_NO_MEMORY;
@@ -1628,5 +1650,5 @@
     if (rc == VINF_SUCCESS)
     {
-        vbgdWaitFreeUnlocked(pDevExt, pWait);
+        vgdrvWaitFreeUnlocked(pDevExt, pWait);
         return rc;
     }
@@ -1652,5 +1674,5 @@
     RTSpinlockAcquire(pDevExt->EventSpinlock);
     fResEvents = pWait->fResEvents;
-    vbgdWaitFreeLocked(pDevExt, pWait);
+    vgdrvWaitFreeLocked(pDevExt, pWait);
     RTSpinlockRelease(pDevExt->EventSpinlock);
 
@@ -1696,5 +1718,5 @@
 
 
-static int vbgdIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+static int vgdrvIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
 {
     PVBOXGUESTWAIT          pWait;
@@ -1735,5 +1757,5 @@
 
 #ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
-    VbgdCommonWaitDoWakeUps(pDevExt);
+    VGDrvCommonWaitDoWakeUps(pDevExt);
 #endif
 
@@ -1750,6 +1772,6 @@
  * @param   pReqHdr             The request.
  */
-static int vbgdCheckIfVmmReqIsAllowed(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VMMDevRequestType enmType,
-                                      VMMDevRequestHeader const *pReqHdr)
+static int vgdrvCheckIfVmmReqIsAllowed(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VMMDevRequestType enmType,
+                                       VMMDevRequestHeader const *pReqHdr)
 {
     /*
@@ -1895,6 +1917,6 @@
 }
 
-static int vbgdIoCtl_VMMRequest(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                VMMDevRequestHeader *pReqHdr, size_t cbData, size_t *pcbDataReturned)
+static int vgdrvIoCtl_VMMRequest(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                 VMMDevRequestHeader *pReqHdr, size_t cbData, size_t *pcbDataReturned)
 {
     int                     rc;
@@ -1930,5 +1952,5 @@
     }
 
-    rc = vbgdCheckIfVmmReqIsAllowed(pDevExt, pSession, enmType, pReqHdr);
+    rc = vgdrvCheckIfVmmReqIsAllowed(pDevExt, pSession, enmType, pReqHdr);
     if (RT_FAILURE(rc))
     {
@@ -1984,7 +2006,7 @@
 AssertCompile(RT_INDEFINITE_WAIT == (uint32_t)RT_INDEFINITE_WAIT); /* assumed by code below */
 
-/** Worker for vbgdHgcmAsyncWaitCallback*. */
-static int vbgdHgcmAsyncWaitCallbackWorker(VMMDevHGCMRequestHeader volatile *pHdr, PVBOXGUESTDEVEXT pDevExt,
-                                           bool fInterruptible, uint32_t cMillies)
+/** Worker for vgdrvHgcmAsyncWaitCallback*. */
+static int vgdrvHgcmAsyncWaitCallbackWorker(VMMDevHGCMRequestHeader volatile *pHdr, PVBOXGUESTDEVEXT pDevExt,
+                                            bool fInterruptible, uint32_t cMillies)
 {
     int rc;
@@ -2008,5 +2030,5 @@
         RTSpinlockRelease(pDevExt->EventSpinlock);
 
-        pWait = vbgdWaitAlloc(pDevExt, NULL);
+        pWait = vgdrvWaitAlloc(pDevExt, NULL);
         if (pWait)
             break;
@@ -2027,5 +2049,5 @@
     if ((pHdr->fu32Flags & VBOX_HGCM_REQ_DONE) != 0)
     {
-        vbgdWaitFreeLocked(pDevExt, pWait);
+        vgdrvWaitFreeLocked(pDevExt, pWait);
         RTSpinlockRelease(pDevExt->EventSpinlock);
         return VINF_SUCCESS;
@@ -2047,7 +2069,7 @@
         && (   !fInterruptible
             || rc != VERR_INTERRUPTED))
-        LogRel(("vbgdHgcmAsyncWaitCallback: wait failed! %Rrc\n", rc));
-
-    vbgdWaitFreeUnlocked(pDevExt, pWait);
+        LogRel(("vgdrvHgcmAsyncWaitCallback: wait failed! %Rrc\n", rc));
+
+    vgdrvWaitFreeUnlocked(pDevExt, pWait);
     return rc;
 }
@@ -2057,12 +2079,12 @@
  * This is a callback for dealing with async waits.
  *
- * It operates in a manner similar to vbgdIoCtl_WaitEvent.
- */
-static DECLCALLBACK(int) vbgdHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
+ * It operates in a manner similar to vgdrvIoCtl_WaitEvent.
+ */
+static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
 {
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
-    LogFlow(("vbgdHgcmAsyncWaitCallback: requestType=%d\n", pHdr->header.requestType));
-    return vbgdHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
-                                           false /* fInterruptible */, u32User  /* cMillies */);
+    LogFlow(("vgdrvHgcmAsyncWaitCallback: requestType=%d\n", pHdr->header.requestType));
+    return vgdrvHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
+                                            false /* fInterruptible */, u32User  /* cMillies */);
 }
 
@@ -2071,17 +2093,17 @@
  * This is a callback for dealing with async waits with a timeout.
  *
- * It operates in a manner similar to vbgdIoCtl_WaitEvent.
- */
-static DECLCALLBACK(int) vbgdHgcmAsyncWaitCallbackInterruptible(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
+ * It operates in a manner similar to vgdrvIoCtl_WaitEvent.
+ */
+static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallbackInterruptible(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
 {
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
-    LogFlow(("vbgdHgcmAsyncWaitCallbackInterruptible: requestType=%d\n", pHdr->header.requestType));
-    return vbgdHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
-                                           true /* fInterruptible */, u32User /* cMillies */);
-}
-
-
-static int vbgdIoCtl_HGCMConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                 VBoxGuestHGCMConnectInfo *pInfo, size_t *pcbDataReturned)
+    LogFlow(("vgdrvHgcmAsyncWaitCallbackInterruptible: requestType=%d\n", pHdr->header.requestType));
+    return vgdrvHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
+                                            true /* fInterruptible */, u32User /* cMillies */);
+}
+
+
+static int vgdrvIoCtl_HGCMConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                  VBoxGuestHGCMConnectInfo *pInfo, size_t *pcbDataReturned)
 {
     int rc;
@@ -2096,5 +2118,5 @@
          ? pInfo->Loc.u.host.achName : "<not local host>"));
 
-    rc = VbglR0HGCMInternalConnect(pInfo, vbgdHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
+    rc = VbglR0HGCMInternalConnect(pInfo, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
     if (RT_SUCCESS(rc))
     {
@@ -2122,5 +2144,5 @@
                 Info.result = 0;
                 Info.u32ClientID = pInfo->u32ClientID;
-                VbglR0HGCMInternalDisconnect(&Info, vbgdHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
+                VbglR0HGCMInternalDisconnect(&Info, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
                 return VERR_TOO_MANY_OPEN_FILES;
             }
@@ -2135,6 +2157,6 @@
 
 
-static int vbgdIoCtl_HGCMDisconnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                    VBoxGuestHGCMDisconnectInfo *pInfo, size_t *pcbDataReturned)
+static int vgdrvIoCtl_HGCMDisconnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                     VBoxGuestHGCMDisconnectInfo *pInfo, size_t *pcbDataReturned)
 {
     /*
@@ -2164,5 +2186,5 @@
      */
     Log(("VBOXGUEST_IOCTL_HGCM_DISCONNECT: u32Client=%RX32\n", pInfo->u32ClientID));
-    rc = VbglR0HGCMInternalDisconnect(pInfo, vbgdHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
+    rc = VbglR0HGCMInternalDisconnect(pInfo, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
     if (RT_SUCCESS(rc))
     {
@@ -2182,7 +2204,7 @@
 
 
-static int vbgdIoCtl_HGCMCall(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestHGCMCallInfo *pInfo,
-                              uint32_t cMillies, bool fInterruptible, bool f32bit, bool fUserData,
-                              size_t cbExtra, size_t cbData, size_t *pcbDataReturned)
+static int vgdrvIoCtl_HGCMCall(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestHGCMCallInfo *pInfo,
+                               uint32_t cMillies, bool fInterruptible, bool f32bit, bool fUserData,
+                               size_t cbExtra, size_t cbData, size_t *pcbDataReturned)
 {
     const uint32_t  u32ClientId = pInfo->u32ClientID;
@@ -2242,7 +2264,7 @@
     {
         if (fInterruptible)
-            rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, vbgdHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
+            rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, vgdrvHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
         else
-            rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, vbgdHgcmAsyncWaitCallback, pDevExt, cMillies);
+            rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, vgdrvHgcmAsyncWaitCallback, pDevExt, cMillies);
     }
     else
@@ -2250,7 +2272,7 @@
     {
         if (fInterruptible)
-            rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, vbgdHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
+            rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, vgdrvHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
         else
-            rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, vbgdHgcmAsyncWaitCallback, pDevExt, cMillies);
+            rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, vgdrvHgcmAsyncWaitCallback, pDevExt, cMillies);
     }
     if (RT_SUCCESS(rc))
@@ -2288,6 +2310,6 @@
  *                              be NULL.
  */
-static int vbgdIoCtl_CheckMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                        VBoxGuestCheckBalloonInfo *pInfo, size_t *pcbDataReturned)
+static int vgdrvIoCtl_CheckMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                         VBoxGuestCheckBalloonInfo *pInfo, size_t *pcbDataReturned)
 {
     VMMDevGetMemBalloonChangeRequest *pReq;
@@ -2300,5 +2322,5 @@
     /*
      * The first user trying to query/change the balloon becomes the
-     * owner and owns it until the session is closed (vbgdCloseMemBalloon).
+     * owner and owns it until the session is closed (vgdrvCloseMemBalloon).
      */
     if (   pDevExt->MemBalloon.pOwner != pSession
@@ -2326,5 +2348,5 @@
                 pInfo->fHandleInR3    = false;
 
-                rc = vbgdSetBalloonSizeKernel(pDevExt, pReq->cBalloonChunks, &pInfo->fHandleInR3);
+                rc = vgdrvSetBalloonSizeKernel(pDevExt, pReq->cBalloonChunks, &pInfo->fHandleInR3);
                 /* Ignore various out of memory failures. */
                 if (   rc == VERR_NO_MEMORY
@@ -2361,6 +2383,6 @@
  *                              be NULL.
  */
-static int vbgdIoCtl_ChangeMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                         VBoxGuestChangeBalloonInfo *pInfo, size_t *pcbDataReturned)
+static int vgdrvIoCtl_ChangeMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                          VBoxGuestChangeBalloonInfo *pInfo, size_t *pcbDataReturned)
 {
     int rc;
@@ -2374,5 +2396,5 @@
         /*
          * The first user trying to query/change the balloon becomes the
-         * owner and owns it until the session is closed (vbgdCloseMemBalloon).
+         * owner and owns it until the session is closed (vgdrvCloseMemBalloon).
          */
         if (   pDevExt->MemBalloon.pOwner != pSession
@@ -2382,5 +2404,5 @@
         if (pDevExt->MemBalloon.pOwner == pSession)
         {
-            rc = vbgdSetBalloonSizeFromUser(pDevExt, pSession, pInfo->u64ChunkAddr, !!pInfo->fInflate);
+            rc = vgdrvSetBalloonSizeFromUser(pDevExt, pSession, pInfo->u64ChunkAddr, !!pInfo->fInflate);
             if (pcbDataReturned)
                 *pcbDataReturned = 0;
@@ -2405,5 +2427,5 @@
  * @param pInfo                 The output buffer.
  */
-static int vbgdIoCtl_WriteCoreDump(PVBOXGUESTDEVEXT pDevExt, VBoxGuestWriteCoreDump *pInfo)
+static int vgdrvIoCtl_WriteCoreDump(PVBOXGUESTDEVEXT pDevExt, VBoxGuestWriteCoreDump *pInfo)
 {
     VMMDevReqWriteCoreDump *pReq = NULL;
@@ -2438,5 +2460,5 @@
  * @param   pcbDataReturned     Where to store the amount of returned data. Can be NULL.
  */
-static int vbgdIoCtl_Log(PVBOXGUESTDEVEXT pDevExt, const char *pch, size_t cbData, size_t *pcbDataReturned, bool fUserSession)
+static int vgdrvIoCtl_Log(PVBOXGUESTDEVEXT pDevExt, const char *pch, size_t cbData, size_t *pcbDataReturned, bool fUserSession)
 {
     if (pDevExt->fLoggingEnabled)
@@ -2461,5 +2483,5 @@
  * @param   pTracker            The tracker to clear.
  */
-static void vbgdBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker)
+static void vgdrvBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker)
 {
     uint32_t iBit;
@@ -2481,5 +2503,5 @@
  * @param   pszWhat             Identifies the tracker in assertions.
  */
-static void vbgdBitUsageTrackerCheckMask(PCVBOXGUESTBITUSAGETRACER pTracker, uint32_t cMax, const char *pszWhat)
+static void vgdrvBitUsageTrackerCheckMask(PCVBOXGUESTBITUSAGETRACER pTracker, uint32_t cMax, const char *pszWhat)
 {
     uint32_t fMask = 0;
@@ -2511,6 +2533,6 @@
  * @param   pszWhat             Identifies the tracker in assertions.
  */
-static bool vbgdBitUsageTrackerChange(PVBOXGUESTBITUSAGETRACER pTracker, uint32_t fChanged, uint32_t fPrevious,
-                                      uint32_t cMax, const char *pszWhat)
+static bool vgdrvBitUsageTrackerChange(PVBOXGUESTBITUSAGETRACER pTracker, uint32_t fChanged, uint32_t fPrevious,
+                                       uint32_t cMax, const char *pszWhat)
 {
     bool fGlobalChange = false;
@@ -2550,5 +2572,5 @@
 
 #ifdef VBOX_STRICT
-    vbgdBitUsageTrackerCheckMask(pTracker, cMax, pszWhat);
+    vgdrvBitUsageTrackerCheckMask(pTracker, cMax, pszWhat);
 #endif
     NOREF(pszWhat); NOREF(cMax);
@@ -2564,5 +2586,5 @@
  * @param   fFixedEvents    Fixed events (init time).
  */
-static int vbgdResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents)
+static int vgdrvResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents)
 {
     VMMDevCtlGuestFilterMask *pReq;
@@ -2599,6 +2621,6 @@
  * @remarks Takes the session spinlock.
  */
-static int vbgdSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                     uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
+static int vgdrvSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                      uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
 {
     VMMDevCtlGuestFilterMask   *pReq;
@@ -2615,5 +2637,5 @@
     else if (!fSessionTermination)
     {
-        LogRel(("vbgdSetSessionFilterMask: VbglGRAlloc failure: %Rrc\n", rc));
+        LogRel(("vgdrvSetSessionFilterMask: VbglGRAlloc failure: %Rrc\n", rc));
         return rc;
     }
@@ -2637,6 +2659,6 @@
     if (fChanged)
     {
-        bool fGlobalChange = vbgdBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, fPrevious,
-                                                       pDevExt->cSessions, "EventFilterTracker");
+        bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, fPrevious,
+                                                        pDevExt->cSessions, "EventFilterTracker");
 
         /*
@@ -2664,6 +2686,6 @@
                         if (!fSessionTermination)
                         {
-                            vbgdBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, pSession->fEventFilter,
-                                                      pDevExt->cSessions, "EventFilterTracker");
+                            vgdrvBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, pSession->fEventFilter,
+                                                       pDevExt->cSessions, "EventFilterTracker");
                             pSession->fEventFilter = fPrevious;
                         }
@@ -2692,5 +2714,5 @@
  * @param   pInfo               The request.
  */
-static int vbgdIoCtl_CtlFilterMask(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestFilterMaskInfo *pInfo)
+static int vgdrvIoCtl_CtlFilterMask(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestFilterMaskInfo *pInfo)
 {
     LogFlow(("VBOXGUEST_IOCTL_CTL_FILTER_MASK: or=%#x not=%#x\n", pInfo->u32OrMask, pInfo->u32NotMask));
@@ -2702,5 +2724,5 @@
     }
 
-    return vbgdSetSessionEventFilter(pDevExt, pSession, pInfo->u32OrMask, pInfo->u32NotMask, false /*fSessionTermination*/);
+    return vgdrvSetSessionEventFilter(pDevExt, pSession, pInfo->u32OrMask, pInfo->u32NotMask, false /*fSessionTermination*/);
 }
 
@@ -2712,5 +2734,5 @@
  * @param   pDevExt         The device extension.
  */
-static int vbgdResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt)
+static int vgdrvResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt)
 {
     VMMDevReqMouseStatus *pReq;
@@ -2748,6 +2770,6 @@
  * @remarks Takes the session spinlock.
  */
-static int vbgdSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                     uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
+static int vgdrvSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                      uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
 {
     VMMDevReqMouseStatus   *pReq;
@@ -2764,5 +2786,5 @@
     else if (!fSessionTermination)
     {
-        LogRel(("vbgdSetSessionMouseStatus: VbglGRAlloc failure: %Rrc\n", rc));
+        LogRel(("vgdrvSetSessionMouseStatus: VbglGRAlloc failure: %Rrc\n", rc));
         return rc;
     }
@@ -2786,6 +2808,6 @@
     if (fChanged)
     {
-        bool fGlobalChange = vbgdBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, fPrevious,
-                                                       pDevExt->cSessions, "MouseStatusTracker");
+        bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, fPrevious,
+                                                        pDevExt->cSessions, "MouseStatusTracker");
 
         /*
@@ -2814,6 +2836,6 @@
                         if (!fSessionTermination)
                         {
-                            vbgdBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, pSession->fMouseStatus,
-                                                      pDevExt->cSessions, "MouseStatusTracker");
+                            vgdrvBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, pSession->fMouseStatus,
+                                                       pDevExt->cSessions, "MouseStatusTracker");
                             pSession->fMouseStatus = fPrevious;
                         }
@@ -2842,5 +2864,5 @@
  * @param   fFeatures           New bitmap of enabled features.
  */
-static int vbgdIoCtl_SetMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fFeatures)
+static int vgdrvIoCtl_SetMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fFeatures)
 {
     LogFlow(("VBOXGUEST_IOCTL_SET_MOUSE_STATUS: features=%#x\n", fFeatures));
@@ -2849,5 +2871,5 @@
         return VERR_INVALID_PARAMETER;
 
-    return vbgdSetSessionMouseStatus(pDevExt, pSession, fFeatures, ~fFeatures, false /*fSessionTermination*/);
+    return vgdrvSetSessionMouseStatus(pDevExt, pSession, fFeatures, ~fFeatures, false /*fSessionTermination*/);
 }
 
@@ -2871,5 +2893,5 @@
  *          VBOXGUEST_ACQUIRE_STYLE_EVENTS mask.
  */
-static uint32_t vbgdGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
+static uint32_t vgdrvGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
 {
     uint32_t fAcquireModeGuestCaps;
@@ -2909,5 +2931,5 @@
  * @param   pDevExt         The device extension.
  */
-static int vbgdResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt)
+static int vgdrvResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt)
 {
     VMMDevReqGuestCapabilities2 *pReq;
@@ -2936,5 +2958,5 @@
  * @param   fMask       The new mask.
  */
-static int vbgdUpdateCapabilitiesOnHostWithReqAndLock(PVBOXGUESTDEVEXT pDevExt, VMMDevReqGuestCapabilities2 *pReq)
+static int vgdrvUpdateCapabilitiesOnHostWithReqAndLock(PVBOXGUESTDEVEXT pDevExt, VMMDevReqGuestCapabilities2 *pReq)
 {
     int rc;
@@ -2982,7 +3004,7 @@
  * @remarks Takes both the session and event spinlocks.
  */
-static int vbgdAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                          uint32_t fOrMask, uint32_t fNotMask, VBOXGUESTCAPSACQUIRE_FLAGS enmFlags,
-                                          bool fSessionTermination)
+static int vgdrvAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                           uint32_t fOrMask, uint32_t fNotMask, VBOXGUESTCAPSACQUIRE_FLAGS enmFlags,
+                                           bool fSessionTermination)
 {
     uint32_t fCurrentOwnedCaps;
@@ -3001,5 +3023,5 @@
                     | VMMDEV_GUEST_SUPPORTS_GRAPHICS ) )
     {
-        LogRel(("vbgdAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x -- invalid fOrMask\n",
+        LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x -- invalid fOrMask\n",
                 pSession, fOrMask, fNotMask, enmFlags));
         return VERR_INVALID_PARAMETER;
@@ -3009,5 +3031,5 @@
         && enmFlags != VBOXGUESTCAPSACQUIRE_FLAGS_NONE)
     {
-        LogRel(("vbgdAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: invalid enmFlags %d\n",
+        LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: invalid enmFlags %d\n",
                 pSession, fOrMask, fNotMask, enmFlags));
         return VERR_INVALID_PARAMETER;
@@ -3029,5 +3051,5 @@
         else if (!fSessionTermination)
         {
-            LogRel(("vbgdAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: VbglGRAlloc failure: %Rrc\n",
+            LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: VbglGRAlloc failure: %Rrc\n",
                     pSession, fOrMask, fNotMask, enmFlags, rc));
             return rc;
@@ -3054,5 +3076,5 @@
             VbglGRFree(&pReq->header);
         AssertMsgFailed(("Trying to change caps mode: %#x\n", fOrMask));
-        LogRel(("vbgdAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: calling caps acquire for set caps\n",
+        LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: calling caps acquire for set caps\n",
                 pSession, fOrMask, fNotMask, enmFlags));
         return VERR_INVALID_STATE;
@@ -3067,5 +3089,5 @@
 
         Assert(!pReq);
-        Log(("vbgdAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: configured acquire caps: 0x%x\n",
+        Log(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x enmFlags=%#x: configured acquire caps: 0x%x\n",
              pSession, fOrMask, fNotMask, enmFlags));
         return VINF_SUCCESS;
@@ -3107,5 +3129,5 @@
             if (pReq)
             {
-                rc = vbgdUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
+                rc = vgdrvUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
                 if (RT_FAILURE(rc) && !fSessionTermination)
                 {
@@ -3123,5 +3145,5 @@
 
                     RTSpinlockRelease(pDevExt->EventSpinlock);
-                    LogRel(("vbgdAcquireSessionCapabilities: vbgdUpdateCapabilitiesOnHostWithReqAndLock failed: rc=%Rrc\n", rc));
+                    LogRel(("vgdrvAcquireSessionCapabilities: vgdrvUpdateCapabilitiesOnHostWithReqAndLock failed: rc=%Rrc\n", rc));
                     VbglGRFree(&pReq->header);
                     return rc;
@@ -3134,5 +3156,5 @@
         RTSpinlockRelease(pDevExt->EventSpinlock);
 
-        Log(("vbgdAcquireSessionCapabilities: Caps %#x were busy\n", fOtherConflictingCaps));
+        Log(("vgdrvAcquireSessionCapabilities: Caps %#x were busy\n", fOtherConflictingCaps));
         VbglGRFree(&pReq->header);
         return VERR_RESOURCE_BUSY;
@@ -3161,9 +3183,9 @@
         RTSpinlockAcquire(pDevExt->EventSpinlock);
         if (fGenFakeEvents || pDevExt->f32PendingEvents)
-            vbgdDispatchEventsLocked(pDevExt, fGenFakeEvents);
+            vgdrvDispatchEventsLocked(pDevExt, fGenFakeEvents);
         RTSpinlockRelease(pDevExt->EventSpinlock);
 
 #ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
-        VbgdCommonWaitDoWakeUps(pDevExt);
+        VGDrvCommonWaitDoWakeUps(pDevExt);
 #endif
     }
@@ -3182,5 +3204,5 @@
  * @param   pAcquire            The request.
  */
-static int vbgdIoCtl_GuestCapsAcquire(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestCapsAquire *pAcquire)
+static int vgdrvIoCtl_GuestCapsAcquire(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestCapsAquire *pAcquire)
 {
     int rc;
@@ -3188,8 +3210,8 @@
              pAcquire->u32OrMask, pAcquire->u32NotMask, pAcquire->enmFlags));
 
-    rc = vbgdAcquireSessionCapabilities(pDevExt, pSession, pAcquire->u32OrMask, pAcquire->u32NotMask, pAcquire->enmFlags,
-                                        false /*fSessionTermination*/);
+    rc = vgdrvAcquireSessionCapabilities(pDevExt, pSession, pAcquire->u32OrMask, pAcquire->u32NotMask, pAcquire->enmFlags,
+                                         false /*fSessionTermination*/);
     if (RT_FAILURE(rc))
-        LogRel(("VbgdCommonIoCtl: GUEST_CAPS_ACQUIRE failed rc=%Rrc\n", rc));
+        LogRel(("VGDrvCommonIoCtl: GUEST_CAPS_ACQUIRE failed rc=%Rrc\n", rc));
     pAcquire->rc = rc;
     return VINF_SUCCESS;
@@ -3212,6 +3234,6 @@
  * @remarks Takes the session spinlock.
  */
-static int vbgdSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                                      uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
+static int vgdrvSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                                       uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
 {
     /*
@@ -3224,5 +3246,5 @@
     else if (!fSessionTermination)
     {
-        LogRel(("vbgdSetSessionCapabilities: VbglGRAlloc failure: %Rrc\n", rc));
+        LogRel(("vgdrvSetSessionCapabilities: VbglGRAlloc failure: %Rrc\n", rc));
         return rc;
     }
@@ -3255,6 +3277,6 @@
         if (fChanged)
         {
-            bool fGlobalChange = vbgdBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, fPrevious,
-                                                           pDevExt->cSessions, "SetGuestCapsTracker");
+            bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, fPrevious,
+                                                            pDevExt->cSessions, "SetGuestCapsTracker");
 
             /*
@@ -3266,11 +3288,11 @@
                 if (pReq)
                 {
-                    rc = vbgdUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
+                    rc = vgdrvUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
 
                     /* On failure, roll back (unless it's session termination time). */
                     if (RT_FAILURE(rc) && !fSessionTermination)
                     {
-                        vbgdBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, pSession->fCapabilities,
-                                                  pDevExt->cSessions, "SetGuestCapsTracker");
+                        vgdrvBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, pSession->fCapabilities,
+                                                   pDevExt->cSessions, "SetGuestCapsTracker");
                         pSession->fCapabilities = fPrevious;
                     }
@@ -3300,5 +3322,5 @@
  * @param   pInfo               The request.
  */
-static int vbgdIoCtl_SetCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestSetCapabilitiesInfo *pInfo)
+static int vgdrvIoCtl_SetCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestSetCapabilitiesInfo *pInfo)
 {
     int rc;
@@ -3306,5 +3328,5 @@
 
     if (!((pInfo->u32OrMask | pInfo->u32NotMask) & ~VMMDEV_GUEST_CAPABILITIES_MASK))
-        rc = vbgdSetSessionCapabilities(pDevExt, pSession, pInfo->u32OrMask, pInfo->u32NotMask, false /*fSessionTermination*/);
+        rc = vgdrvSetSessionCapabilities(pDevExt, pSession, pInfo->u32OrMask, pInfo->u32NotMask, false /*fSessionTermination*/);
     else
         rc = VERR_INVALID_PARAMETER;
@@ -3331,9 +3353,9 @@
  * @param   pcbDataReturned     Where to store the amount of returned data. Can be NULL.
  */
-int VbgdCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                    void *pvData, size_t cbData, size_t *pcbDataReturned)
+int VGDrvCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                     void *pvData, size_t cbData, size_t *pcbDataReturned)
 {
     int rc;
-    LogFlow(("VbgdCommonIoCtl: iFunction=%#x pDevExt=%p pSession=%p pvData=%p cbData=%zu\n",
+    LogFlow(("VGDrvCommonIoCtl: iFunction=%#x pDevExt=%p pSession=%p pvData=%p cbData=%zu\n",
              iFunction, pDevExt, pSession, pvData, cbData));
 
@@ -3393,5 +3415,5 @@
     {
         CHECKRET_MIN_SIZE("VMMREQUEST", sizeof(VMMDevRequestHeader));
-        rc = vbgdIoCtl_VMMRequest(pDevExt, pSession, (VMMDevRequestHeader *)pvData, cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_VMMRequest(pDevExt, pSession, (VMMDevRequestHeader *)pvData, cbData, pcbDataReturned);
     }
 #ifdef VBOX_WITH_HGCM
@@ -3403,7 +3425,7 @@
         bool fInterruptible = pSession->R0Process != NIL_RTR0PROCESS;
         CHECKRET_MIN_SIZE("HGCM_CALL", sizeof(VBoxGuestHGCMCallInfo));
-        rc = vbgdIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
-                                fInterruptible, false /*f32bit*/, false /* fUserData */,
-                                0, cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
+                                 fInterruptible, false /*f32bit*/, false /* fUserData */,
+                                 0, cbData, pcbDataReturned);
     }
     else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0)))
@@ -3411,8 +3433,8 @@
         VBoxGuestHGCMCallInfoTimed *pInfo = (VBoxGuestHGCMCallInfoTimed *)pvData;
         CHECKRET_MIN_SIZE("HGCM_CALL_TIMED", sizeof(VBoxGuestHGCMCallInfoTimed));
-        rc = vbgdIoCtl_HGCMCall(pDevExt, pSession, &pInfo->info, pInfo->u32Timeout,
-                                !!pInfo->fInterruptible || pSession->R0Process != NIL_RTR0PROCESS,
-                                false /*f32bit*/, false /* fUserData */,
-                                RT_OFFSETOF(VBoxGuestHGCMCallInfoTimed, info), cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_HGCMCall(pDevExt, pSession, &pInfo->info, pInfo->u32Timeout,
+                                 !!pInfo->fInterruptible || pSession->R0Process != NIL_RTR0PROCESS,
+                                 false /*f32bit*/, false /* fUserData */,
+                                 RT_OFFSETOF(VBoxGuestHGCMCallInfoTimed, info), cbData, pcbDataReturned);
     }
     else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_USERDATA(0)))
@@ -3420,7 +3442,7 @@
         bool fInterruptible = true;
         CHECKRET_MIN_SIZE("HGCM_CALL", sizeof(VBoxGuestHGCMCallInfo));
-        rc = vbgdIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
-                                fInterruptible, false /*f32bit*/, true /* fUserData */,
-                                0, cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
+                                 fInterruptible, false /*f32bit*/, true /* fUserData */,
+                                 0, cbData, pcbDataReturned);
     }
 # ifdef RT_ARCH_AMD64
@@ -3429,7 +3451,7 @@
         bool fInterruptible = pSession->R0Process != NIL_RTR0PROCESS;
         CHECKRET_MIN_SIZE("HGCM_CALL", sizeof(VBoxGuestHGCMCallInfo));
-        rc = vbgdIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
-                                fInterruptible, true /*f32bit*/, false /* fUserData */,
-                                0, cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, RT_INDEFINITE_WAIT,
+                                 fInterruptible, true /*f32bit*/, false /* fUserData */,
+                                 0, cbData, pcbDataReturned);
     }
     else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMED_32(0)))
@@ -3437,8 +3459,8 @@
         CHECKRET_MIN_SIZE("HGCM_CALL_TIMED", sizeof(VBoxGuestHGCMCallInfoTimed));
         VBoxGuestHGCMCallInfoTimed *pInfo = (VBoxGuestHGCMCallInfoTimed *)pvData;
-        rc = vbgdIoCtl_HGCMCall(pDevExt, pSession, &pInfo->info, pInfo->u32Timeout,
-                                !!pInfo->fInterruptible || pSession->R0Process != NIL_RTR0PROCESS,
-                                true /*f32bit*/, false /* fUserData */,
-                                RT_OFFSETOF(VBoxGuestHGCMCallInfoTimed, info), cbData, pcbDataReturned);
+        rc = vgdrvIoCtl_HGCMCall(pDevExt, pSession, &pInfo->info, pInfo->u32Timeout,
+                                 !!pInfo->fInterruptible || pSession->R0Process != NIL_RTR0PROCESS,
+                                 true /*f32bit*/, false /* fUserData */,
+                                 RT_OFFSETOF(VBoxGuestHGCMCallInfoTimed, info), cbData, pcbDataReturned);
     }
 # endif
@@ -3447,5 +3469,5 @@
     {
         CHECKRET_MIN_SIZE("LOG", 1);
-        rc = vbgdIoCtl_Log(pDevExt, (char *)pvData, cbData, pcbDataReturned, pSession->fUserSession);
+        rc = vgdrvIoCtl_Log(pDevExt, (char *)pvData, cbData, pcbDataReturned, pSession->fUserSession);
     }
     else
@@ -3456,5 +3478,5 @@
                 CHECKRET_RING0("GETVMMDEVPORT");
                 CHECKRET_MIN_SIZE("GETVMMDEVPORT", sizeof(VBoxGuestPortInfo));
-                rc = vbgdIoCtl_GetVMMDevPort(pDevExt, (VBoxGuestPortInfo *)pvData, pcbDataReturned);
+                rc = vgdrvIoCtl_GetVMMDevPort(pDevExt, (VBoxGuestPortInfo *)pvData, pcbDataReturned);
                 break;
 
@@ -3463,5 +3485,5 @@
                 CHECKRET_RING0("SET_MOUSE_NOTIFY_CALLBACK");
                 CHECKRET_SIZE("SET_MOUSE_NOTIFY_CALLBACK", sizeof(VBoxGuestMouseSetNotifyCallback));
-                rc = vbgdIoCtl_SetMouseNotifyCallback(pDevExt, (VBoxGuestMouseSetNotifyCallback *)pvData);
+                rc = vgdrvIoCtl_SetMouseNotifyCallback(pDevExt, (VBoxGuestMouseSetNotifyCallback *)pvData);
                 break;
 #endif
@@ -3469,16 +3491,16 @@
             case VBOXGUEST_IOCTL_WAITEVENT:
                 CHECKRET_MIN_SIZE("WAITEVENT", sizeof(VBoxGuestWaitEventInfo));
-                rc = vbgdIoCtl_WaitEvent(pDevExt, pSession, (VBoxGuestWaitEventInfo *)pvData,
-                                                    pcbDataReturned, pSession->R0Process != NIL_RTR0PROCESS);
+                rc = vgdrvIoCtl_WaitEvent(pDevExt, pSession, (VBoxGuestWaitEventInfo *)pvData,
+                                          pcbDataReturned, pSession->R0Process != NIL_RTR0PROCESS);
                 break;
 
             case VBOXGUEST_IOCTL_CANCEL_ALL_WAITEVENTS:
                 CHECKRET_SIZE("CANCEL_ALL_WAITEVENTS", 0);
-                rc = vbgdIoCtl_CancelAllWaitEvents(pDevExt, pSession);
+                rc = vgdrvIoCtl_CancelAllWaitEvents(pDevExt, pSession);
                 break;
 
             case VBOXGUEST_IOCTL_CTL_FILTER_MASK:
                 CHECKRET_MIN_SIZE("CTL_FILTER_MASK", sizeof(VBoxGuestFilterMaskInfo));
-                rc = vbgdIoCtl_CtlFilterMask(pDevExt, pSession, (VBoxGuestFilterMaskInfo *)pvData);
+                rc = vgdrvIoCtl_CtlFilterMask(pDevExt, pSession, (VBoxGuestFilterMaskInfo *)pvData);
                 break;
 
@@ -3489,5 +3511,5 @@
 # endif
                 CHECKRET_MIN_SIZE("HGCM_CONNECT", sizeof(VBoxGuestHGCMConnectInfo));
-                rc = vbgdIoCtl_HGCMConnect(pDevExt, pSession, (VBoxGuestHGCMConnectInfo *)pvData, pcbDataReturned);
+                rc = vgdrvIoCtl_HGCMConnect(pDevExt, pSession, (VBoxGuestHGCMConnectInfo *)pvData, pcbDataReturned);
                 break;
 
@@ -3497,5 +3519,5 @@
 # endif
                 CHECKRET_MIN_SIZE("HGCM_DISCONNECT", sizeof(VBoxGuestHGCMDisconnectInfo));
-                rc = vbgdIoCtl_HGCMDisconnect(pDevExt, pSession, (VBoxGuestHGCMDisconnectInfo *)pvData, pcbDataReturned);
+                rc = vgdrvIoCtl_HGCMDisconnect(pDevExt, pSession, (VBoxGuestHGCMDisconnectInfo *)pvData, pcbDataReturned);
                 break;
 #endif /* VBOX_WITH_HGCM */
@@ -3503,20 +3525,20 @@
             case VBOXGUEST_IOCTL_CHECK_BALLOON:
                 CHECKRET_MIN_SIZE("CHECK_MEMORY_BALLOON", sizeof(VBoxGuestCheckBalloonInfo));
-                rc = vbgdIoCtl_CheckMemoryBalloon(pDevExt, pSession, (VBoxGuestCheckBalloonInfo *)pvData, pcbDataReturned);
+                rc = vgdrvIoCtl_CheckMemoryBalloon(pDevExt, pSession, (VBoxGuestCheckBalloonInfo *)pvData, pcbDataReturned);
                 break;
 
             case VBOXGUEST_IOCTL_CHANGE_BALLOON:
                 CHECKRET_MIN_SIZE("CHANGE_MEMORY_BALLOON", sizeof(VBoxGuestChangeBalloonInfo));
-                rc = vbgdIoCtl_ChangeMemoryBalloon(pDevExt, pSession, (VBoxGuestChangeBalloonInfo *)pvData, pcbDataReturned);
+                rc = vgdrvIoCtl_ChangeMemoryBalloon(pDevExt, pSession, (VBoxGuestChangeBalloonInfo *)pvData, pcbDataReturned);
                 break;
 
             case VBOXGUEST_IOCTL_WRITE_CORE_DUMP:
                 CHECKRET_MIN_SIZE("WRITE_CORE_DUMP", sizeof(VBoxGuestWriteCoreDump));
-                rc = vbgdIoCtl_WriteCoreDump(pDevExt, (VBoxGuestWriteCoreDump *)pvData);
+                rc = vgdrvIoCtl_WriteCoreDump(pDevExt, (VBoxGuestWriteCoreDump *)pvData);
                 break;
 
             case VBOXGUEST_IOCTL_SET_MOUSE_STATUS:
                 CHECKRET_SIZE("SET_MOUSE_STATUS", sizeof(uint32_t));
-                rc = vbgdIoCtl_SetMouseStatus(pDevExt, pSession, *(uint32_t *)pvData);
+                rc = vgdrvIoCtl_SetMouseStatus(pDevExt, pSession, *(uint32_t *)pvData);
                 break;
 
@@ -3524,5 +3546,5 @@
             case VBOXGUEST_IOCTL_DPC_LATENCY_CHECKER:
                 CHECKRET_SIZE("DPC_LATENCY_CHECKER", 0);
-                rc = VbgdNtIOCtl_DpcLatencyChecker();
+                rc = VGDrvNtIOCtl_DpcLatencyChecker();
                 break;
 #endif
@@ -3530,5 +3552,5 @@
             case VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE:
                 CHECKRET_SIZE("GUEST_CAPS_ACQUIRE", sizeof(VBoxGuestCapsAquire));
-                rc = vbgdIoCtl_GuestCapsAcquire(pDevExt, pSession, (VBoxGuestCapsAquire *)pvData);
+                rc = vgdrvIoCtl_GuestCapsAcquire(pDevExt, pSession, (VBoxGuestCapsAquire *)pvData);
                 *pcbDataReturned = sizeof(VBoxGuestCapsAquire);
                 break;
@@ -3536,10 +3558,10 @@
             case VBOXGUEST_IOCTL_SET_GUEST_CAPABILITIES:
                 CHECKRET_MIN_SIZE("SET_GUEST_CAPABILITIES", sizeof(VBoxGuestSetCapabilitiesInfo));
-                rc = vbgdIoCtl_SetCapabilities(pDevExt, pSession, (VBoxGuestSetCapabilitiesInfo *)pvData);
+                rc = vgdrvIoCtl_SetCapabilities(pDevExt, pSession, (VBoxGuestSetCapabilitiesInfo *)pvData);
                 break;
 
             default:
             {
-                LogRel(("VbgdCommonIoCtl: Unknown request iFunction=%#x stripped size=%#x\n",
+                LogRel(("VGDrvCommonIoCtl: Unknown request iFunction=%#x stripped size=%#x\n",
                         iFunction, VBOXGUEST_IOCTL_STRIP_SIZE(iFunction)));
                 rc = VERR_NOT_SUPPORTED;
@@ -3549,5 +3571,5 @@
     }
 
-    LogFlow(("VbgdCommonIoCtl: returns %Rrc *pcbDataReturned=%zu\n", rc, pcbDataReturned ? *pcbDataReturned : 0));
+    LogFlow(("VGDrvCommonIoCtl: returns %Rrc *pcbDataReturned=%zu\n", rc, pcbDataReturned ? *pcbDataReturned : 0));
     return rc;
 }
@@ -3555,5 +3577,5 @@
 
 /**
- * Used by VbgdCommonISR as well as the acquire guest capability code.
+ * Used by VGDrvCommonISR as well as the acquire guest capability code.
  *
  * @returns VINF_SUCCESS on success. On failure, ORed together
@@ -3562,5 +3584,5 @@
  * @param   fEvents             The events to dispatch.
  */
-static int vbgdDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents)
+static int vgdrvDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents)
 {
     PVBOXGUESTWAIT  pWait;
@@ -3579,5 +3601,5 @@
                check first, then deal with VBOXGUEST_ACQUIRE_STYLE_EVENTS as applicable. */
             if (fHandledEvents & VBOXGUEST_ACQUIRE_STYLE_EVENTS)
-                fHandledEvents &= vbgdGetAllowedEventMaskForSession(pDevExt, pWait->pSession);
+                fHandledEvents &= vgdrvGetAllowedEventMaskForSession(pDevExt, pWait->pSession);
             if (fHandledEvents)
             {
@@ -3610,5 +3632,5 @@
  * @param   pDevExt     The VBoxGuest device extension.
  */
-bool VbgdCommonISR(PVBOXGUESTDEVEXT pDevExt)
+bool VGDrvCommonISR(PVBOXGUESTDEVEXT pDevExt)
 {
     VMMDevEvents volatile  *pReq                  = pDevExt->pIrqAckEvents;
@@ -3643,5 +3665,5 @@
             uint32_t        fEvents = pReq->events;
 
-            Log3(("VbgdCommonISR: acknowledge events succeeded %#RX32\n", fEvents));
+            Log3(("VGDrvCommonISR: acknowledge events succeeded %#RX32\n", fEvents));
 
             /*
@@ -3687,12 +3709,12 @@
              * Normal FIFO waiter evaluation.
              */
-            rc |= vbgdDispatchEventsLocked(pDevExt, fEvents);
+            rc |= vgdrvDispatchEventsLocked(pDevExt, fEvents);
         }
         else /* something is serious wrong... */
-            Log(("VbgdCommonISR: acknowledge events failed rc=%Rrc (events=%#x)!!\n",
+            Log(("VGDrvCommonISR: acknowledge events failed rc=%Rrc (events=%#x)!!\n",
                  pReq->header.rc, pReq->events));
     }
     else
-        Log3(("VbgdCommonISR: not ours\n"));
+        Log3(("VGDrvCommonISR: not ours\n"));
 
     RTSpinlockRelease(pDevExt->EventSpinlock);
@@ -3704,5 +3726,5 @@
      *       care of it.  Same on darwin, doing it in the work loop callback.
      */
-    VbgdCommonWaitDoWakeUps(pDevExt);
+    VGDrvCommonWaitDoWakeUps(pDevExt);
 #endif
 
@@ -3714,5 +3736,5 @@
     {
         ASMAtomicIncU32(&pDevExt->u32MousePosChangedSeq);
-        VbgdNativeISRMousePollEvent(pDevExt);
+        VGDrvNativeISRMousePollEvent(pDevExt);
     }
 
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestIDC-unix.c.h
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestIDC-unix.c.h	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestIDC-unix.c.h	(revision 58053)
@@ -69,5 +69,5 @@
 #endif
 
-    rc = VbgdCommonCreateKernelSession(&g_DevExt, &pSession);
+    rc = VGDrvCommonCreateKernelSession(&g_DevExt, &pSession);
     if (RT_SUCCESS(rc))
     {
@@ -106,5 +106,5 @@
 
     AssertPtrReturn(pSession, VERR_INVALID_POINTER);
-    VbgdCommonCloseSession(&g_DevExt, pSession);
+    VGDrvCommonCloseSession(&g_DevExt, pSession);
 
 #ifdef RT_OS_SOLARIS
@@ -144,5 +144,5 @@
                     ("SC: %p != %p\n", pSession->pDevExt, &g_DevExt), VERR_INVALID_HANDLE);
 
-    return VbgdCommonIoCtl(iCmd, &g_DevExt, pSession, pvData, cbData, pcbDataReturned);
+    return VGDrvCommonIoCtl(iCmd, &g_DevExt, pSession, pvData, cbData, pcbDataReturned);
 }
 
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h	(revision 58052)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h	(revision 58053)
@@ -314,20 +314,20 @@
 RT_C_DECLS_BEGIN
 
-int  VbgdCommonInitDevExt(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase, void *pvMMIOBase, uint32_t cbMMIO,
-                          VBOXOSTYPE enmOSType, uint32_t fEvents);
-bool VbgdCommonISR(PVBOXGUESTDEVEXT pDevExt);
-void VbgdCommonDeleteDevExt(PVBOXGUESTDEVEXT pDevExt);
-int  VbgdCommonReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType);
+int  VGDrvCommonInitDevExt(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase, void *pvMMIOBase, uint32_t cbMMIO,
+                           VBOXOSTYPE enmOSType, uint32_t fEvents);
+bool VGDrvCommonISR(PVBOXGUESTDEVEXT pDevExt);
+void VGDrvCommonDeleteDevExt(PVBOXGUESTDEVEXT pDevExt);
+int  VGDrvCommonReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType);
 #ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
-void VbgdCommonWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt);
-#endif
-
-int  VbgdCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
-int  VbgdCommonCreateKernelSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
-void VbgdCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
-
-int  VbgdCommonIoCtlFast(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
-int  VbgdCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
-                     void *pvData, size_t cbData, size_t *pcbDataReturned);
+void VGDrvCommonWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt);
+#endif
+
+int  VGDrvCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
+int  VGDrvCommonCreateKernelSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
+void VGDrvCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
+
+int  VGDrvCommonIoCtlFast(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
+int  VGDrvCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
+                      void *pvData, size_t cbData, size_t *pcbDataReturned);
 
 /**
@@ -339,9 +339,9 @@
  * @param   pDevExt     The device extension.
  */
-void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt);
+void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt);
 
 
 #ifdef VBOX_WITH_DPC_LATENCY_CHECKER
-int VbgdNtIOCtl_DpcLatencyChecker(void);
+int VGDrvNtIOCtl_DpcLatencyChecker(void);
 #endif
 
