Changeset 75547 in vbox

Timestamp:

Nov 18, 2018 4:50:34 AM (6 years ago)

Author:

vboxsync

Message:

VBoxGuest: Added an IDC interface for faster HGCM calls (VBGL_IOCTL_IDC_HGCM_FAST_CALL, VbglR0HGCMFastCall). This expects the caller to construct a valid call and only concerns itself with issuing it to the host and waiting for the result to arrive. bugref:9172

Location:

trunk

Files:

• include/VBox/VBoxGuest.h (modified) (6 diffs)
• include/VBox/VBoxGuestLib.h (modified) (5 diffs)
• src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp (modified) (5 diffs)
• src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibHGCM.cpp (modified) (1 diff)
• src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibInternal.h (modified) (1 diff)

trunk/include/VBox/VBoxGuest.h

@@ -52 +52 @@
  *
  * - I/O controls for user and/or kernel mode starts at 0.
- * - IDC specific requests descends from 127.
+ * - IDC specific requests descends from 63.
  * - Bits 7 and 6 are currently reserved for future hacks.
  *
@@ -285 +285 @@
 /** @} */
 
-
 #ifdef VBOX_WITH_HGCM
+
 /** @name VBGL_IOCTL_HGCM_CONNECT
  * Connect to a HGCM service.
@@ -344 +344 @@
 /** @name VBGL_IOCTL_HGCM_CALL, VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA
  *
- * Make a call to a HGCM servicesure.  There are several variations here.
+ * Make a call to a HGCM service.  There are several variations here.
  *
  * The VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA variation is for other drivers (like
@@ -360 +360 @@
 # define VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA(a_cb)  VBGL_IOCTL_CODE_SIZE(8, (a_cb))
 /** @} */
