Changeset 15704 in vbox

Timestamp:

Dec 19, 2008 4:44:54 PM (16 years ago)

Author:

vboxsync

Message:

Introduced VbglHCGMCall32 for supporting 32 bits clients on 64 bits guests.

Location:

trunk

Files:

• include/VBox/VBoxGuest.h (modified) (2 diffs)
• include/VBox/VBoxGuestLib.h (modified) (1 diff)
• src/VBox/Additions/WINNT/VBoxGuest/VBoxGuest.cpp (modified) (3 diffs)
• src/VBox/Additions/common/VBoxGuestLib/HGCMInternal.cpp (modified) (1 diff)

trunk/include/VBox/VBoxGuest.h

@@ -916 +916 @@
 #pragma pack()
 
-#define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
+#define VMMDEV_HGCM_CALL_PARMS(a)   ((HGCMFunctionParameter *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
+#define VMMDEV_HGCM_CALL_PARMS32(a) ((HGCMFunctionParameter32 *)((uint8_t *)a + sizeof (VMMDevHGCMCall)))
 
 #ifdef VBOX_WITH_64_BITS_GUESTS
@@ -1404 +1405 @@
 
 # define VBOXGUEST_HGCM_CALL_PARMS(a)       ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
+# define VBOXGUEST_HGCM_CALL_PARMS32(a)     ((HGCMFunctionParameter32 *)((uint8_t *)(a) + sizeof (VBoxGuestHGCMCallInfo)))
 
 #endif /* VBOX_WITH_HGCM */

trunk/include/VBox/VBoxGuestLib.h

