Changeset 14352 in vbox for trunk/src/VBox

Timestamp:

Nov 19, 2008 2:10:24 PM (16 years ago)

Author:

vboxsync

Message:

Additions/HGCM: merged code for HGCMCall and HGCMCallTimed, as per todo

Location:

trunk/src/VBox/Additions

Files:

• WINNT/VBoxGuest/VBoxGuest.cpp (modified) (7 diffs)
• common/VBoxGuest/VBoxGuest.cpp (modified) (13 diffs)
• common/VBoxGuestLib/HGCM.cpp (modified) (1 diff)
• common/VBoxGuestLib/VBoxGuestR3LibGuestProp.cpp (modified) (1 diff)
• linux/module/cmc.c (modified) (4 diffs)
• linux/module/vboxmod.c (modified) (3 diffs)

trunk/src/VBox/Additions/WINNT/VBoxGuest/VBoxGuest.cpp

@@ -341 +341 @@
 
 #ifdef VBOX_WITH_HGCM
-DECLVBGL(void) VBoxHGCMCallback (VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data)
-{
-    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvData;
-
-    dprintf(("VBoxHGCMCallback\n"));
-
+void VBoxHGCMCallbackWorker (VMMDevHGCMRequestHeader *pHeader, PVBOXGUESTDEVEXT pDevExt,
+                             uint32_t u32Timeout, bool fInterruptible)
+{
     /* Possible problem with request completion right between the fu32Flags check and KeWaitForSingleObject
      * call; introduce a timeout to make sure we don't wait indefinitely.
      */
 
+    LARGE_INTEGER timeout;
+    if (u32Timeout == RT_INDEFINITE_WAIT)
+        timeout.QuadPart = pDevExt->HGCMWaitTimeout.QuadPart;
+    else
+        timeout.QuadPart = u32Timeout * -10000; /* relative in 100ns units */
     while ((pHeader->fu32Flags & VBOX_HGCM_REQ_DONE) == 0)
     {
-        /* Specifying UserMode so killing the user process will abort the wait.
-         * @todo Since VbglGRCancel is not yet implemented, the wait itself must
-         *       be not interruptible. The wait can be interrupted only when the
-         *       calling process is being killed.
-         *       When alertable is TRUE, the wait sometimes ends with STATUS_USER_APC.
-         */
+        /* Specifying UserMode so killing the user process will abort the wait. */
         NTSTATUS rc = KeWaitForSingleObject (&pDevExt->keventNotification, Executive,
                                              UserMode,
-                                             FALSE, /* Not Alertable */
-                                             &pDevExt->HGCMWaitTimeout
+                                             fInterruptible ? TRUE : FALSE, /* Alertable */
+                                             &timeout
                                             );
         dprintf(("VBoxHGCMCallback: Wait returned %d fu32Flags=%x\n", rc, pHeader->fu32Flags));
 
-        if (rc == STATUS_TIMEOUT)
+        if (rc == STATUS_TIMEOUT && u32Timeout == RT_INDEFINITE_WAIT)
             continue;
 
@@ -380 +377 @@
 }
 
-/* Note that VbglGRCancel *is* now implemented. */
-DECLVBGL(void) VBoxHGCMCallbackTimeout (VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data)
+DECLVBGL(void) VBoxHGCMCallback (VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data)
 {
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvData;
-    LARGE_INTEGER timeout;
-    timeout.QuadPart = u32Data * -10000; /* relative in 100ns units */
-    dprintf(("VBoxHGCMCallbackTimeout: entering, timeout %llu\n", timeout.QuadPart));
-    NTSTATUS rc = KeWaitForSingleObject (&pDevExt->keventNotification, Executive,
-                                         UserMode,
-                                         FALSE, /* Not Alertable */
-                                         &timeout
-                                        );
-    dprintf(("VBoxHGCMCallbackTimeout: Wait returned %d fu32Flags=%x\n", rc, pHeader->fu32Flags));
-
-    if (rc != STATUS_WAIT_0)
-        dprintf(("VBoxHGCMCallbackTimeout: The external event was signalled or the wait timed out or terminated rc = 0x%08X.\n", rc));
-    else
-        dprintf(("VBoxHGCMCallbackTimeout: fu32Flags = %08X\n", pHeader->fu32Flags));
-    return;
+
+    dprintf(("VBoxHGCMCallback\n"));
+    VBoxHGCMCallbackWorker (pHeader, pDevExt, u32Data, false);
+}
+
+DECLVBGL(void) VBoxHGCMCallbackInterruptible (VMMDevHGCMRequestHeader *pHeader, void *pvData,
+                                              uint32_t u32Data)
+{
+    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvData;
+
+    dprintf(("VBoxHGCMCallback\n"));
+    VBoxHGCMCallbackWorker (pHeader, pDevExt, u32Data, true);
 }
 
@@ -937 +930 @@
             dprintf(("a) ptr->u32ClientID = %d\n", ptr->u32ClientID));
 
-            int rc = VbglHGCMConnect (ptr, VBoxHGCMCallback, pDevExt, 0);
+            int rc = VbglHGCMConnect (ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
 
             dprintf(("b) ptr->u32ClientID = %d\n", ptr->u32ClientID));
@@ -980 +973 @@
              */
 
-            int rc = VbglHGCMDisconnect (ptr, VBoxHGCMCallback, pDevExt, 0);
+            int rc = VbglHGCMDisconnect (ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
 
             if (RT_FAILURE(rc))
@@ -1009 +1002 @@
             VBoxGuestHGCMCallInfo *ptr = (VBoxGuestHGCMCallInfo *)pBuf;
 
-            int rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, 0);
+            int rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
 
             if (RT_FAILURE(rc))
@@ -1023 +1016 @@
         } break;
 
-        case VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0): /* (The size isn't relevant on NT.) */
-        {
-            dprintf(("VBoxGuest::VBoxGuestDeviceControl: VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT\n"));
+        case VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0): /* (The size isn't relevant on NT.) */
+        {
+            dprintf(("VBoxGuest::VBoxGuestDeviceControl: VBOXGUEST_IOCTL_HGCM_CALL_TIMED\n"));
 
             Status = vboxHGCMVerifyIOBuffers (pStack,
-                                              sizeof (VBoxGuestHGCMCallInfoTimeout));
+                                              sizeof (VBoxGuestHGCMCallInfoTimed));
 
             if (Status != STATUS_SUCCESS)
@@ -1036 +1029 @@
             }
 