+
+
+/** @name VBGL_IOCTL_IDC_HGCM_FAST_CALL
+ *
+ * Variant of VBGL_IOCTL_HGCM_CALL for drivers that submits the request as-is to
+ * the host and handles the waiting, the caller does all the rest.
+ *
+ * @note ring-0 only.
+ * @note Size is not encoded in the I/O control code.
+ * @{
+ */
+#define VBGL_IOCTL_IDC_HGCM_FAST_CALL               VBGL_IOCTL_CODE_SIZE(62, sizeof(VBGLIOCIDCHGCMFASTCALL))
+#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE(a_cb)    (a_cb)
+#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE_IN(a_cb) (a_cb)
+#define VBGL_IOCTL_IDC_HGCM_FAST_CALL_SIZE_OUT(a_cb) (a_cb)
+#pragma pack(4) /* Want it to fit nicely with the 44 byte VMMDevHGCMCall and optimally align 64-bit parameters structures.  */
+typedef struct VBGLIOCIDCHGCMFASTCALL
+{
+    /** The header. */
+    VBGLREQHDR      Hdr;
+    /** The physical address of the following VMMDevHGCMCall structure. */
+    RTGCPHYS32      GCPhysReq;
+    /** Set if interruptible. */
+    bool            fInterruptible;
+    /** Reserved. */
+    uint8_t         abReserved0[3];
+    uint64_t        uTimestamp[2];
+    uint8_t         abReserved1[4];
+    /* After this structure follows a VMMDevHGCMCall strcuture (44 bytes), then
+       zero or more HGCMFunctionParameter structures (12 or 16 bytes), and finally
+       page lists and embedded buffers. */
+} VBGLIOCIDCHGCMFASTCALL, RT_FAR *PVBGLIOCIDCHGCMFASTCALL;
+#pragma pack()
+AssertCompileSize(VBGLIOCIDCHGCMFASTCALL, /* 24 + 4 + 1 + 3 + 2*8 + 4 = 0x34 (52) = */ 0x34);
+
+/**
+ * Macro for initializing VBGLIOCIDCHGCMFASTCALL and the following
+ * VMMDevHGCMCall structures.
+ *
+ * @param   a_pHdr      The request header to initialize.
+ * @param   a_HdrPhys   The 32-bit physical address corresponding to @a a_pHdr.
+ * @param   a_pCall     Pointer to the VMMDevHGCMCall structure.
+ * @param   a_idClient  The HGCM client ID.
+ * @param   a_uFunction The HGCM function number.
+ * @param   a_cParms    The number of parameters following @a a_pCall.
+ * @param   a_cbReq     The size of the whole request.
+ */
+#define VBGLIOCIDCHGCMFASTCALL_INIT(a_pHdr, a_HdrPhys, a_pCall, a_idClient, a_uFunction, a_cParms, a_cbReq) \
+    do { \
+        Assert((uintptr_t)(a_pHdr) + sizeof(VBGLIOCIDCHGCMFASTCALL) == (uintptr_t)(a_pCall)); \
+        VBGLREQHDR_INIT_EX(&(a_pHdr)->Hdr, a_cbReq, a_cbReq); \
+        pReq->Hdr.GCPhysReq      = (a_HdrPhys) + sizeof(VBGLIOCIDCHGCMFASTCALL); \
+        pReq->Hdr.fInterruptible = false; \
+        \
+        (a_pCall)->header.header.size       = (a_cbReq) - sizeof(VBGLIOCIDCHGCMFASTCALL); \
+        (a_pCall)->header.header.version    = VBGLREQHDR_VERSION; \
+        (a_pCall)->header.header.requestType= (ARCH_BITS == 32 ? VMMDevReq_HGCMCall32 : VMMDevReq_HGCMCall64); \
+        (a_pCall)->header.header.rc         = VERR_INTERNAL_ERROR; \
+        (a_pCall)->header.header.reserved1  = 0; \
+        (a_pCall)->header.header.fRequestor = VMMDEV_REQUESTOR_KERNEL        | VMMDEV_REQUESTOR_USR_DRV_OTHER \
+                                            | VMMDEV_REQUESTOR_CON_DONT_KNOW | VMMDEV_REQUESTOR_TRUST_NOT_GIVEN; \
+        (a_pCall)->header.fu32Flags         = 0; \
+        (a_pCall)->header.result            = VERR_INTERNAL_ERROR; \
+        (a_pCall)->u32ClientID              = (a_idClient); \
+        (a_pCall)->u32Function              = (a_uFunction); \
+        (a_pCall)->cParms                   = (a_cParms); \
+    } while (0)
+
+
+/** @} */
+
 #endif /* VBOX_WITH_HGCM */
 
@@ -798 +869 @@
  *
  * @note ring-0 only.
