Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk	(revision 38356)
@@ -38,5 +38,5 @@
 endif
 VBoxUSB_SDKS        = W2K3DDK WINPSDKINCS
-VBoxUSB_DEFS        = IN_RT_R0 IN_SUP_R0
+VBoxUSB_DEFS        = IN_RT_R0 IN_SUP_R0 VBOX_DBG_LOG_NAME=\"USBDev\"
 VBoxUSB_LDFLAGS.x86 = -Entry:DriverEntry@8
 VBoxUSB_LDFLAGS.amd64 = -Entry:DriverEntry
@@ -66,5 +66,5 @@
 VBoxUSBMon_DEFS        = IN_RT_R0 IN_SUP_R0 i386=1 STD_CALL CONDITION_HANDLING=1 NT_INST=0 \
 	WIN32=100 _NT1X_=100 WINNT=1 _WIN32_WINNT=0x0501 WINVER=0x0501 _WIN32_IE=0x0600 WIN32_LEAN_AND_MEAN=1 \
-	VBOXUSBFILTERMGR_USB_SPINLOCK
+	VBOXUSBFILTERMGR_USB_SPINLOCK VBOX_DBG_LOG_NAME=\"USBMon\"
 VBoxUSBMon_LDFLAGS.x86 = -Entry:DriverEntry@8
 VBoxUSBMon_LDFLAGS.amd64 = -Entry:DriverEntry
@@ -86,5 +86,7 @@
 	$(PATH_STAGE_LIB)/RuntimeR0Drv$(VBOX_SUFF_LIB) \
 	$(usbd_1_TARGET)
-#VBoxUSBMon_DEFS      += LOG_ENABLED
+if1of ($(KBUILD_TYPE), debug)
+VBoxUSBMon_DEFS      += LOG_ENABLED VBOX_USB_WITH_VERBOSE_LOGGING
+endif
 
 #
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp	(revision 38356)
@@ -19,4 +19,7 @@
 
 #include <iprt/assert.h>
+#include <VBox/log.h>
+
+#include "../../../win/VBoxDbgLog.h"
 
 #define VBOXDRVTOOL_MEMTAG 'TDBV'
@@ -137,4 +140,6 @@
 {
     KEVENT Event;
+    LOG(("post irp (0x%p) to DevObj(0x%p) with timeout (%u)", pIrp, pDevObj, dwTimeoutMs));
+
     KeInitializeEvent(&Event, NotificationEvent, FALSE);
     NTSTATUS Status = VBoxDrvToolIoPostAsync(pDevObj, pIrp, &Event);
@@ -152,12 +157,9 @@
         if (Status == STATUS_TIMEOUT)
         {
-#ifdef DEBUG_misha
-            /* debugging only */
-            AssertFailed();
-#endif
+            WARN(("irp (0x%p) to DevObj(0x%p) was not completed within timeout (%u), cancelling", pIrp, pDevObj, dwTimeoutMs));
             if (!IoCancelIrp(pIrp))
             {
                 /* this may happen, but this is something the caller with timeout is not expecting */
-                AssertFailed();
+                WARN(("IoCancelIrp failed"));
             }
 
@@ -167,9 +169,14 @@
         else
         {
-            Assert(Status == STATUS_SUCCESS);
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("uunexpected Status (0x%x)", Status));
         }
 
         /* by this time the IRP is completed */
         Status = pIrp->IoStatus.Status;
+        LOG(("Pending IRP(0x%p) completed with status(0x%x)", pIrp, Status));
+    }
+    else
+    {
+        LOG(("IRP(0x%p) completed with status(0x%x)", pIrp, Status));
     }
     return Status;
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp	(revision 38356)
@@ -22,4 +22,6 @@
 #include <VBox/log.h>
 
+#include "../../../win/VBoxDbgLog.h"
+
 #define VBOXUSBTOOL_MEMTAG 'TUBV'
 
@@ -97,7 +99,7 @@
     USHORT cbUrb = sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST);
     PURB pUrb = VBoxUsbToolUrbAllocZ(URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE, cbUrb);
-    Assert(pUrb);
     if(!pUrb)
     {
+        WARN(("allocating URB failed"));
         return STATUS_INSUFFICIENT_RESOURCES;
     }
@@ -116,7 +118,5 @@
 
     Status = VBoxUsbToolUrbPost(pDevObj, pUrb, dwTimeoutMs);
-#ifdef DEBUG_misha
-    Assert(Status == STATUS_SUCCESS);
-#endif
+    ASSERT_WARN(Status == STATUS_SUCCESS, ("VBoxUsbToolUrbPost failed Status (0x%x)", Status));
 
     VBoxUsbToolUrbFree(pUrb);
@@ -349,4 +349,5 @@
     if (!pIrp)
     {
+        WARN(("VBoxUsbToolIoBuildAsyncInternalCtl failed"));
         return STATUS_INSUFFICIENT_RESOURCES;
     }
@@ -371,5 +372,5 @@
     if (!pIrp)
     {
-        AssertMsgFailed(("IoBuildDeviceIoControlRequest failed!!\n"));
+        WARN(("IoBuildDeviceIoControlRequest failed!!\n"));
         pIoStatus->Status = STATUS_INSUFFICIENT_RESOURCES;
         pIoStatus->Information = 0;
@@ -395,12 +396,20 @@
     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
+    LOG(("Sending sync Ctl pDevObj(0x%p), uCtl(0x%x), pvArg1(0x%p), pvArg2(0x%p)", pDevObj, uCtl, pvArg1, pvArg2));
+
     Status = VBoxUsbToolIoInternalCtlSendAsync(pDevObj, uCtl, pvArg1, pvArg2, &Event, &IoStatus);
 
     if (Status == STATUS_PENDING)
     {
+        LOG(("VBoxUsbToolIoInternalCtlSendAsync returned pending for pDevObj(0x%x)", pDevObj));
         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
         Status = IoStatus.Status;
-    }
-
-    return Status;
-}
+        LOG(("Pending VBoxUsbToolIoInternalCtlSendAsync completed with Status (0x%x) for pDevObj(0x%x)", Status, pDevObj));
+    }
+    else
+    {
+        LOG(("VBoxUsbToolIoInternalCtlSendAsync completed with Status (0x%x) for pDevObj(0x%x)", Status, pDevObj));
+    }
+
+    return Status;
+}
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp	(revision 38356)
@@ -286,5 +286,5 @@
 static PVBOXUSBFLT_DEVICE vboxUsbFltDevGetLocked(PDEVICE_OBJECT pPdo)
 {
-#ifdef DEBUG_misha
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
     for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink;
             pEntry != &g_VBoxUsbFltGlobals.DeviceList;
@@ -297,7 +297,7 @@
         {
             PVBOXUSBFLT_DEVICE pDevice2 = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry2);
-            Assert(    pDevice->idVendor  != pDevice2->idVendor
+            ASSERT_WARN(    pDevice->idVendor  != pDevice2->idVendor
                     || pDevice->idProduct != pDevice2->idProduct
-                    || pDevice->bcdDevice != pDevice2->bcdDevice);
+                    || pDevice->bcdDevice != pDevice2->bcdDevice, ("duplicate devices in a list!!"));
         }
     }