-            VBoxGuestHGCMCallInfoTimeout *pInfo = (VBoxGuestHGCMCallInfoTimeout *)pBuf;
+            VBoxGuestHGCMCallInfoTimed *pInfo = (VBoxGuestHGCMCallInfoTimed *)pBuf;
             VBoxGuestHGCMCallInfo *ptr = &pInfo->info;
 
             int rc;
-            if (pInfo->u32Timeout == RT_INDEFINITE_WAIT)
-            {
-                dprintf(("VBoxGuest::VBoxGuestDeviceControl: calling VBoxHGCMCall with no timeout\n"));
-                rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, 0);
+            if (pInfo->fInterruptible)
+            {
+                dprintf(("VBoxGuest::VBoxGuestDeviceControl: calling VBoxHGCMCall interruptible, timeout %lu ms\n",
+                         pInfo->u32Timeout));
+                rc = VbglHGCMCall (ptr, VBoxHGCMCallbackInterruptible, pDevExt, pInfo->u32Timeout);
             }
             else
             {
-                dprintf(("VBoxGuest::VBoxGuestDeviceControl: calling VBoxHGCMCall timeout %lu ms\n",
+                dprintf(("VBoxGuest::VBoxGuestDeviceControl: calling VBoxHGCMCall, timeout %lu ms\n",
                          pInfo->u32Timeout));
-                rc = VbglHGCMCall (ptr, VBoxHGCMCallbackTimeout, pDevExt, pInfo->u32Timeout);
+                rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, pInfo->u32Timeout);
             }
 
             if (RT_FAILURE(rc))
             {
-                dprintf(("VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT: vbox rc = %Rrc\n", rc));
+                dprintf(("VBOXGUEST_IOCTL_HGCM_CALL_TIMED: vbox rc = %Rrc\n", rc));
                 Status = STATUS_UNSUCCESSFUL;
             }

trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp

@@ -389 +389 @@
             pSession->aHGCMClientIds[i] = 0;
             Log(("VBoxGuestCloseSession: disconnecting client id %#RX32\n", Info.u32ClientID));
-            VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, false /* uninterruptible */);
+            VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
         }
 #endif
@@ -910 +910 @@
 }
 
