Changeset 47572 in vbox for trunk/src/VBox

Timestamp:

Aug 7, 2013 9:51:45 AM (12 years ago)

Author:

vboxsync

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

87772

Message:

Runtime/threadctxhooks: RTThreadCtxHooksAreRegistered().

Location:

trunk/src/VBox

Files:

• HostDrivers/Support/SUPDrv.c (modified) (1 diff)
• Runtime/r0drv/generic/threadctxhooks-r0drv-generic.cpp (modified) (1 diff)
• Runtime/r0drv/linux/threadctxhooks-r0drv-linux.c (modified) (4 diffs)
• Runtime/r0drv/solaris/threadctxhooks-r0drv-solaris.c (modified) (3 diffs)
• Runtime/testcase/tstR0ThreadPreemption.cpp (modified) (6 diffs)

trunk/src/VBox/HostDrivers/Support/SUPDrv.c

@@ -367 +367 @@
     { "RTStrPrintfV",                           (void *)RTStrPrintfV },
     { "RTThreadCreate",                         (void *)RTThreadCreate },
+    { "RTThreadCtxHooksAreRegistered",          (void *)RTThreadCtxHooksAreRegistered },
     { "RTThreadCtxHooksCreate",                 (void *)RTThreadCtxHooksCreate },
     { "RTThreadCtxHooksDeregister",             (void *)RTThreadCtxHooksDeregister },

trunk/src/VBox/Runtime/r0drv/generic/threadctxhooks-r0drv-generic.cpp

@@ -75 +75 @@
 RT_EXPORT_SYMBOL(RTThreadCtxHooksDeregister);
 
+
+RTDECL(bool) RTThreadCtxHooksAreRegistered(RTTHREADCTX hThreadCtx)
+{
+    NOREF(hThreadCtx);
+    return false;
+}
+RT_EXPORT_SYMBOL(RTThreadCtxHooksAreRegistered);
+

trunk/src/VBox/Runtime/r0drv/linux/threadctxhooks-r0drv-linux.c

@@ -212 +212 @@
     PRTTHREADCTXINT pThis = hThreadCtx;
     if (pThis == NIL_RTTHREADCTX)
-        return VINF_SUCCESS;
+        return VERR_INVALID_HANDLE;
     AssertPtr(pThis);
     AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
@@ -242 +242 @@
     PRTTHREADCTXINT pThis = hThreadCtx;
     if (pThis == NIL_RTTHREADCTX)
-        return VINF_SUCCESS;
+        return VERR_INVALID_HANDLE;
     AssertPtr(pThis);
     AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
@@ -257 +257 @@
 RT_EXPORT_SYMBOL(RTThreadCtxHooksDeregister);
 
+
+RTDECL(bool) RTThreadCtxHooksAreRegistered(RTTHREADCTX hThreadCtx)
+{
+    /*
+     * Validate input.
+     */
+    PRTTHREADCTXINT pThis = hThreadCtx;
+    if (pThis == NIL_RTTHREADCTX)
+        return false;
+    AssertPtr(pThis);
+    AssertMsg(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis));
+
+    return pThis->fRegistered;
+}
+
 #else    /* Not supported / Not needed */
 
@@ -300 +315 @@
 RT_EXPORT_SYMBOL(RTThreadCtxHooksDeregister);
 
+
+RTDECL(bool) RTThreadCtxHooksAreRegistered(RTTHREADCTX hThreadCtx)
+{
+    NOREF(hThreadCtx);
+    return false;
+}
+RT_EXPORT_SYMBOL(RTThreadCtxHooksAreRegistered);
+
 #endif   /* Not supported / Not needed */
 

trunk/src/VBox/Runtime/r0drv/solaris/threadctxhooks-r0drv-solaris.c

@@ -281 +281 @@
     PRTTHREADCTXINT pThis = hThreadCtx;
     if (pThis == NIL_RTTHREADCTX)
-        return VINF_SUCCESS;
+        return VERR_INVALID_HANDLE;
     AssertPtr(pThis);
     AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
@@ -305 +305 @@
     PRTTHREADCTXINT pThis = hThreadCtx;
     if (pThis == NIL_RTTHREADCTX)
-        return VINF_SUCCESS;
+        return VERR_INVALID_HANDLE;
     AssertPtr(pThis);
     AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