+ * @{
  */
 #define VBGL_IOCTL_IDC_CONNECT                      VBGL_IOCTL_CODE_SIZE(63, VBGL_IOCTL_IDC_CONNECT_SIZE)
@@ -859 +931 @@
  *
  * @note ring-0 only.
+ * @{
  */
 #define VBGL_IOCTL_IDC_DISCONNECT                   VBGL_IOCTL_CODE_SIZE(62, VBGL_IOCTL_IDC_DISCONNECT_SIZE)

trunk/include/VBox/VBoxGuestLib.h

@@ -212 +212 @@
 # ifdef VBOX_WITH_HGCM
 struct VBGLIOCHGCMCALL;
+struct VBGLIOCIDCHGCMFASTCALL;
 
 #  ifdef VBGL_VBOXGUEST
@@ -325 +326 @@
 #  else  /* !VBGL_VBOXGUEST */
 
+#ifndef VBGL_VBOXGUEST
+/** @internal  */
+typedef struct VBGLHGCMHANDLEDATA
+{
+    uint32_t fAllocated;
+    VBGLIDCHANDLE IdcHandle;
+} VBGLHGCMHANDLEDATA;
+#else
 struct VBGLHGCMHANDLEDATA;
+#endif
+
 typedef struct VBGLHGCMHANDLEDATA *VBGLHGCMHANDLE;
 
@@ -382 +393 @@
  * @return VBox status code.
  */
-DECLR0VBGL(int) VbglR0HGCMCallRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
+DECLR0VBGL(int) VbglR0HGCMCallRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
 
 /**
@@ -394 +405 @@
  *         or the HGCM status code (pData->Hdr.rc).
  */
-DECLR0VBGL(int) VbglR0HGCMCall(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
+DECLR0VBGL(int) VbglR0HGCMCall(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
 
 /**
@@ -406 +417 @@
  * @return VBox status code.
  */
-DECLR0VBGL(int) VbglR0HGCMCallUserDataRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL*pData, uint32_t cbData);
+DECLR0VBGL(int) VbglR0HGCMCallUserDataRaw(VBGLHGCMHANDLE handle, struct VBGLIOCHGCMCALL *pData, uint32_t cbData);
+
+/**
+ * Call to a service, w/o any repacking and buffer locking in VBoxGuest,
+ * returning the only request related status code (not HGCM).
+ *
+ * The driver only submits the request and waits for completion, nothing else.
+ *
+ * @param   hHandle     The connection handle.
+ * @param   pCallReq    The call request.  Will be passed directly to the host.
+ * @param   cbCallReq   The size of the whole call request.
+ *
+ * @return VBox status code.
+ *
+ * @remarks The result of the HGCM call is found in
+ *          @a pCallReq->HgcmCallReq.header.result on a successful return.  The
+ *          @a pCallReq->Hdr.rc and @a pCallReq->HgcmCallReq.header.header.rc
+ *          fields are the same as the return value and can safely be ignored.
+ */
+DECLR0VBGL(int) VbglR0HGCMFastCall(VBGLHGCMHANDLE hHandle, struct VBGLIOCIDCHGCMFASTCALL *pCallReq, uint32_t cbCallReq);
 
 /** @} */

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

@@ -2729 +2729 @@
      * Some more validations.
      */
-    if (pInfo->cParms > 4096) /* (Just make sure it doesn't overflow the next check.) */
+    if (RT_LIKELY(pInfo->cParms <= VMMDEV_MAX_HGCM_PARMS)) /* (Just make sure it doesn't overflow the next check.) */
+    { /* likely */}
+    else
     {
         LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cParm=%RX32 is not sane\n", pInfo->cParms));
@@ -2742 +2744 @@
 #endif
         cbActual += pInfo->cParms * sizeof(HGCMFunctionParameter);
-    if (cbData < cbActual)
+    if (RT_LIKELY(cbData >= cbActual))
+    { /* likely */}
+    else
     {
         LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cbData=%#zx (%zu) required size is %#zx (%zu)\n",
@@ -2758 +2762 @@
             break;
     RTSpinlockRelease(pDevExt->SessionSpinlock);
-    if (RT_UNLIKELY(i >= RT_ELEMENTS(pSession->aHGCMClientIds)))
+    if (RT_LIKELY(i < RT_ELEMENTS(pSession->aHGCMClientIds)))
+    { /* likely */}
+    else
     {
         LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_CALL: Invalid handle. u32Client=%RX32\n", u32ClientId));
@@ -2818 +2824 @@
 }
 
+
+/**
+ * Handles a fast HGCM call from another driver.
+ *
+ * The driver has provided a fully assembled HGCM call request and all we need
+ * to do is send it to the host and do the wait processing.
+ *
+ * @returns VBox status code of the request submission part.
+ * @param   pDevExt     The device extension.
+ * @param   pCallReq    The call request.
+ */
+static int vgdrvIoCtl_HGCMFastCall(PVBOXGUESTDEVEXT pDevExt, VBGLIOCIDCHGCMFASTCALL volatile *pCallReq)
+{
+    VMMDevHGCMCall volatile *pHgcmCall = (VMMDevHGCMCall volatile *)(pCallReq + 1);
+    int rc;
+
+    /*
+     * Check out the physical address.
+     */
+    Assert((pCallReq->GCPhysReq & PAGE_OFFSET_MASK) == ((uintptr_t)pHgcmCall & PAGE_OFFSET_MASK));
+
+    AssertReturn(!pCallReq->fInterruptible, VERR_NOT_IMPLEMENTED);
+
+    /*
+     * Submit the request.
+     */
+    Log(("vgdrvIoCtl_HGCMFastCall -> host\n"));
+    ASMOutU32(pDevExt->IOPortBase + VMMDEV_PORT_OFF_REQUEST, (uint32_t)pCallReq->GCPhysReq);
+
+    /* Make the compiler aware that the host has changed memory. */
+    ASMCompilerBarrier();
+
+    pCallReq->Hdr.rc = rc = pHgcmCall->header.header.rc;
+    Log(("vgdrvIoCtl_HGCMFastCall -> %Rrc (header rc=%Rrc)\n", rc, pHgcmCall->header.result));
+
+    /*
+     * The host is likely to engage in asynchronous execution of HGCM, unless it fails.
+     */
+    if (rc == VINF_HGCM_ASYNC_EXECUTE)
+    {
+        rc = vgdrvHgcmAsyncWaitCallbackWorker(&pHgcmCall->header, pDevExt, false /* fInterruptible */, RT_INDEFINITE_WAIT);
+        if (pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_DONE)
+        {
+            Assert(!(pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_CANCELLED));
+            rc = VINF_SUCCESS;
+        }
+        else
+        {
+            /*
+             * Timeout and interrupt scenarios are messy and requires
+             * cancelation, so implement later.
+             */
+            AssertReleaseMsgFailed(("rc=%Rrc\n", rc));
+        }
+    }
+    else
+        Assert((pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_DONE) || RT_FAILURE_NP(rc));
+
+    Log(("vgdrvIoCtl_HGCMFastCall: rc=%Rrc result=%Rrc fu32Flags=%#x\n", rc, pHgcmCall->header.result, pHgcmCall->header.fu32Flags));
+    return rc;
+
+}
 
 #endif /* VBOX_WITH_HGCM */
@@ -4060 +4128 @@
         }
 #ifdef VBOX_WITH_HGCM
+        else if (iFunction == VBGL_IOCTL_IDC_HGCM_FAST_CALL) /* (is variable size, but we don't bother encoding it) */
+        {
+            REQ_CHECK_RING0("VBGL_IOCTL_IDC_HGCM_FAST_CALL");
+            REQ_CHECK_EXPR(VBGL_IOCTL_IDC_HGCM_FAST_CALL, cbReq >= sizeof(VBGLIOCIDCHGCMFASTCALL) + sizeof(VMMDevHGCMCall));
+            vgdrvIoCtl_HGCMFastCall(pDevExt, (VBGLIOCIDCHGCMFASTCALL volatile *)pReqHdr);
+        }
         else if (   iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL(0))
 # if ARCH_BITS == 64

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

@@ -231 +231 @@
 }
 
+
+DECLR0VBGL(int) VbglR0HGCMFastCall(VBGLHGCMHANDLE hHandle, PVBGLIOCIDCHGCMFASTCALL pCallReq, uint32_t cbCallReq)
+{
+    /* pCallReq->Hdr.rc and pCallReq->HgcmCallReq.header.header.rc; are not used by this IDC. */
+    return VbglR0IdcCallRaw(&hHandle->IdcHandle, VBGL_IOCTL_IDC_HGCM_FAST_CALL, &pCallReq->Hdr, cbCallReq);
+}
+

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibInternal.h

@@ -107 +107 @@
 typedef struct _VBGLPHYSHEAPCHUNK VBGLPHYSHEAPCHUNK;
 
-#ifndef VBGL_VBOXGUEST
-struct VBGLHGCMHANDLEDATA
-{
-    uint32_t fAllocated;
-    VBGLIDCHANDLE IdcHandle;
-};
-#endif
-
 enum VbglLibStatus
 {