-
 /**
  * This is a callback for dealing with async waits.
@@ -918 +917 @@
 static DECLCALLBACK(void) VBoxGuestHGCMAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
 {
-    const bool fInterruptible = (bool)u32User;
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
     LogFunc(("requestType=%d\n", pHdr->header.requestType));
-    VBoxGuestHGCMAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt, fInterruptible, RT_INDEFINITE_WAIT);
-}
-
+    VBoxGuestHGCMAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr,
+                                         pDevExt, false /* fInterruptible */,
+                                         RT_INDEFINITE_WAIT);
+}
 
 /**
@@ -930 +929 @@
  * It operates in a manner similar to VBoxGuestCommonIOCtl_WaitEvent.
  */
-static DECLCALLBACK(void) VBoxGuestHGCMAsyncWaitCallbackTimeoutInterruptible(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
+static DECLCALLBACK(void) VBoxGuestHGCMAsyncWaitCallbackInterruptible(VMMDevHGCMRequestHeader *pHdr,
+                                                   void *pvUser, uint32_t u32User)
 {
     PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
     LogFunc(("requestType=%d\n", pHdr->header.requestType));
-    VBoxGuestHGCMAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt, true /* fInterruptible */, u32User);
-}
-
-
-/**
- * This is an uninterruptible callback for dealing with async waits with a timeout.
- *
- * It operates in a manner similar to VBoxGuestCommonIOCtl_WaitEvent.
- */
-static DECLCALLBACK(void) VBoxGuestHGCMAsyncWaitCallbackTimeout(VMMDevHGCMRequestHeader *pHdr, void *pvUser, uint32_t u32User)
-{
-    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
-    LogFunc(("requestType=%d\n", pHdr->header.requestType));
-    VBoxGuestHGCMAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt, false /* fInterruptible */, u32User);
-}
-
+    VBoxGuestHGCMAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr,
+                                         pDevExt, true /* fInterruptible */,
+                                         u32User);
+}
 
 static int VBoxGuestCommonIOCtl_HGCMConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestHGCMConnectInfo *pInfo,
@@ -963 +951 @@
          ? pInfo->Loc.u.host.achName : "<not local host>"));
 
-    int rc = VbglHGCMConnect(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, false /* uninterruptible */);
+    int rc = VbglHGCMConnect(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
     if (RT_SUCCESS(rc))
     {
@@ -993 +981 @@
                 Info.result = 0;
                 Info.u32ClientID = pInfo->u32ClientID;
-                VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, false /* uninterruptible */);
+                VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
                 return VERR_TOO_MANY_OPEN_FILES;
             }
@@ -1035 +1023 @@
      */
     Log(("VBoxGuestCommonIOCtl: HGCM_DISCONNECT: u32Client=%RX32\n", pInfo->u32ClientID));