@@ -320 +320 @@
 }
 
+
+RTDECL(bool) RTThreadCtxHooksAreRegistered(RTTHREADCTX hThreadCtx)
+{
+    /*
+     * Validate input.
+     */
+    PRTTHREADCTXINT pThis = hThreadCtx;
+    if (pThis == NIL_RTTHREADCTX)
+        return false;
+    AssertPtr(pThis);
+    AssertMsg(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis));
+
+    return pThis->fRegistered;
+}
+

trunk/src/VBox/Runtime/testcase/tstR0ThreadPreemption.cpp

@@ -299 +299 @@
             }
 
+            bool fRegistered = RTThreadCtxHooksAreRegistered(NIL_RTTHREADCTX);
+            if (fRegistered)
+            {
+                RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksAreRegistered returns true before creating any hooks");
+                break;
+            }
+
             RTTHREADCTX hThreadCtx;
             int rc = RTThreadCtxHooksCreate(&hThreadCtx);
@@ -307 +314 @@
                 else
                     RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksCreate returns %Rrc", rc);
+                break;
+            }
+
+            fRegistered = RTThreadCtxHooksAreRegistered(hThreadCtx);
+            if (fRegistered)
+            {
+                RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksAreRegistered returns true before registering any hooks");
+                RTThreadCtxHooksRelease(hThreadCtx);
                 break;
             }
@@ -330 +345 @@
             if (RT_FAILURE(rc))
             {
+                RTThreadPreemptRestore(&PreemptState);
                 RTMemFree(pCtxData);
                 RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksRegister returns %Rrc", rc);
@@ -335 +351 @@
             }
 
+            fRegistered = RTThreadCtxHooksAreRegistered(hThreadCtx);
+            if (!fRegistered)
+            {
+                RTThreadPreemptRestore(&PreemptState);
+                RTMemFree(pCtxData);
+                RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksAreRegistered return false when hooks are supposedly registered");
+                break;
+            }
+
             RTThreadPreemptRestore(&PreemptState);
 
             /* Check if the preempting callback has/will been invoked. */
-            const uint32_t  cMsTimeout           = 8000;
+            const uint32_t  cMsTimeout           = 10000;
             const uint32_t  cMsSleepGranularity  = 50;
             uint32_t        cMsSlept             = 0;
+            RTCPUID         uCurrentCpuId        = NIL_RTCPUID;
             for (;;)
             {
                 RTThreadPreemptDisable(&PreemptState);
-                const RTCPUID uCurrentCpuId = RTMpCpuId();
+                uCurrentCpuId = RTMpCpuId();
                 RTThreadPreemptRestore(&PreemptState);
 
@@ -359 +385 @@
             if (!ASMAtomicReadBool(&pCtxData->fPreemptingInvoked))
             {
-                RTStrPrintf(pszErr, cchErr, "!tstR0ThreadCtxHooks[RTTHREADCTXEVENT_PREEMPTING] not invoked after ca. %u ms",
-                            cMsSlept);
+                if (pCtxData->uSourceCpuId != uCurrentCpuId)
+                {
+                    RTStrPrintf(pszErr, cchErr,
+                                "!tstR0ThreadCtxHooks[RTTHREADCTXEVENT_PREEMPTING] not invoked before migrating from CPU %RU32 to %RU32",
+                                pCtxData->uSourceCpuId, uCurrentCpuId);
+                }
+                else
+                {
+                    RTStrPrintf(pszErr, cchErr, "!tstR0ThreadCtxHooks[RTTHREADCTXEVENT_PREEMPTING] not invoked after ca. %u ms",
+                                cMsSlept);
+                }
             }
             else if (!pCtxData->fPreemptingSuccess)
@@ -391 +426 @@
             RTThreadCtxHooksDeregister(hThreadCtx);
 
+            fRegistered = RTThreadCtxHooksAreRegistered(hThreadCtx);
+            if (fRegistered)
+            {
+                RTMemFree(pCtxData);
+                RTStrPrintf(pszErr, cchErr, "!RTThreadCtxHooksAreRegistered return true when hooks are deregistered");
+                break;
+            }
+
             Assert(RTThreadPreemptIsEnabled(NIL_RTTHREAD));
             uint32_t cRefs = RTThreadCtxHooksRelease(hThreadCtx);