Changeset 38592 in vbox for trunk/src/VBox/Additions/common

Timestamp:

Aug 31, 2011 8:45:29 PM (14 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

73787

Message:

Additions/common/VBoxGuest: mediate SET_MOUSE_STATUS in the kernel module

Location:

trunk/src/VBox/Additions/common

Files:

• VBoxGuest/VBoxGuest.cpp (modified) (5 diffs)
• VBoxGuest/VBoxGuestInternal.h (modified) (4 diffs)
• VBoxGuestLib/VBoxGuestR3LibMouse.cpp (modified) (1 diff)

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

@@ -56 +56 @@
 #ifdef VBOX_WITH_HGCM
 static DECLCALLBACK(int) VBoxGuestHGCMAsyncWaitCallback(VMMDevHGCMRequestHeader *pHdrNonVolatile, void *pvUser, uint32_t u32User);
+#endif
+#ifdef DEBUG
+static void testSetMouseStatus(void);
 #endif
 
@@ -789 +792 @@
                         vboxGuestInitFixateGuestMappings(pDevExt);
 
+#ifdef DEBUG
+                        testSetMouseStatus();  /* Other tests? */
+#endif
+
                         rc = VBoxGuestReportDriverStatus(true /* Driver is active */);
                         if (RT_FAILURE(rc))
@@ -2068 +2075 @@
 }
 #endif /* VBOX_WITH_VRDP_SESSION_HANDLING */
+
+#ifdef DEBUG
+/** Unit test SetMouseStatus instead of really executing the request. */
+static bool     g_test_fSetMouseStatus = false;
+/** When unit testing SetMouseStatus, the fake RC for the GR to return. */
+static int      g_test_SetMouseStatusGRRC;
+/** When unit testing SetMouseStatus this will be set to the status passed to
+ * the GR. */
+static uint32_t g_test_statusSetMouseStatus;
+#endif
+
+static int vboxguestcommonSetMouseStatus(uint32_t fFeatures)
+{
+    VMMDevReqMouseStatus *pReq;
+    int rc;
+
+    LogRelFlowFunc(("fFeatures=%u\n", (int) fFeatures));
+    rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, sizeof(*pReq), VMMDevReq_SetMouseStatus);
+    if (RT_SUCCESS(rc))
+    {
+        pReq->mouseFeatures = fFeatures;
+        pReq->pointerXPos = 0;
+        pReq->pointerYPos = 0;
+#ifdef DEBUG
+        if (g_test_fSetMouseStatus)
+        {
+            g_test_statusSetMouseStatus = pReq->mouseFeatures;
+            rc = g_test_SetMouseStatusGRRC;
+        }
+        else
+#endif
+            rc = VbglGRPerform(&pReq->header);
+        VbglGRFree(&pReq->header);
+    }
+    LogRelFlowFunc(("rc=%Rrc\n", rc));
+    return rc;
+}
+
+
+/**
+ * Sets the mouse status features for this session and updates them globally.
+ *
+ * @returns VBox status code.
+ *
+ * @param   pDevExt             The device extention.
+ * @param   pSession            The session.
+ * @param   fFeatures           New bitmap of enabled features.
+ */
+static int VBoxGuestCommonIOCtl_SetMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fFeatures)
+{
+    unsigned i;
+    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
+    uint32_t fNewDevExtStatus = 0;
+    int rc;
+
+    RTSpinlockAcquireNoInts(pDevExt->SessionSpinlock, &Tmp);
+    for (i = 0; i < sizeof(fFeatures) * 8; ++i)
+    {
+        if (RT_BIT_32(i) & VMMDEV_MOUSE_GUEST_MASK)
+        {
+            if (   (RT_BIT_32(i) & fFeatures)
+                && !(RT_BIT_32(i) & pSession->fMouseStatus))
+                ++pDevExt->cMouseFeatureUsage[i];
+            else if (   !(RT_BIT_32(i) & fFeatures)
+                     && (RT_BIT_32(i) & pSession->fMouseStatus))
+                --pDevExt->cMouseFeatureUsage[i];
+        }
+        if (pDevExt->cMouseFeatureUsage[i] > 0)
+            fNewDevExtStatus |= RT_BIT_32(i);
+    }
+    pSession->fMouseStatus = fFeatures & VMMDEV_MOUSE_GUEST_MASK;
+    pDevExt->fMouseStatus = fNewDevExtStatus;
+    RTSpinlockReleaseNoInts(pDevExt->SessionSpinlock, &Tmp);
+    do
+    {
+        fNewDevExtStatus = pDevExt->fMouseStatus;
+        rc = vboxguestcommonSetMouseStatus(fNewDevExtStatus);
+    } while(RT_SUCCESS(rc) && fNewDevExtStatus != pDevExt->fMouseStatus);
+    return rc;
+}
+
+
+#ifdef DEBUG
+/** Unit test for the SET_MOUSE_STATUS IoCtl.  Since this is closely tied to
+ * the code in question it probably makes most sense to keep it next to the
+ * code. */
+static void testSetMouseStatus(void)
+{
+    int cFailures = 0;
+    uint32_t u32Data;
+    int rc;
+    RTSPINLOCK Spinlock;
+
+    g_test_fSetMouseStatus = true;
+    rc = RTSpinlockCreate(&Spinlock);
+    AssertRCReturnVoid(rc);
+    {
+        VBOXGUESTDEVEXT  DevExt  = { 0 };
+        VBOXGUESTSESSION Session = { 0 };
+
+        g_test_statusSetMouseStatus = ~0;
+        g_test_SetMouseStatusGRRC = VINF_SUCCESS;
+        DevExt.SessionSpinlock = Spinlock;
+        u32Data = VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertRCSuccess(rc);
+        AssertMsg(   g_test_statusSetMouseStatus
+                  == VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE,
+                  ("Actual status: 0x%x\n", g_test_statusSetMouseStatus));
+        DevExt.cMouseFeatureUsage[ASMBitFirstSetU32(VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR) - 1] = 1;
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertRCSuccess(rc);
+        AssertMsg(   g_test_statusSetMouseStatus
+                  == (  VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
+                      | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR),
+                  ("Actual status: 0x%x\n", g_test_statusSetMouseStatus));
+        u32Data = VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE;  /* Can't change this */
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertRCSuccess(rc);
+        AssertMsg(   g_test_statusSetMouseStatus
+                  == VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR,
+                  ("Actual status: 0x%x\n", g_test_statusSetMouseStatus));
+        u32Data = VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR;
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertRCSuccess(rc);
+        AssertMsg(   g_test_statusSetMouseStatus
+                  == VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR,
+                  ("Actual status: 0x%x\n", g_test_statusSetMouseStatus));
+        u32Data = 0;
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertRCSuccess(rc);
+        AssertMsg(   g_test_statusSetMouseStatus
+                  == VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR,
+                  ("Actual status: 0x%x\n", g_test_statusSetMouseStatus));
+        AssertMsg(DevExt.cMouseFeatureUsage[ASMBitFirstSetU32(VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR) - 1] == 1,
+                  ("Actual value: %d\n", DevExt.cMouseFeatureUsage[ASMBitFirstSetU32(VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR)]));
+        g_test_SetMouseStatusGRRC = VERR_UNRESOLVED_ERROR;
+        rc = VBoxGuestCommonIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &DevExt,
+                                  &Session, &u32Data, sizeof(u32Data), NULL);
+        AssertMsg(rc == VERR_UNRESOLVED_ERROR, ("rc == %Rrc\n", rc));
+        /* Untested paths: out of memory; race setting status to host */
+   }
+    RTSpinlockDestroy(Spinlock);
+    g_test_fSetMouseStatus = false;
+}
+#endif
 
 
@@ -2144 +2302 @@
         } \
     } while (0)