-    int rc = VbglHGCMDisconnect(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, false /* uninterruptible */);
+    int rc = VbglHGCMDisconnect(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
     if (RT_SUCCESS(rc))
     {
@@ -1053 +1041 @@
 
 
-/** @remarks Identical to VBoxGuestCommonIOCtl_HGCMCallTimeout. */
-static int VBoxGuestCommonIOCtl_HGCMCall(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestHGCMCallInfo *pInfo,
+static int VBoxGuestCommonIOCtl_HGCMCall(PVBOXGUESTDEVEXT pDevExt,
+                                         PVBOXGUESTSESSION pSession,
+                                         VBoxGuestHGCMCallInfo *pInfo,
+                                         uint32_t u32Timeout, bool fInterruptible,
                                          size_t cbData, size_t *pcbDataReturned)
 {
@@ -1099 +1089 @@
      */
     Log(("VBoxGuestCommonIOCtl: HGCM_CALL: u32Client=%RX32\n", pInfo->u32ClientID));
-    int rc = VbglHGCMCall(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, pSession->R0Process != NIL_RTR0PROCESS);
+    int rc;
+    if (fInterruptible)
+        rc = VbglHGCMCall(pInfo, VBoxGuestHGCMAsyncWaitCallbackInterruptible, pDevExt,
+                          u32Timeout);
+    else
+        rc = VbglHGCMCall(pInfo, VBoxGuestHGCMAsyncWaitCallback, pDevExt, u32Timeout);
     if (RT_SUCCESS(rc))
     {
@@ -1110 +1105 @@
 }
 
-
-# ifdef HGCM_TIMEOUT
-/** @remarks Identical to VBoxGuestCommonIOCtl_HGCMCall.
- * @todo r=bird: merge the two.  */
-static int VBoxGuestCommonIOCtl_HGCMCallTimeout(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VBoxGuestHGCMCallInfoTimeout *pInfoTimeout,
-                                                size_t cbData, size_t *pcbDataReturned)
-{
-    VBoxGuestHGCMCallInfo *pInfo = &pInfoTimeout->info;
-    /*
-     * Some more validations.
-     */
-    if (pInfo->cParms > 4096) /* (Just make sure it doesn't overflow the next check.) */
-    {
-        Log(("VBoxGuestCommonIOCtl: HGCM_CALL: cParm=%RX32 is not sane\n", pInfo->cParms));
-        return VERR_INVALID_PARAMETER;
-    }
-    const size_t cbActual = sizeof(*pInfoTimeout) + pInfo->cParms * sizeof(HGCMFunctionParameter);
-    if (cbData < cbActual)
-    {
-        Log(("VBoxGuestCommonIOCtl: HGCM_CALL: cbData=%#zx (%zu) required size is %#zx (%zu)\n",
-             cbData, cbActual));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    /*
-     * Validate the client id.
-     */
-    const uint32_t u32ClientId = pInfo->u32ClientID;
-    unsigned i;
-    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
-    RTSpinlockAcquireNoInts(pDevExt->SessionSpinlock, &Tmp);
-    for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
-        if (pSession->aHGCMClientIds[i] == u32ClientId)
-            break;
-    RTSpinlockReleaseNoInts(pDevExt->SessionSpinlock, &Tmp);
-    if (RT_UNLIKELY(i >= RT_ELEMENTS(pSession->aHGCMClientIds)))
-    {
-        static unsigned s_cErrors = 0;
-        if (s_cErrors++ > 32)
-            LogRel(("VBoxGuestCommonIOCtl: HGCM_CALL: Invalid handle. u32Client=%RX32\n", u32ClientId));
-        return VERR_INVALID_HANDLE;
-    }
-
-    /*
-     * The VbglHGCMCall call will invoke the callback if the HGCM
-     * call is performed in an ASYNC fashion. This function can
-     * deal with cancelled requests, so we let user more requests
-     * be interruptible (should add a flag for this later I guess).
-     */
-    Log(("VBoxGuestCommonIOCtl: HGCM_CALL: u32Client=%RX32\n", pInfo->u32ClientID));
-    int rc;
-    if (pSession->R0Process == NIL_RTR0PROCESS)
-        rc = VbglHGCMCall(pInfo, VBoxGuestHGCMAsyncWaitCallbackTimeout, pDevExt, pInfoTimeout->u32Timeout);
-    else
-        rc = VbglHGCMCall(pInfo, VBoxGuestHGCMAsyncWaitCallbackTimeoutInterruptible, pDevExt,
-                          pInfoTimeout->u32Timeout);
-    if (RT_SUCCESS(rc))
-    {
-        Log(("VBoxGuestCommonIOCtl: HGCM_CALL: result=%Rrc\n", pInfo->result));
-        if (pcbDataReturned)
-            *pcbDataReturned = cbActual;
-    }
-    Log(("VBoxGuestCommonIOCtl: HGCM_CALL: Failed. rc=%Rrc.\n", rc));
-    return rc;
-}
-# endif /* HGCM_TIMEOUT */
-
-
 /**
  * @returns VBox status code. Unlike the other HGCM IOCtls this will combine
@@ -1196 +1123 @@
         Info.result = (uint32_t)VERR_WRONG_ORDER;           /** @todo Vitali, why is this member unsigned? */
         Info.u32ClientID = pDevExt->u32ClipboardClientId;
-        rc = VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, 0);
+        rc = VbglHGCMDisconnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
         if (RT_SUCCESS(rc))
         {
@@ -1219 +1146 @@
     Info.result = (uint32_t)VERR_WRONG_ORDER;
 
-    rc = VbglHGCMConnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, 0);
+    rc = VbglHGCMConnect(&Info, VBoxGuestHGCMAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
     if (RT_FAILURE(rc))
     {
@@ -1323 +1250 @@
      * These ones are tricky and can be done later.
      */
-/**@todo r=bird: Merge the handling of these two. The only difference is that the 2nd has one or two extra argument preceeding the call info. */
     else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL(0)))
     {
         CHECKRET_MIN_SIZE("HGCM_CALL", sizeof(VBoxGuestHGCMCallInfo));
-        rc = VBoxGuestCommonIOCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData, cbData, pcbDataReturned);
-    }
-# ifdef HGCM_TIMEOUT
-    else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0)))
-    {
-        CHECKRET_MIN_SIZE("HGCM_CALL_TIMEOUT", sizeof(VBoxGuestHGCMCallInfoTimeout));
-        rc = VBoxGuestCommonIOCtl_HGCMCallTimeout(pDevExt, pSession, (VBoxGuestHGCMCallInfoTimeout *)pvData, cbData, pcbDataReturned);
-    }
-# endif /* HGCM_TIMEOUT */
+        bool fInterruptible = pSession->R0Process != NIL_RTR0PROCESS;
+        rc = VBoxGuestCommonIOCtl_HGCMCall(pDevExt, pSession, (VBoxGuestHGCMCallInfo *)pvData,
+                                           RT_INDEFINITE_WAIT, fInterruptible,
+                                           cbData, pcbDataReturned);
+    }
+    else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0)))
+    {
+        CHECKRET_MIN_SIZE("HGCM_CALL_TIMED", sizeof(VBoxGuestHGCMCallInfoTimed));
+        VBoxGuestHGCMCallInfoTimed *pInfo = (VBoxGuestHGCMCallInfoTimed *)pvData;
+        rc = VBoxGuestCommonIOCtl_HGCMCall(pDevExt, pSession, &pInfo->info,
+                                           pInfo->u32Timeout, !!pInfo->fInterruptible,
+                                           cbData, pcbDataReturned);
+    }
 #endif /* VBOX_WITH_HGCM */
     else if (VBOXGUEST_IOCTL_STRIP_SIZE(iFunction) == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_LOG(0)))