@@ -200 +200 @@
 DECLVBGL(int) VbglHGCMCall (VBoxGuestHGCMCallInfo *pCallInfo,
                             VBGLHGCMCALLBACK *pAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
+
+/** Call a HGCM service. (32 bits packet structure in a 64 bits guest)
+ *
+ * @note This function can deal with cancelled requests.
+ *
+ * @param pCallInfo       The request data.
+ * @param pAsyncCallback  Required pointer to function that is called when
+ *                        host returns VINF_HGCM_ASYNC_EXECUTE. VBoxGuest
+ *                        implements waiting for an IRQ in this function.
+ * @param pvAsyncData     An arbitrary VBoxGuest pointer to be passed to callback.
+ * @param u32AsyncData    An arbitrary VBoxGuest 32 bit value to be passed to callback.
+ *
+ * @return VBox status code.
+ */
+DECLVBGL(int) VbglHGCMCall32 (VBoxGuestHGCMCallInfo *pCallInfo,
+                              VBGLHGCMCALLBACK *pAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData);
 
 #else /* !VBGL_VBOXGUEST */

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

@@ -993 +993 @@
         case VBOXGUEST_IOCTL_HGCM_CALL(0): /* (The size isn't relevant on NT.) */
         {
+            int rc;
+
             dprintf(("VBoxGuest::VBoxGuestDeviceControl: VBOXGUEST_IOCTL_HGCM_CALL\n"));
 
@@ -1006 +1008 @@
             VBoxGuestHGCMCallInfo *ptr = (VBoxGuestHGCMCallInfo *)pBuf;
 
-            int rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
+# if ARCH_BITS == 64
+            if (IoIs32bitProcess(pIrp))
+                rc = VbglHGCMCall32(ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
+            else
+# endif
+                rc = VbglHGCMCall (ptr, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
 
             if (RT_FAILURE(rc))
@@ -1019 +1026 @@
 
         } break;
-
-#if defined(VBOX_WITH_64_BITS_GUESTS) && ARCH_BITS == 64
-        case VBOXGUEST_IOCTL_HGCM_CALL_32(0): /* (The size isn't relevant on NT.) */
-        {
-            dprintf(("VBoxGuest::VBoxGuestDeviceControl: VBOXGUEST_IOCTL_HGCM_CALL_32\n"));
-
-            Status = vboxHGCMVerifyIOBuffers (pStack,
-                                              sizeof (VBoxGuestHGCMCallInfo));
-
-            if (Status != STATUS_SUCCESS)
-            {
-                dprintf(("VBoxGuest::VBoxGuestDeviceControl: invalid parameter. Status: %p\n", Status));
-                break;
-            }
-
-            VBoxGuestHGCMCallInfo *ptr32 = (VBoxGuestHGCMCallInfo *)pBuf;
-            VBoxGuestHGCMCallInfo *ptr64;
-
-            unsigned cbPtr32 = sizeof(*ptr32)+ptr32->cParms*sizeof(HGCMFunctionParameter32);
-            unsigned cbPtr64 = sizeof(*ptr32)+ptr32->cParms*sizeof(HGCMFunctionParameter);
-
-            /*@todo r=Leonid, same should be applied to case VBOXGUEST_IOCTL_HGCM_CALL(0) as well,
-             * because vboxHGCMVerifyIOBuffers, checks for sizeof (VBoxGuestHGCMCallInfo) only.
-             */
-            if (pStack->Parameters.DeviceIoControl.InputBufferLength < cbPtr32)
-            {
-                dprintf(("VBoxGuest::vboxHGCMVerifyIOBuffers: InputBufferLength %d < %d\n",
-                        pStack->Parameters.DeviceIoControl.InputBufferLength, cbPtr32));
-                Status = STATUS_INVALID_PARAMETER;
-                break;
-            }
-
-            ptr64 = (VBoxGuestHGCMCallInfo *) RTMemTmpAlloc(cbPtr64);
-
-            if (!ptr64)
-            {
-                dprintf(("VBoxGuest::VBoxGuestDeviceControl: No memory\n"));
-                Status = STATUS_UNSUCCESSFUL;
-                break;      
-            }
-
-            /*copy 32bit call info into 64bit*/
-            {
-                unsigned iParm;
-                HGCMFunctionParameter   *pParm64;
-                HGCMFunctionParameter32 *pParm32;
-
-                /*copy header*/
-                memcpy(ptr64, ptr32, sizeof(VBoxGuestHGCMCallInfo));
-
-                pParm64 = VBOXGUEST_HGCM_CALL_PARMS(ptr64);
-                pParm32 = (HGCMFunctionParameter32*) VBOXGUEST_HGCM_CALL_PARMS(ptr32);
-
-                for (iParm = 0; iParm < ptr32->cParms; ++iParm)
-                {
-                    pParm64->type = pParm32->type;
-                    
-                    switch(pParm64->type)
-                    {
-                        case VMMDevHGCMParmType_PhysAddr:
-                            pParm64->u.Pointer.size = pParm32->u.Pointer.size;
-                            pParm64->u.Pointer.u.physAddr = pParm32->u.Pointer.u.physAddr;
-                            break;
-                        case VMMDevHGCMParmType_LinAddr:
-                        case VMMDevHGCMParmType_LinAddr_In:
-                        case VMMDevHGCMParmType_LinAddr_Out:
-                        case VMMDevHGCMParmType_LinAddr_Locked:
-                        case VMMDevHGCMParmType_LinAddr_Locked_In:
-                        case VMMDevHGCMParmType_LinAddr_Locked_Out:
-                            pParm64->u.Pointer.size = pParm32->u.Pointer.size;
-                            pParm64->u.Pointer.u.linearAddr = pParm32->u.Pointer.u.linearAddr;
-                            break;
-                        case VMMDevHGCMParmType_32bit:
-                            pParm64->u.value32 = pParm32->u.value32;
-                            break;
-                        case VMMDevHGCMParmType_64bit:
-                            pParm64->u.value64 = pParm32->u.value64;
-                            break;
-                        default:
-                            Status = STATUS_UNSUCCESSFUL;
-                            break;
-                    }
-
-                    ++pParm32;
-                    ++pParm64;
-                }
-
-                if (Status != STATUS_SUCCESS)
-                {
-                    dprintf(("VBoxGuest::VBoxGuestDeviceControl: invalid parameter. Status: %p\n", Status));
-                    break;
-                }
-            }
-
-            int rc = VbglHGCMCall (ptr64, VBoxHGCMCallback, pDevExt, RT_INDEFINITE_WAIT);
-
-            if (RT_FAILURE(rc))
-            {
-                dprintf(("VBOXGUEST_IOCTL_HGCM_CALL: vbox rc = %Rrc\n", rc));
-                Status = STATUS_UNSUCCESSFUL;
-            }
-            else
-            {
-                cbOut = pStack->Parameters.DeviceIoControl.OutputBufferLength;
-            }
-
-            /*copy results back*/
-            {
-                unsigned iParm;
-                HGCMFunctionParameter   *pParm64;
-                HGCMFunctionParameter32 *pParm32;
-
-                /*copy header*/
-                memcpy(ptr32, ptr64, sizeof(VBoxGuestHGCMCallInfo));
-
-                pParm64 = VBOXGUEST_HGCM_CALL_PARMS(ptr64);
-                pParm32 = (HGCMFunctionParameter32*) VBOXGUEST_HGCM_CALL_PARMS(ptr32);
-
-                /*@todo r=Leonid, FIXME: I think pointer values couldn't change but not sure so better play it safe*/
-                for (iParm = 0; iParm < ptr32->cParms; ++iParm)
-                {
-                    pParm32->type = pParm64->type;
-                    
-                    switch(pParm64->type)
-                    {
-                        case VMMDevHGCMParmType_PhysAddr:
-                            pParm32->u.Pointer.size = pParm64->u.Pointer.size;
-                            pParm32->u.Pointer.u.physAddr = pParm64->u.Pointer.u.physAddr;
-                            break;
-                        case VMMDevHGCMParmType_LinAddr:
-                        case VMMDevHGCMParmType_LinAddr_In:
-                        case VMMDevHGCMParmType_LinAddr_Out:
-                        case VMMDevHGCMParmType_LinAddr_Locked:
-                        case VMMDevHGCMParmType_LinAddr_Locked_In:
-                        case VMMDevHGCMParmType_LinAddr_Locked_Out:
-                            pParm32->u.Pointer.size = pParm64->u.Pointer.size;
-                            pParm32->u.Pointer.u.linearAddr = pParm64->u.Pointer.u.linearAddr;
-                            break;
-                        case VMMDevHGCMParmType_32bit:
-                            pParm32->u.value32 = pParm64->u.value32;
-                            break;
-                        case VMMDevHGCMParmType_64bit:
-                            pParm32->u.value64 = pParm64->u.value64;
-                            break;
-                        default:
-                            Status = STATUS_UNSUCCESSFUL;
-                            break;
-                    }
-
-                    ++pParm32;
-                    ++pParm64;
-                }
-
-                if (Status != STATUS_SUCCESS)
-                {
-                    dprintf(("VBoxGuest::VBoxGuestDeviceControl: invalid parameter. Status: %p\n", Status));
-                    break;
-                }
-            }
-
-            RTMemTmpFree(ptr64);
-
-        } break;
-#endif
 
         case VBOXGUEST_IOCTL_HGCM_CALL_TIMED(0): /* (The size isn't relevant on NT.) */

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

@@ -286 +286 @@
     return rc;
 }
+# if ARCH_BITS == 64
+DECLVBGL(int) VbglHGCMCall32 (VBoxGuestHGCMCallInfo *pCallInfo,
+                              VBGLHGCMCALLBACK *pAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData)
+{
+    VMMDevHGCMCall *pHGCMCall;
+    uint32_t cbParms;
+    HGCMFunctionParameter32 *pParm;
+    unsigned iParm;
+    int rc;
+
+    if (!pCallInfo || !pAsyncCallback || pCallInfo->cParms > VBOX_HGCM_MAX_PARMS)
+    {
+        AssertFailed();
+        return VERR_INVALID_PARAMETER;
+    }
+
+    Log (("VbglHGCMCall: pCallInfo->cParms = %d, pHGCMCall->u32Function = %d\n", pCallInfo->cParms, pCallInfo->u32Function));
+
+    pHGCMCall = NULL;
+
+    cbParms = pCallInfo->cParms * sizeof (HGCMFunctionParameter32);
+
+    /* Allocate request */
+    rc = VbglGRAlloc ((VMMDevRequestHeader **)&pHGCMCall, sizeof (VMMDevHGCMCall) + cbParms, VMMDevReq_HGCMCall32);
+
+    Log (("VbglHGCMCall Allocated gr %p, rc = %Rrc, cbParms = %d\n", pHGCMCall, rc, cbParms));
+
+    if (RT_SUCCESS(rc))
+    {
+        void *apvCtx[VBOX_HGCM_MAX_PARMS];
+        memset (apvCtx, 0, sizeof(void *) * pCallInfo->cParms);
+
+        /* Initialize request memory */
+        pHGCMCall->header.fu32Flags = 0;
+        pHGCMCall->header.result    = VINF_SUCCESS;
+
+        pHGCMCall->u32ClientID = pCallInfo->u32ClientID;
+        pHGCMCall->u32Function = pCallInfo->u32Function;
+        pHGCMCall->cParms      = pCallInfo->cParms;
+
+        if (cbParms)
+        {
+            /* Lock user buffers. */
+            pParm = VBOXGUEST_HGCM_CALL_PARMS32(pCallInfo);
+
+            for (iParm = 0; iParm < pCallInfo->cParms; iParm++, pParm++)
+            {
+                switch (pParm->type)
+                {
+                case VMMDevHGCMParmType_LinAddr_Locked_In:
+                    pParm->type = VMMDevHGCMParmType_LinAddr_In;
+                    break;
+                case VMMDevHGCMParmType_LinAddr_Locked_Out:
+                    pParm->type = VMMDevHGCMParmType_LinAddr_Out;
+                    break;
+                case VMMDevHGCMParmType_LinAddr_Locked:
+                    pParm->type = VMMDevHGCMParmType_LinAddr;
+                    break;
+
+                case VMMDevHGCMParmType_LinAddr_In:
+                case VMMDevHGCMParmType_LinAddr_Out:
+                case VMMDevHGCMParmType_LinAddr:
+                    /* PORTME: When porting this to Darwin and other systems where the entire kernel isn't mapped
+                       into every process, all linear address will have to be converted to physical SG lists at
+                       this point. Care must also be taken on these guests to not mix kernel and user addresses
+                       in HGCM calls, or we'll end up locking the wrong memory. If VMMDev/HGCM gets a linear address
+                       it will assume that it's in the current memory context (i.e. use CR3 to translate it).
+
+                       These kind of problems actually applies to some patched linux kernels too, including older
+                       fedora releases. (The patch is the infamous 4G/4G patch, aka 4g4g, by Ingo Molnar.) */
+                    rc = vbglLockLinear (&apvCtx[iParm], (void *)pParm->u.Pointer.u.linearAddr, pParm->u.Pointer.size, (pParm->type == VMMDevHGCMParmType_LinAddr_In) ? false : true /* write access */);
+                    break;
+                default:
+                    /* make gcc happy */
+                    break;
+                }
+                if (RT_FAILURE (rc))
+                    break;
+            }
+            memcpy (VMMDEV_HGCM_CALL_PARMS32(pHGCMCall), VBOXGUEST_HGCM_CALL_PARMS32(pCallInfo), cbParms);
+        }
+
+        /* Check that the parameter locking was ok. */
+        if (RT_SUCCESS(rc))
+        {
+            Log (("calling VbglGRPerform\n"));
+
+            /* Issue request */
+            rc = VbglGRPerform (&pHGCMCall->header.header);
+
+            Log (("VbglGRPerform rc = %Rrc (header rc=%d)\n", rc, pHGCMCall->header.result));
+
+            /** If the call failed, but as a result of the request itself, then pretend success
+             *  Upper layers will interpret the result code in the packet.
+             */
+            if (RT_FAILURE(rc) && rc == pHGCMCall->header.result)
+            {
+                Assert(pHGCMCall->header.fu32Flags & VBOX_HGCM_REQ_DONE);
+                rc = VINF_SUCCESS;
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                /* Check if host decides to process the request asynchronously. */
+                if (rc == VINF_HGCM_ASYNC_EXECUTE)
+                {
+                    /* Wait for request completion interrupt notification from host */
+                    Log (("Processing HGCM call asynchronously\n"));
+                    pAsyncCallback (&pHGCMCall->header, pvAsyncData, u32AsyncData);
+                }
+
+                if (pHGCMCall->header.fu32Flags & VBOX_HGCM_REQ_DONE)
+                {
+                    if (cbParms)
+                        memcpy (VBOXGUEST_HGCM_CALL_PARMS32(pCallInfo), VMMDEV_HGCM_CALL_PARMS32(pHGCMCall), cbParms);
+
+                    pCallInfo->result = pHGCMCall->header.result;
+                }
+                else
+                {
+                    /* The callback returns without completing the request,
+                     * that means the wait was interrrupted. That can happen
+                     * if the request times out, the system reboots or the
+                     * VBoxService ended abnormally.
+                     *
+                     * Cancel the request, the host will not write to the
+                     * memory related to the cancelled request.
+                     */
+                    Log (("Cancelling HGCM call\n"));
+                    pHGCMCall->header.fu32Flags |= VBOX_HGCM_REQ_CANCELLED;
+
+                    pHGCMCall->header.header.requestType = VMMDevReq_HGCMCancel;
+                    VbglGRPerform (&pHGCMCall->header.header);
+                }
+            }
+        }
+
+        /* Unlock user buffers. */
+        pParm = VBOXGUEST_HGCM_CALL_PARMS32(pCallInfo);
+
+        for (iParm = 0; iParm < pCallInfo->cParms; iParm++, pParm++)
+        {
+            if (   pParm->type == VMMDevHGCMParmType_LinAddr_In
+                || pParm->type == VMMDevHGCMParmType_LinAddr_Out
+                || pParm->type == VMMDevHGCMParmType_LinAddr)
+            {
+                if (apvCtx[iParm] != NULL)
+                {
+                    vbglUnlockLinear (apvCtx[iParm], (void *)pParm->u.Pointer.u.linearAddr, pParm->u.Pointer.size);
+                }
+            }
+            else
+                Assert(!apvCtx[iParm]);
+        }
+
+        if ((pHGCMCall->header.fu32Flags & VBOX_HGCM_REQ_CANCELLED) == 0)
+            VbglGRFree (&pHGCMCall->header.header);
+        else
+            rc = VERR_INTERRUPTED;
+    }
+
+    return rc;
+}
+# endif /* ARCH_BITS == 64 */
 
 #endif /* VBGL_VBOXGUEST */