+#define CHECKRET_SIZE(mnemonic, cb) \
+    do { \
+        if (cbData != (cb)) \
+        { \
+            LogFunc((mnemonic ": cbData=%#zx (%zu) expected is %#zx (%zu)\n", \
+                 cbData, cbData, (size_t)(cb), (size_t)(cb))); \
+            return VERR_BUFFER_OVERFLOW; \
+        } \
+        if ((cb) != 0 && !VALID_PTR(pvData)) \
+        { \
+            LogFunc((mnemonic ": Invalid pointer %p\n", pvData)); \
+            return VERR_INVALID_POINTER; \
+        } \
+    } while (0)
 
 
@@ -2275 +2447 @@
                 break;
 #endif /* VBOX_WITH_VRDP_SESSION_HANDLING */
+            case VBOXGUEST_IOCTL_SET_MOUSE_STATUS:
+                CHECKRET_SIZE("SET_MOUSE_STATUS", sizeof(uint32_t));
+                rc = VBoxGuestCommonIOCtl_SetMouseStatus(pDevExt, pSession,
+                                                         *(uint32_t *)pvData);
+                break;
 
             default:

trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h

@@ -154 +154 @@
     /** Memory balloon information for RTR0MemObjAllocPhysNC(). */
     VBOXGUESTMEMBALLOON         MemBalloon;
+    /** For each mouse status feature the number of sessions which have
+     * enabled it.  A feature is enabled globally if at least one session has
+     * requested it. */
+    /** @todo can we programmatically determine the size of the array and
+     * still get the following alignment right? */
+    uint32_t volatile           cMouseFeatureUsage[32];
+    /** The mouse feature status matching the counts above.  These are updated
+     * together inside the session spinlock. */
+    uint32_t volatile           fMouseStatus;
     /** Align the next bit on a 64-byte boundary and make sure it starts at the same
      *  offset in both 64-bit and 32-bit builds.
@@ -162 +171 @@
      *          following it (to grow into and align the struct size).
      */
-    uint8_t abAlignment1[HC_ARCH_BITS == 32 ? 24 : 4];
+    uint8_t abAlignment1[HC_ARCH_BITS == 32 ? 20 : 0];
 
     /** Windows part. */
@@ -177 +186 @@
 typedef VBOXGUESTDEVEXT *PVBOXGUESTDEVEXT;
 
+AssertCompileMemberSizeAlignment(VBOXGUESTDEVEXT, win, 64);
 
 /**
@@ -213 +223 @@
      * Used to implement polling.  */
     uint32_t volatile           u32MousePosChangedSeq;
+    /** Mouse features supported.  A feature enabled in any guest session will
+     * be enabled for the host. */
+    uint32_t volatile           fMouseStatus;
 
 } VBOXGUESTSESSION;

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

@@ -71 +71 @@
 VBGLR3DECL(int) VbglR3SetMouseStatus(uint32_t fFeatures)
 {
-    VMMDevReqMouseStatus Req;
-    vmmdevInitRequest(&Req.header, VMMDevReq_SetMouseStatus);
-    Req.mouseFeatures = fFeatures;
-    Req.pointerXPos = 0;
-    Req.pointerYPos = 0;
-    return vbglR3GRPerform(&Req.header);
+    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &fFeatures,
+                         sizeof(fFeatures));
 }