trunk/src/VBox/Additions/common/VBoxGuestLib/HGCM.cpp

@@ -187 +187 @@
 }
 
-DECLVBGL(int) VbglHGCMCallTimeout (VBGLHGCMHANDLE handle,
-                                   VBoxGuestHGCMCallInfoTimeout *pData, uint32_t cbData)
+DECLVBGL(int) VbglHGCMCallTimed (VBGLHGCMHANDLE handle,
+                                 VBoxGuestHGCMCallInfoTimed *pData, uint32_t cbData)
 {
     int rc = VINF_SUCCESS;
 
-    VBGL_HGCM_ASSERTMsg(cbData >= sizeof (VBoxGuestHGCMCallInfoTimeout) + pData->info.cParms * sizeof (HGCMFunctionParameter),
-                        ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->info.cParms, sizeof (VBoxGuestHGCMCallInfoTimeout) + pData->info.cParms * sizeof (VBoxGuestHGCMCallInfo)));
-
-    if (pData->u32Timeout == RT_INDEFINITE_WAIT)
-    {
-        uint32_t cbDataNew = cbData - RT_OFFSETOF(VBoxGuestHGCMCallInfoTimeout, info);
-        rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL(cbDataNew), &pData->info,
-                              cbDataNew);
-    }
-    else
-        rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(cbData), pData, cbData);
+    uint32_t cbExpected =   sizeof (VBoxGuestHGCMCallInfoTimed)
+                          + pData->info.cParms * sizeof (HGCMFunctionParameter);
+    VBGL_HGCM_ASSERTMsg(cbData >= cbExpected,
+                        ("cbData = %d, cParms = %d (calculated size %d)\n",
+                        cbData, pData->info.cParms, cbExpected));
+
+    rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_TIMED(cbData),
+                          pData, cbData);
 
     return rc;

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestProp.cpp

@@ -846 +846 @@
     Msg.size.SetUInt32(0);
 
-    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(sizeof(Msg)), &Msg, sizeof(Msg));
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(sizeof(Msg)), &Msg, sizeof(Msg));
     if (RT_SUCCESS(rc))
         rc = Msg.hdr.info.result;

trunk/src/VBox/Additions/linux/module/cmc.c

@@ -31 +31 @@
 {
     VBoxDevice *dev = pvData;
-    wait_event (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE);
+    if (u32Data == RT_INDEFINITE_WAIT)
+        wait_event (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE);
+    else
+        wait_event_timeout (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE,
+                            msecs_to_jiffies (u32Data));
 }
 