@@ -308,9 +308,10 @@
     {
         PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry);
-        Assert(    pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
+        ASSERT_WARN(    pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
                 || pDevice->enmState == VBOXUSBFLT_DEVSTATE_UNCAPTURED
                 || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURING
                 || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURED
-                || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST);
+                || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST,
+                ("Invalid device state(%d) for device(0x%p) PDO(0x%p)", pDevice->enmState, pDevice, pDevice->Pdo));
         if (pDevice->Pdo == pPdo)
             return pDevice;
@@ -328,7 +329,9 @@
     {
         vboxUsbFltDevRetain(pDevice);
+        LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
     }
     else
     {
+        LOG(("found replugging device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
         pDevice = NULL;
     }
@@ -340,6 +343,8 @@
 static NTSTATUS vboxUsbFltPdoReplug(PDEVICE_OBJECT pDo)
 {
+    LOG(("Replugging PDO(0x%p)", pDo));
     NTSTATUS Status = VBoxUsbToolIoInternalCtlSendSync(pDo, IOCTL_INTERNAL_USB_CYCLE_PORT, NULL, NULL);
-    Assert(Status == STATUS_SUCCESS);
+    ASSERT_WARN(Status == STATUS_SUCCESS, ("replugging PDO(0x%p) failed Status(0x%x)", pDo, Status));
+    LOG(("Replugging PDO(0x%p) done with Status(0x%x)", pDo, Status));
     return Status;
 }
@@ -393,8 +398,10 @@
     pDevice->Pdo = pDo;
 
+    LOG(("Populating Device(0x%p) for PDO(0x%p)", pDevice, pDo));
+
     pDevDr = (PUSB_DEVICE_DESCRIPTOR)VBoxUsbMonMemAllocZ(sizeof(*pDevDr));
     if (pDevDr == NULL)
     {
-        AssertMsgFailed(("Failed to alloc mem for urb\n"));
+        WARN(("Failed to alloc mem for urb\n"));
         return STATUS_INSUFFICIENT_RESOURCES;
     }
@@ -405,5 +412,5 @@
         if (!NT_SUCCESS(Status))
         {
-            LOGREL((__FUNCTION__": getting device descriptor failed\n"));
+            WARN(("getting device descriptor failed, Status (0x%x)\n", Status));
             break;
         }
@@ -411,8 +418,5 @@
         if (vboxUsbFltBlDevMatchLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice))
         {
-            LOGREL((__FUNCTION__": found a known black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
-#ifdef DEBUG_misha
-            AssertFailed();
-#endif
+            WARN(("found a known black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
             Status = STATUS_UNSUCCESSFUL;
             break;
@@ -438,8 +442,8 @@
             if (!NT_SUCCESS(Status))
             {
-                AssertMsgFailed((__FUNCTION__": reading language ID failed\n"));
+                WARN(("reading language ID failed\n"));
                 if (Status == STATUS_CANCELLED)
                 {
-                    AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
+                    WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
                     vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
                     Status = STATUS_UNSUCCESSFUL;
@@ -453,8 +457,8 @@
                 if (!NT_SUCCESS(Status))
                 {
-                    AssertMsgFailed((__FUNCTION__": reading serial number failed\n"));
+                    WARN(("reading serial number failed\n"));
                     if (Status == STATUS_CANCELLED)
                     {
-                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
+                        WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
                         vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
                         Status = STATUS_UNSUCCESSFUL;
@@ -469,8 +473,8 @@
                 if (!NT_SUCCESS(Status))
                 {
-                    AssertMsgFailed((__FUNCTION__": reading manufacturer name failed\n"));
+                    WARN(("reading manufacturer name failed\n"));
                     if (Status == STATUS_CANCELLED)
                     {
-                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
+                        WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
                         vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
                         Status = STATUS_UNSUCCESSFUL;
@@ -485,8 +489,8 @@
                 if (!NT_SUCCESS(Status))
                 {
-                    AssertMsgFailed((__FUNCTION__": reading product name failed\n"));
+                    WARN(("reading product name failed\n"));
                     if (Status == STATUS_CANCELLED)
                     {
-                        AssertMsgFailed((__FUNCTION__": found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
+                        WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)\n", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice));
                         vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice);
                         Status = STATUS_UNSUCCESSFUL;
@@ -535,12 +539,14 @@
             }
 #endif
-            LOG((__FUNCTION__": strings: '%s':'%s':'%s' (lang ID %x)\n",
+            LOG((": strings: '%s':'%s':'%s' (lang ID %x)\n",
                         pDevice->szMfgName, pDevice->szProduct, pDevice->szSerial, langId));
         }
 
+        LOG(("Populating Device(0x%p) for PDO(0x%p) Succeeded", pDevice, pDo));
         Status = STATUS_SUCCESS;
     } while (0);
 
     VBoxUsbMonMemFree(pDevDr);
+    LOG(("Populating Device(0x%p) for PDO(0x%p) Done, Status (0x%x)", pDevice, pDo, Status));
     return Status;
 }
@@ -566,11 +572,16 @@
 static bool vboxUsbFltDevCheckReplugLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext)
 {
-    Assert(pContext);
+    ASSERT_WARN(pContext, ("context is NULL!"));
+
+    LOG(("Current context is (0x%p)", pContext));
+    LOG(("Current Device owner is (0x%p)", pDevice->pOwner));
 
     /* check if device is already replugging */
     if (pDevice->enmState <= VBOXUSBFLT_DEVSTATE_ADDED)
     {
+        LOG(("Device (0x%p) is already replugging, return..", pDevice));
         /* it is, do nothing */
-        Assert(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING);
+        ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING,
+                ("Device (0x%p) state is NOT REPLUGGING (%d)", pDevice, pDevice->enmState));
         return false;
     }
@@ -578,4 +589,5 @@
     if (pDevice->pOwner && pContext != pDevice->pOwner)
     {
+        LOG(("Device (0x%p) is owned by another context(0x%p), current is(0x%p)", pDevice, pDevice->pOwner, pContext));
         /* this device is owned by another context, we're not allowed to do anything */
         return false;
@@ -589,6 +601,8 @@
             false, /* do not remove a one-shot filter */
             &fFilter, &fIsOneShot);
+    LOG(("Matching Info: Filter (0x%p), NewOwner(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pNewOwner, (int)fFilter, (int)fIsOneShot));
     if (pDevice->pOwner && pNewOwner && pDevice->pOwner != pNewOwner)
     {
+        LOG(("Matching: Device (0x%p) is requested another owner(0x%p), current is(0x%p)", pDevice, pNewOwner, pDevice->pOwner));
         /* the device is owned by another owner, we can not change the owner here */
         return false;
@@ -597,22 +611,31 @@
     if (!fFilter)
     {
+        LOG(("Matching: Device (0x%p) should NOT be filtered", pDevice));
         /* the device should NOT be filtered, check the current state  */
         if (vboxUsbFltDevStateIsNotFiltered(pDevice))
         {
+            LOG(("Device (0x%p) is NOT filtered", pDevice));
             /* no changes */
             if (fIsOneShot)
             {
-                Assert(pNewOwner);
+                ASSERT_WARN(pNewOwner, ("no new owner"));
+                LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId));
                 /* remove a one-shot filter and keep the original filter data */
                 int tmpRc = VBoxUSBFilterRemove(pNewOwner, uId);
-                AssertRC(tmpRc);
+                ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc));
                 if (!pDevice->pOwner)
                 {
+                    LOG(("Matching: updating the one-shot owner to (0x%p), fltId(0x%p)", pNewOwner, uId));
                     /* update owner for one-shot if the owner is changed (i.e. assigned) */
                     vboxUsbFltDevOwnerUpdateLocked(pDevice, pNewOwner, uId, true);
+                }
+                else
+                {
+                    LOG(("Matching: device already has owner (0x%p) assigned", pDevice->pOwner));
                 }
             }
             else
             {
+                LOG(("Matching: This is NOT a one-shot filter (0x%p), newOwner(0x%p)", uId, pNewOwner));
                 if (pNewOwner)
                 {
@@ -623,4 +646,5 @@
         else
         {
+            LOG(("Device (0x%p) IS filtered", pDevice));
             /* the device is currently filtered, we should release it only if
              * 1. device does not have an owner
@@ -631,4 +655,5 @@
             if (!pDevice->pOwner || fIsOneShot || !pDevice->fIsFilterOneShot)
             {
+                LOG(("Matching: Need replug"));
                 bNeedReplug = true;
             }
@@ -637,21 +662,26 @@
     else
     {
+        LOG(("Matching: Device (0x%p) SHOULD be filtered", pDevice));
         /* the device should be filtered, check the current state  */
-        Assert(uId);
-        Assert(pNewOwner);
+        ASSERT_WARN(uId, ("zero uid"));
+        ASSERT_WARN(pNewOwner, ("zero pNewOwner"));
         if (vboxUsbFltDevStateIsFiltered(pDevice))
         {
+            LOG(("Device (0x%p) IS filtered", pDevice));
             /* the device is filtered */
             if (pNewOwner == pDevice->pOwner)
             {
+                LOG(("Device owner match"));
                 /* no changes */
                 if (fIsOneShot)
                 {
+                    LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId));
                     /* remove a one-shot filter and keep the original filter data */
                     int tmpRc = VBoxUSBFilterRemove(pNewOwner, uId);
-                    AssertRC(tmpRc);
+                    ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc));
                 }
                 else
                 {
+                    LOG(("Matching: This is NOT a one-shot filter (0x%p), Owner(0x%p)", uId, pDevice->pOwner));
                     vboxUsbFltDevOwnerUpdateLocked(pDevice, pDevice->pOwner, uId, false);
                 }
@@ -659,5 +689,6 @@
             else
             {
-                Assert(!pDevice->pOwner);
+                ASSERT_WARN(!pDevice->pOwner, ("device should NOT have owner"));
+                LOG(("Matching: Need replug"));
                 /* the device needs to be filtered, but the owner changes, replug needed */
                 bNeedReplug = true;
@@ -676,4 +707,5 @@
             {
                 bNeedReplug = true;
+                LOG(("Matching: Need replug"));
             }
         }
@@ -682,5 +714,10 @@
     if (bNeedReplug)
     {
+        LOG(("Matching: Device needs replugging, marking as such"));
         vboxUsbFltDevStateMarkReplugLocked(pDevice);
+    }
+    else
+    {
+        LOG(("Matching: Device does NOT need replugging"));
     }
 
@@ -697,6 +734,8 @@
         pNext = pEntry->Flink;
         PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_REPLUGGINGLE(pEntry);
-        Assert(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
-                || pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED);
+        LOG(("replugging matched PDO(0x%p), pDevice(0x%p)", pDevice->Pdo, pDevice));
+        ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING
+                || pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED,
+                ("invalid state(0x%x) for device(0x%p)", pDevice->enmState, pDevice));
 
         vboxUsbFltPdoReplug(pDevice->Pdo);
@@ -713,5 +752,5 @@
     Assert(Irql == PASSIVE_LEVEL);
 
-    LOG(("==" __FUNCTION__"\n"));
+    LOG(("Running filters, Context (0x%p)..", pContext));
 
     for (int i=0;i<RT_ELEMENTS(lpszStandardControllerName);i++)
@@ -758,9 +797,7 @@
                         PDEVICE_RELATIONS pDevRelations = NULL;
 
-#ifdef DEBUG
-                        LOG(("Associated driver "));
-                        vboxUsbDbgPrintUnicodeString(&pHubDevObj->DriverObject->DriverName);
-                        LOG((" -> related dev obj=0x%p\n", IoGetRelatedDeviceObject(pHubFileObj)));
-#endif
+                        LOG(("Flt Associated driver "));
+                        LOG_USTR(&pHubDevObj->DriverObject->DriverName);
+                        LOG((" -> related dev obj=0x%p", pHubDevObj));
 
                         Status = VBoxUsbMonQueryBusRelations(pHubDevObj, pHubFileObj, &pDevRelations);
@@ -774,12 +811,14 @@
                                 PDEVICE_OBJECT pDevObj = pDevRelations->Objects[k];
 
-                                LOG(("Found existing USB PDO 0x%p\n", pDevObj));
+                                LOG(("Found existing USB PDO 0x%p", pDevObj));
                                 VBOXUSBFLT_LOCK_ACQUIRE();
                                 PVBOXUSBFLT_DEVICE pDevice = vboxUsbFltDevGetLocked(pDevObj);
                                 if (pDevice)
                                 {
+                                    LOG(("Found existing device info (0x%p) for PDO 0x%p", pDevice, pDevObj));
                                     bool bReplug = vboxUsbFltDevCheckReplugLocked(pDevice, pContext);
                                     if (bReplug)
                                     {
+                                        LOG(("Replug needed for device (0x%p)", pDevice));
                                         InsertHeadList(&ReplugDevList, &pDevice->RepluggingLe);
                                         vboxUsbFltDevRetain(pDevice);
@@ -788,4 +827,5 @@
                                     else
                                     {
+                                        LOG(("Replug NOT needed for device (0x%p)", pDevice));
                                         ObDereferenceObject(pDevObj);
                                     }
@@ -795,9 +835,10 @@
                                     pDevRelations->Objects[k] = NULL;
                                     --cReplugPdos;
-                                    Assert((uint32_t)cReplugPdos < UINT32_MAX/2);
+                                    ASSERT_WARN((uint32_t)cReplugPdos < UINT32_MAX/2, ("cReplugPdos(%d) state broken", cReplugPdos));
                                     continue;
                                 }
                                 VBOXUSBFLT_LOCK_RELEASE();
 
+                                LOG(("NO device info found for PDO 0x%p", pDevObj));
                                 VBOXUSBFLT_DEVICE Device;
                                 Status = vboxUsbFltDevPopulate(&Device, pDevObj /*, FALSE /* only need filter properties */);
@@ -812,6 +853,8 @@
                                             &fFilter, &fIsOneShot);
                                     VBOXUSBFLT_LOCK_RELEASE();
+                                    LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot));
                                     if (!fFilter)
                                     {
+                                        LOG(("Matching: This device should NOT be filtered"));
                                         /* this device should not be filtered, and it's not */
                                         ObDereferenceObject(pDevObj);
@@ -822,4 +865,5 @@
                                     }
 
+                                    LOG(("Matching: This device SHOULD be filtered"));
                                     /* this device needs to be filtered, but it's not,
                                      * leave the PDO in array to issue a replug request for it
@@ -827,5 +871,11 @@
 
                                 }
+                                else
+                                {
+                                    WARN(("vboxUsbFltDevPopulate for PDO 0x%p failed with Status 0x%x", pDevObj, Status));
+                                }
                             }
+
+                            LOG(("(%d) non-matched PDOs to be replugged", cReplugPdos));
 
                             if (cReplugPdos)
@@ -837,5 +887,5 @@
 
                                     Status = vboxUsbFltPdoReplug(pDevRelations->Objects[k]);
-                                    Assert(Status == STATUS_SUCCESS);
+                                    ASSERT_WARN(Status == STATUS_SUCCESS, ("vboxUsbFltPdoReplug ailed Status(0x%x)", Status));
                                     ObDereferenceObject(pDevRelations->Objects[k]);
                                     if (!--cReplugPdos)
@@ -843,5 +893,5 @@
                                 }
 
-                                Assert(!cReplugPdos);
+                                ASSERT_WARN(!cReplugPdos, ("cReplugPdosreached zero!"));
                             }
 
@@ -849,4 +899,9 @@
 
                             ExFreePool(pDevRelations);
+                        }
+                        else
+                        {
+                            WARN(("VBoxUsbMonQueryBusRelations failed for DO(0x%p), Status(0x%x), pDevRelations(0x%p)",
+                                    pHubDevObj, Status, pDevRelations));
                         }
                     }
@@ -856,4 +911,6 @@
         }
     }
+
+    LOG(("DONE Running filters, Context (0x%p)", pContext));
 
     return STATUS_SUCCESS;
@@ -936,6 +993,6 @@
         USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR)       ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR)       : "<null>",
         USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>"));
-#ifdef DEBUG
-    LOG(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
+    LOG(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x Type%#x\n",
               USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID),
               USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID),
@@ -945,5 +1002,6 @@
               USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL),
               USBFilterGetNum(pFilter, USBFILTERIDX_BUS),
-              USBFilterGetNum(pFilter, USBFILTERIDX_PORT)));
+              USBFilterGetNum(pFilter, USBFILTERIDX_PORT),
+              USBFilterGetFilterType(pFilter)));
 #endif
 
@@ -957,8 +1015,8 @@
     int rc = VBoxUSBFilterAdd(pFilter, pContext, &uId);
     VBOXUSBFLT_LOCK_RELEASE();
-    AssertRC(rc);
     if (RT_SUCCESS(rc))
     {
-        Assert(uId);
+        LOG(("ADDED filer id 0x%p", uId));
+        ASSERT_WARN(uId, ("uid is NULL"));
 #ifdef VBOX_USBMON_WITH_FILTER_AUTOAPPLY
         VBoxUsbFltFilterCheck();
@@ -967,5 +1025,6 @@
     else
     {
-        Assert(!uId);
+        WARN(("VBoxUSBFilterAdd failed rc (%d)", rc));
+        ASSERT_WARN(!uId, ("uid is not NULL"));
     }
 
@@ -982,5 +1041,5 @@
     if (!RT_SUCCESS(rc))
     {
-        AssertFailed();
+        WARN(("VBoxUSBFilterRemove failed rc (%d)", rc));
         VBOXUSBFLT_LOCK_RELEASE();
         return rc;
@@ -994,5 +1053,5 @@
         if (pDevice->fIsFilterOneShot)
         {
-            Assert(!pDevice->uFltId);
+            ASSERT_WARN(!pDevice->uFltId, ("oneshot filter on device(0x%p): unexpected uFltId(%d)", pDevice, pDevice->uFltId));
         }
 
@@ -1000,9 +1059,9 @@
             continue;
 
-        Assert(pDevice->pOwner == pContext);
+        ASSERT_WARN(pDevice->pOwner == pContext, ("Device(0x%p) owner(0x%p) not match to (0x%p)", pDevice, pDevice->pOwner, pContext));
         if (pDevice->pOwner != pContext)
             continue;
 
-        Assert(!pDevice->fIsFilterOneShot);
+        ASSERT_WARN(!pDevice->fIsFilterOneShot, ("device(0x%p) is filtered with a oneshot filter", pDevice));
         pDevice->uFltId = 0;
         /* clear the fIsFilterOneShot flag to ensure the device is replugged on the next VBoxUsbFltFilterCheck call */
@@ -1058,7 +1117,6 @@
     if (pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING)
     {
-        Assert(!pDevice->pOwner);
-        Assert(!pDevice->uFltId);
-        AssertFailed();
+        ASSERT_WARN(!pDevice->pOwner, ("replugging device(0x%p) still has an owner(0x%p)", pDevice, pDevice->pOwner));
+        ASSERT_WARN(!pDevice->uFltId, ("replugging device(0x%p) still has filter(0x%p)", pDevice, pDevice->uFltId));
         /* no user state for this, we should not return it tu the user */
         return USBDEVICESTATE_USED_BY_HOST;
@@ -1066,10 +1124,13 @@
 
     /* the device is filtered, if owner differs from the context, return as USED_BY_HOST */
-    Assert(pDevice->pOwner);
+    ASSERT_WARN(pDevice->pOwner, ("device(0x%p) has noowner", pDevice));
     /* the id can be null if a filter is removed */
 //    Assert(pDevice->uFltId);
 
     if (pDevice->pOwner != pContext)
+    {
+        LOG(("Device owner differs from the current context, returning used by host"));
         return USBDEVICESTATE_USED_BY_HOST;
+    }
 
     switch (pDevice->enmState)
@@ -1083,5 +1144,5 @@
             return USBDEVICESTATE_USED_BY_GUEST;
         default:
-            AssertFailed();
+            WARN(("unexpected device state(%d) for device(0x%p)", pDevice->enmState, pDevice));
             return USBDEVICESTATE_UNSUPPORTED;
     }
@@ -1148,6 +1209,7 @@
     if (pDevice)
     {
-        Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED);
-        Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED);
+        LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
+        ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice));
+        ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice));
         *pbFiltered = pDevice->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING;
         VBOXUSBFLT_LOCK_RELEASE();
@@ -1158,5 +1220,5 @@
     if (!pDevice)
     {
-        AssertFailed();
+        WARN(("VBoxUsbMonMemAllocZ failed"));
         return STATUS_NO_MEMORY;
     }
@@ -1167,5 +1229,5 @@
     if (!NT_SUCCESS(Status))
     {
-        AssertFailed();
+        WARN(("vboxUsbFltDevPopulate failed, Status 0x%x", Status));
         VBoxUsbMonMemFree(pDevice);
         return Status;
@@ -1182,6 +1244,7 @@
     if (pTmpDev)
     {
-        Assert(pTmpDev->enmState != VBOXUSBFLT_DEVSTATE_ADDED);
-        Assert(pTmpDev->enmState != VBOXUSBFLT_DEVSTATE_REMOVED);
+        LOG(("second try: found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo));
+        ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("second try: VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice));
+        ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("second try: VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice));
         *pbFiltered = pTmpDev->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING;
         VBOXUSBFLT_LOCK_RELEASE();
@@ -1190,16 +1253,21 @@
     }
 
+    LOG(("Created Device 0x%p for PDO 0x%p", pDevice, pPdo));
+
     pCtx = vboxUsbFltDevMatchLocked(pDevice, &uId,
             true, /* remove a one-shot filter */
             &fFilter, &fIsOneShot);
+    LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot));
     if (fFilter)
     {
-        Assert(pCtx);
-        Assert(uId);
+        LOG(("Created Device 0x%p should be filtered", pDevice));
+        ASSERT_WARN(pCtx, ("zero ctx"));
+        ASSERT_WARN(uId, ("zero uId"));
         pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING;
     }
     else
     {
-        Assert(!uId == !pCtx); /* either both zero or both not */
+        LOG(("Created Device 0x%p should NOT be filtered", pDevice));
+        ASSERT_WARN(!uId == !pCtx, ("invalid uid(0x%p) - ctx(0x%p) pair", uId, pCtx)); /* either both zero or both not */
         pDevice->enmState = VBOXUSBFLT_DEVSTATE_UNCAPTURED;
     }
@@ -1280,4 +1348,5 @@
     {
         pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURED;
+        LOG(("The proxy notified proxy start for the captured device 0x%x\n", pDevice));
         vboxUsbFltDevRetain(pDevice);
         vboxUsbFltSignalChangeLocked();
@@ -1285,5 +1354,5 @@
     else
     {
-        AssertFailed();
+        WARN(("invalid state, %d", pDevice->enmState));
         pDevice = NULL;
     }
@@ -1300,5 +1369,5 @@
     {
         /* this is due to devie was physically removed */
-        LOG(("The proxy notified progy stop for the captured device 0x%x\n", pDevice));
+        LOG(("The proxy notified proxy stop for the captured device 0x%x, current state %d\n", pDevice, pDevice->enmState));
         pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING;
         vboxUsbFltSignalChangeLocked();
@@ -1306,5 +1375,8 @@
     else
     {
-        Assert(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING);
+        if(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REPLUGGING)
+        {
+            WARN(("invalid state, %d", pDevice->enmState));
+        }
     }
     VBOXUSBFLT_LOCK_RELEASE();
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp	(revision 38356)
@@ -180,5 +180,5 @@
         if (pCur->pIrp != pIrp)
             continue;
-        AssertFailed();
+        WARN(("found pending IRP(0x%p) when it should not be", pIrp));
     }
     KeReleaseSpinLock(&pHook->Lock, oldIrql);
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp	(revision 38356)
@@ -168,5 +168,5 @@
     if (!pIrp)
     {
-        AssertMsgFailed(("IoBuildDeviceIoControlRequest failed!!\n"));
+        WARN(("IoBuildDeviceIoControlRequest failed!!\n"));
         return STATUS_INSUFFICIENT_RESOURCES;
     }
@@ -196,5 +196,11 @@
         }
         else
-            LOG(("Invalid pointer %p\n", pRel));
+        {
+            WARN(("Invalid pointer %p\n", pRel));
+        }
+    }
+    else
+    {
+        WARN(("IRP_MN_QUERY_DEVICE_RELATIONS failed Status(0x%x)\n", Status));
     }
 
@@ -302,5 +308,5 @@
 static NTSTATUS vboxUsbMonHandlePnPIoctl(PDEVICE_OBJECT pDevObj, PIO_STACK_LOCATION pSl, PIO_STATUS_BLOCK pIoStatus)
 {
-    LOG(("VBoxUSBMonHandlePnPIoctl IRQL = %d\n", KeGetCurrentIrql()));
+    LOG(("IRQL = %d\n", KeGetCurrentIrql()));
     switch(pSl->MinorFunction)
     {
@@ -315,5 +321,5 @@
                     KIRQL Iqrl = KeGetCurrentIrql();
                     /* IRQL should be always passive here */
-                    Assert(Iqrl == PASSIVE_LEVEL);
+                    ASSERT_WARN(Iqrl == PASSIVE_LEVEL, ("irql is not PASSIVE"));
                     switch(pSl->Parameters.QueryDeviceText.DeviceTextType)
                     {
@@ -328,4 +334,5 @@
                             if (VBoxUsbFltPdoIsFiltered(pDevObj))
                             {
+                                LOG(("PDO (0x%p) is filtered", pDevObj));
                                 WCHAR *pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szDeviceTextDescription));
                                 if (!pId)
@@ -340,6 +347,11 @@
                                 pIoStatus->Information = (ULONG_PTR)pId;
                             }
+                            else
+                            {
+                                LOG(("PDO (0x%p) is NOT filtered", pDevObj));
+                            }
                             break;
                         default:
+                            LOG(("DeviceText %d", pSl->Parameters.QueryDeviceText.DeviceTextType));
                             break;
                     }
@@ -357,5 +369,5 @@
             {
                 WCHAR *pId = (WCHAR *)pIoStatus->Information;
-#ifdef DEBUG
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
                 WCHAR *pTmp;
 #endif
@@ -364,5 +376,5 @@
                     KIRQL Iqrl = KeGetCurrentIrql();
                     /* IRQL should be always passive here */
-                    Assert(Iqrl == PASSIVE_LEVEL);
+                    ASSERT_WARN(Iqrl == PASSIVE_LEVEL, ("irql is not PASSIVE"));
 
                     switch (pSl->Parameters.QueryDeviceRelations.Type)
@@ -375,8 +387,9 @@
                         case BusQueryDeviceID:
                         {
+                            LOG(("BusQueryDeviceID"));
                             pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szBusQueryDeviceId));
                             if (!pId)
                             {
-                                AssertFailed();
+                                WARN(("ExAllocatePool failed"));
                                 break;
                             }
@@ -386,9 +399,17 @@
                             if (Status != STATUS_SUCCESS || !bFiltered)
                             {
-                                Assert(Status == STATUS_SUCCESS);
+                                if(Status == STATUS_SUCCESS)
+                                {
+                                    LOG(("PDO (0x%p) is NOT filtered", pDevObj));
+                                }
+                                else
+                                {
+                                    WARN(("VBoxUsbFltPdoAdd for PDO (0x%p) failed Status 0x%x", pDevObj, Status));
+                                }
                                 ExFreePool(pId);
                                 break;
                             }
 
+                            LOG(("PDO (0x%p) is filtered", pDevObj));
                             ExFreePool((PVOID)pIoStatus->Information);
                             memcpy(pId, szBusQueryDeviceId, sizeof(szBusQueryDeviceId));
@@ -398,8 +419,8 @@
                     case BusQueryHardwareIDs:
                     {
-#ifdef DEBUG
+                        LOG(("BusQueryHardwareIDs"));
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
                         while(*pId) //MULTI_SZ
                         {
-                            LOG(("BusQueryHardwareIDs"));
                             LOG_STRW(pId);
                             while(*pId) pId++;
@@ -410,5 +431,5 @@
                         if (!pId)
                         {
-                            AssertFailed();
+                            WARN(("ExAllocatePool failed"));
                             break;
                         }
@@ -418,15 +439,25 @@
                         if (Status != STATUS_SUCCESS || !bFiltered)
                         {
-                            Assert(Status == STATUS_SUCCESS);
+                            if(Status == STATUS_SUCCESS)
+                            {
+                                LOG(("PDO (0x%p) is NOT filtered", pDevObj));
+                            }
+                            else
+                            {
+                                WARN(("VBoxUsbFltPdoAdd for PDO (0x%p) failed Status 0x%x", pDevObj, Status));
+                            }
                             ExFreePool(pId);
                             break;
                         }
 
+                        LOG(("PDO (0x%p) is filtered", pDevObj));
+
                         memcpy(pId, szBusQueryHardwareIDs, sizeof(szBusQueryHardwareIDs));
-#ifdef DEBUG
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
+                        LOG(("NEW BusQueryHardwareIDs"));
                         pTmp = pId;
                         while(*pTmp) //MULTI_SZ
                         {
-                            LOG(("NEW BusQueryHardwareIDs"));
+
                             LOG_STRW(pTmp);
                             while(*pTmp) pTmp++;
@@ -439,8 +470,8 @@
                     }
                     case BusQueryCompatibleIDs:
-#ifdef DEBUG
+                        LOG(("BusQueryCompatibleIDs"));
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
                         while(*pId) //MULTI_SZ
                         {
-                            LOG(("BusQueryCompatibleIDs"));
                             LOG_STRW(pId);
                             while(*pId) pId++;
@@ -450,16 +481,17 @@
                         if (VBoxUsbFltPdoIsFiltered(pDevObj))
                         {
+                            LOG(("PDO (0x%p) is filtered", pDevObj));
                             pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szBusQueryCompatibleIDs));
                             if (!pId)
                             {
-                                AssertFailed();
+                                WARN(("ExAllocatePool failed"));
                                 break;
                             }
                             memcpy(pId, szBusQueryCompatibleIDs, sizeof(szBusQueryCompatibleIDs));
-#ifdef DEBUG
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
+                            LOG(("NEW BusQueryCompatibleIDs"));
                             pTmp = pId;
                             while(*pTmp) //MULTI_SZ
                             {
-                                LOG(("NEW BusQueryCompatibleIDs"));
                                 LOG_STRW(pTmp);
                                 while(*pTmp) pTmp++;
@@ -469,4 +501,8 @@
                             ExFreePool((PVOID)pIoStatus->Information);
                             pIoStatus->Information = (ULONG_PTR)pId;
+                        }
+                        else
+                        {
+                            LOG(("PDO (0x%p) is NOT filtered", pDevObj));
                         }
                         break;
@@ -474,10 +510,12 @@
                 }
                 else
+                {
                     LOG(("Invalid pointer %p\n", pId));
-            }
-            break;
-        }
-
-#ifdef DEBUG
+                }
+            }
+            break;
+        }
+
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
         case IRP_MN_QUERY_DEVICE_RELATIONS:
         {
@@ -542,5 +580,5 @@
     } /*switch */
 
-    LOG(("VBoxUSBMonHandlePnPIoctl returns %x (IRQL = %d)\n", pIoStatus->Status, KeGetCurrentIrql()));
+    LOG(("Done returns %x (IRQL = %d)\n", pIoStatus->Status, KeGetCurrentIrql()));
     return pIoStatus->Status;
 }
@@ -548,5 +586,6 @@
 NTSTATUS _stdcall VBoxUsbPnPCompletion(DEVICE_OBJECT *pDevObj, IRP *pIrp, void *pvContext)
 {
-    Assert(pvContext);
+    LOG(("Completion PDO(0x%p), IRP(0x%p), Status(0x%x)\n", pDevObj, pIrp, pIrp->IoStatus.Status));
+    ASSERT_WARN(pvContext, ("zero context"));
 
     PVBOXUSBHOOK_REQUEST pRequest = (PVBOXUSBHOOK_REQUEST)pvContext;
@@ -562,5 +601,5 @@
      * */
     PIO_STACK_LOCATION pSl = &pRequest->OldLocation;
-    Assert(pIrp == pRequest->pIrp);
+    ASSERT_WARN(pIrp == pRequest->pIrp, ("completed IRP(0x%x) not match request IRP(0x%x)", pIrp, pRequest->pIrp));
     /* NOTE: we can not rely on pDevObj passed in IoCompletion since it may be zero
      * in case IRP was created with extra stack locations and the caller did not initialize
@@ -574,5 +613,5 @@
         case IRP_MN_QUERY_DEVICE_TEXT:
         case IRP_MN_QUERY_ID:
-#ifdef DEBUG
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
         case IRP_MN_QUERY_DEVICE_RELATIONS:
         case IRP_MN_QUERY_CAPABILITIES:
@@ -584,5 +623,5 @@
             else
             {
-                Assert(pIrp->IoStatus.Status == STATUS_NOT_SUPPORTED);
+                ASSERT_WARN(pIrp->IoStatus.Status == STATUS_NOT_SUPPORTED, ("Irp failed with status(0x%x)", pIrp->IoStatus.Status));
             }
             break;
@@ -645,6 +684,9 @@
 NTSTATUS _stdcall VBoxUsbMonPnPHook(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
 {
+    LOG(("==>PnP: Mn(%s), PDO(0x%p), IRP(0x%p), Status(0x%x)\n", vboxUsbDbgStrPnPMn(IoGetCurrentIrpStackLocation(pIrp)->MinorFunction), pDevObj, pIrp, pIrp->IoStatus.Status));
+
     if(!VBoxUsbHookRetain(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook))
     {
+        WARN(("VBoxUsbHookRetain failed"));
         return VBoxUsbHookRequestPassDownHookSkip(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook, pDevObj, pIrp);
     }
@@ -653,5 +695,5 @@
     if (!pCompletion)
     {
-        AssertFailed();
+        WARN(("VBoxUsbMonMemAlloc failed"));
         VBoxUsbHookRelease(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook);
         pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -661,11 +703,14 @@
     }
 
-    LOG(("==>PnP: Mn(%s), PDO(0x%p), IRP(0x%p), Status(0x%x)\n", vboxUsbDbgStrPnPMn(IoGetCurrentIrpStackLocation(pIrp)->MinorFunction), pDevObj, pIrp, pIrp->IoStatus.Status));
-
     NTSTATUS Status = VBoxUsbHookRequestPassDownHookCompletion(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook, pDevObj, pIrp, VBoxUsbPnPCompletion, &pCompletion->Rq);
-#ifdef DEBUG
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
     if (Status != STATUS_PENDING)
     {
+        LOG(("Request completed, Status(0x%x)", Status));
         VBoxUsbHookVerifyCompletion(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook, &pCompletion->Rq, pIrp);
+    }
+    else
+    {
+        LOG(("Request pending"));
     }
 #endif
@@ -992,5 +1037,5 @@
             if (!pvBuffer || cbOutBuffer != sizeof(*pOut) || cbInBuffer != 0)
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_GET_VERSION: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_GET_VERSION: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
                         cbInBuffer, 0, cbOutBuffer, sizeof (*pOut)));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1000,4 +1045,5 @@
             pOut->u32Minor = USBMON_MINOR_VERSION;
             Info = sizeof (*pOut);
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1011,5 +1057,5 @@
             if (RT_UNLIKELY(!pvBuffer || cbInBuffer != sizeof (*pFilter) || cbOutBuffer != sizeof (*pOut)))
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_ADD_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_ADD_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
                         cbInBuffer, sizeof (*pFilter), cbOutBuffer, sizeof (*pOut)));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1021,4 +1067,5 @@
             pOut->uId = uId;
             Info = sizeof (*pOut);
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1031,5 +1078,5 @@
             if (!pvBuffer || cbInBuffer != sizeof (*pIn) || (cbOutBuffer && cbOutBuffer != sizeof (*pRc)))
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_REMOVE_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_REMOVE_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
                         cbInBuffer, sizeof (*pIn), cbOutBuffer, 0));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1045,4 +1092,5 @@
                 Info = sizeof (*pRc);
             }
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1052,5 +1100,5 @@
             if (pvBuffer || cbInBuffer || cbOutBuffer)
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_RUN_FILTERS: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_RUN_FILTERS: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
                         cbInBuffer, 0, cbOutBuffer, 0));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1059,6 +1107,5 @@
             LOG(("SUPUSBFLT_IOCTL_RUN_FILTERS \n"));
             Status = VBoxUsbMonRunFilters(pContext);
-            Assert(Status == STATUS_SUCCESS);
-            Assert(Status != STATUS_PENDING);
+            ASSERT_WARN(Status != STATUS_PENDING, ("status pending!"));
             break;
         }
@@ -1070,5 +1117,5 @@
             if (!pvBuffer || cbInBuffer != sizeof (hDevice) || cbOutBuffer < sizeof (*pOut))
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_GET_DEVICE: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected >= %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_GET_DEVICE: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected >= %d.\n",
                         cbInBuffer, sizeof (hDevice), cbOutBuffer, sizeof (*pOut)));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1084,5 +1131,5 @@
             else
             {
-                AssertFailed();
+                WARN(("VBoxUsbMonGetDevice fail 0x%x", Status));
             }
             break;
@@ -1094,5 +1141,5 @@
             if (!pvBuffer || cbInBuffer != sizeof (*pSne) || cbOutBuffer != sizeof (*pSne))
             {
-                AssertMsgFailed(("SUPUSBFLT_IOCTL_SET_NOTIFY_EVENT: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
+                WARN(("SUPUSBFLT_IOCTL_SET_NOTIFY_EVENT: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.\n",
                         cbInBuffer, sizeof (*pSne), cbOutBuffer, sizeof (*pSne)));
                 Status = STATUS_INVALID_PARAMETER;
@@ -1102,13 +1149,15 @@
             pSne->u.rc = VBoxUsbMonSetNotifyEvent(pContext, pSne->u.hEvent);
             Info = sizeof (*pSne);
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
 
         default:
+            WARN(("Unknown code 0x%x", Ctl));
             Status = STATUS_INVALID_PARAMETER;
             break;
     }
 
-    Assert(Status != STATUS_PENDING);
+    ASSERT_WARN(Status != STATUS_PENDING, ("Status pending!"));
 
     *pInfo = Info;
@@ -1134,7 +1183,11 @@
                     pSl->Parameters.DeviceIoControl.OutputBufferLength,
                     &Info);
-        Assert(Status != STATUS_PENDING);
+        ASSERT_WARN(Status != STATUS_PENDING, ("Status pending"));
 
         IoReleaseRemoveLock(&g_VBoxUsbMonGlobals.RmLock, pDevObj);
+    }
+    else
+    {
+        WARN(("IoAcquireRemoveLock failed Status (0x%x)", Status));
     }
 
@@ -1158,5 +1211,5 @@
             if (!pvBuffer)
             {
-                AssertMsgFailed(("VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION: Buffer is NULL\n"));
+                WARN(("VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION: Buffer is NULL\n"));
                 Status = STATUS_INVALID_PARAMETER;
                 break;
@@ -1164,4 +1217,5 @@
             pOut->u32Major = VBOXUSBIDC_VERSION_MAJOR;
             pOut->u32Minor = VBOXUSBIDC_VERSION_MINOR;
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1174,5 +1228,5 @@
             if (!pvBuffer)
             {
-                AssertMsgFailed(("VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION: Buffer is NULL\n"));
+                WARN(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP: Buffer is NULL\n"));
                 Status = STATUS_INVALID_PARAMETER;
                 break;
@@ -1180,4 +1234,6 @@
 
             pOut->u.hDev = VBoxUsbFltProxyStarted(pOut->u.pPDO);
+            ASSERT_WARN(pOut->u.hDev, ("zero hDev"));
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1190,10 +1246,12 @@
             if (!pvBuffer)
             {
-                AssertMsgFailed(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN: Buffer is NULL\n"));
+                WARN(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN: Buffer is NULL\n"));
                 Status = STATUS_INVALID_PARAMETER;
                 break;
             }
 
+            ASSERT_WARN(pOut->hDev, ("zero hDev"));
             VBoxUsbFltProxyStopped(pOut->hDev);
+            ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status));
             break;
         }
@@ -1201,5 +1259,5 @@
         default:
         {
-            AssertFailed();
+            WARN(("Unknown code 0x%x", Ctl));
             Status = STATUS_INVALID_PARAMETER;
             break;
@@ -1276,5 +1334,5 @@
 NTSTATUS _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
 {
-#ifdef DEBUG_misha
+#ifdef VBOX_USB_WITH_VERBOSE_LOGGING
     RTLogGroupSettings(0, "+default.e.l.f.l2.l3");
     RTLogDestinations(0, "debugger");
Index: trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h
===================================================================
--- trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h	(revision 38292)
+++ trunk/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h	(revision 38356)
@@ -31,5 +31,4 @@
 #endif
 
-#define VBOX_DBG_LOG_NAME "USBMon"
 #include "../../../win/VBoxDbgLog.h"
 #include "../cmn/VBoxDrvTool.h"