@@ -38 +42 @@
 {
     VBoxDevice *dev = pvData;
-    wait_event_interruptible (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE);
-}
-
-static DECLVBGL(void)
-vboxadd_hgcm_callback_timeout (VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data)
-{
-    VBoxDevice *dev = pvData;
-    wait_event_interruptible_timeout (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE,
-                                      msecs_to_jiffies (u32Data));
+    if (u32Data == RT_INDEFINITE_WAIT)
+        wait_event_interruptible (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE);
+    else
+        wait_event_interruptible_timeout (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE,
+                                          msecs_to_jiffies (u32Data));
 }
 
@@ -56 +56 @@
     if (   VBOXGUEST_IOCTL_STRIP_SIZE(func)
         == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL(0)))
-        rc = VbglHGCMCall (data, vboxadd_hgcm_callback_interruptible, opaque, 0);
+        rc = VbglHGCMCall (data, vboxadd_hgcm_callback_interruptible, opaque, RT_INDEFINITE_WAIT);
     /* this function can handle cancelled requests */
     else if (   VBOXGUEST_IOCTL_STRIP_SIZE(func)
-             == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0)))
+             == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0)))
     {
-        VBoxGuestHGCMCallInfoTimeout *pCallInfo;
-        pCallInfo = (VBoxGuestHGCMCallInfoTimeout *) data;
-        rc = VbglHGCMCall (&pCallInfo->info, vboxadd_hgcm_callback_timeout,
-                           opaque, pCallInfo->u32Timeout);
+        VBoxGuestHGCMCallInfoTimed *pCallInfo;
+        pCallInfo = (VBoxGuestHGCMCallInfoTimed *) data;
+        if (pCallInfo->fInterruptible)
+            rc = VbglHGCMCall (&pCallInfo->info, vboxadd_hgcm_callback_interruptible,
+                               opaque, pCallInfo->u32Timeout);
+        else
+            rc = VbglHGCMCall (&pCallInfo->info, vboxadd_hgcm_callback,
+                               opaque, pCallInfo->u32Timeout);
     }
     else switch (func)
@@ -70 +74 @@
         /* this function can NOT handle cancelled requests */
         case VBOXGUEST_IOCTL_HGCM_CONNECT:
-            rc = VbglHGCMConnect (data, vboxadd_hgcm_callback, opaque, 0);
+            rc = VbglHGCMConnect (data, vboxadd_hgcm_callback, opaque, RT_INDEFINITE_WAIT);
             break;
 
         /* this function can NOT handle cancelled requests */
         case VBOXGUEST_IOCTL_HGCM_DISCONNECT:
-            rc = VbglHGCMDisconnect (data, vboxadd_hgcm_callback, opaque, 0);
+            rc = VbglHGCMDisconnect (data, vboxadd_hgcm_callback, opaque, RT_INDEFINITE_WAIT);
             break;
 

trunk/src/VBox/Additions/linux/module/vboxmod.c

@@ -420 +420 @@
  * @param  u32Size        the size of the userspace structure
  */
-static int vboxadd_hgcm_call_timeout(unsigned long userspace_info,
+static int vboxadd_hgcm_call_timed(unsigned long userspace_info,
                                      uint32_t u32Size)
 {
-        VBoxGuestHGCMCallInfoTimeout *pInfo = NULL;
+        VBoxGuestHGCMCallInfoTimed *pInfo = NULL;
         int rc = 0;
         
@@ -445 +445 @@
                 LogRelFunc(("client ID %u\n", pInfo->info.u32ClientID));
                 vrc = vboxadd_cmc_call(vboxDev,
-                              VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(u32Size), pInfo);
+                              VBOXGUEST_IOCTL_HGCM_CALL_TIMED(u32Size), pInfo);
                 rc = -RTErrConvertToErrno(vrc);
                 if (   rc >= 0
@@ -624 +624 @@
                 IOCTL_EXIT("VBOXGUEST_IOCTL_HGCM_CALL", arg);
         }
-        else if (   VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0))
+        else if (   VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0))
                  == VBOXGUEST_IOCTL_STRIP_SIZE(cmd))
         {
         /* Do the HGCM call using the Vbgl bits */
-                IOCTL_ENTRY("VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT", arg);
-                rc = vboxadd_hgcm_call_timeout(arg, _IOC_SIZE(cmd));
-                IOCTL_EXIT("VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT", arg);
+                IOCTL_ENTRY("VBOXGUEST_IOCTL_HGCM_CALL_TIMED", arg);
+                rc = vboxadd_hgcm_call_timed(arg, _IOC_SIZE(cmd));
+                IOCTL_EXIT("VBOXGUEST_IOCTL_HGCM_CALL_TIMED", arg);
         }
         else