Changeset 92792 in vbox for trunk/src/VBox/Runtime/nt

Timestamp:

Dec 7, 2021 9:49:10 PM (3 years ago)

Author:

vboxsync

Message:

IPRT/semevent-nt: Converted semevent-r0drv-nt.cpp into something that works both in ring-3 and ring-0. Enabled the tstRTSemEvent testcase. bugref:10138

File:

• trunk/src/VBox/Runtime/nt/semevent-nt.cpp (moved) (moved from trunk/src/VBox/Runtime/r0drv/nt/semevent-r0drv-nt.cpp ) (14 diffs)

trunk/src/VBox/Runtime/nt/semevent-nt.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT -  Single Release Event Semaphores, Ring-0 Driver, NT.
+ * IPRT -  Single Release Event Semaphores, Ring-0 Driver & Ring-3 Userland, NT.
  */
 
@@ -30 +30 @@
 *********************************************************************************************************************************/
 #define RTSEMEVENT_WITHOUT_REMAPPING
-#include "the-nt-kernel.h"
+#ifdef IN_RING0
+# include "../r0drv/nt/the-nt-kernel.h"
+#else
+# include <iprt/nt/nt.h>
+#endif
 #include <iprt/semaphore.h>
 
@@ -40 +44 @@
 #include <iprt/time.h>
 #include <iprt/timer.h>
-
+#ifdef IN_RING3
+# include <iprt/system.h>
+#endif
 #include "internal/magics.h"
 
@@ -56 +62 @@
     /** Reference counter. */
     uint32_t volatile   cRefs;
-    /** The NT Event object. */
+#ifdef IN_RING0
+    /** The NT event object. */
     KEVENT              Event;
+#elif defined(IN_RING3)
+    /** Handle to the NT event object. */
+    HANDLE              hEvent;
+#else
+# error "Unknown context"
+#endif
+#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3)
+    /** Signallers. */
+    RTLOCKVALRECSHRD    Signallers;
+    /** Indicates that lock validation should be performed. */
+    bool volatile       fEverHadSignallers;
+#endif
+
 } RTSEMEVENTINTERNAL, *PRTSEMEVENTINTERNAL;
 
@@ -72 +92 @@
     Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
     AssertCompile(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
-    RT_NOREF2(hClass, pszNameFmt);
 
     PRTSEMEVENTINTERNAL pThis = (PRTSEMEVENTINTERNAL)RTMemAlloc(sizeof(*pThis));
@@ -79 +98 @@
         pThis->u32Magic = RTSEMEVENT_MAGIC;
         pThis->cRefs    = 1;
+#ifdef IN_RING0
         KeInitializeEvent(&pThis->Event, SynchronizationEvent, FALSE /* not signalled */);
-
-        *phEventSem = pThis;
-        return VINF_SUCCESS;
+#else
+        NTSTATUS rcNt = NtCreateEvent(&pThis->hEvent, EVENT_ALL_ACCESS, NULL /*pObjAttr*/,
+                                      SynchronizationEvent, FALSE /*not signalled*/);
+        if (NT_SUCCESS(rcNt))
+#endif
+        {
+#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3)
+            if (!pszNameFmt)
+            {
+                static uint32_t volatile s_iSemEventAnon = 0;
+                RTLockValidatorRecSharedInit(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
+                                             true /*fSignaller*/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL),
+                                             "RTSemEvent-%u", ASMAtomicIncU32(&s_iSemEventAnon) - 1);
+            }
+            else
+            {
+                va_list va;
+                va_start(va, pszNameFmt);
+                RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
+                                              true /*fSignaller*/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL),
+                                              pszNameFmt, va);
+                va_end(va);
+            }
+            pThis->fEverHadSignallers = false;
+#else
+            RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt);
+#endif
+            *phEventSem = pThis;
+            return VINF_SUCCESS;
+        }
+#ifdef IN_RING3
+        RTMemFree(pThis);
+        return RTErrConvertFromNtStatus(rcNt);
+#endif
     }
     return VERR_NO_MEMORY;
@@ -108 +159 @@
 {
     if (ASMAtomicDecU32(&pThis->cRefs) == 0)
+    {
+#ifdef IN_RING3
+        NTSTATUS rcNt = NtClose(pThis->hEvent);
+        AssertMsg(NT_SUCCESS(rcNt), ("%#x\n", rcNt)); RT_NOREF(rcNt);
+        pThis->hEvent = NULL;
+#endif
+#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3)
+        RTLockValidatorRecSharedDelete(&pThis->Signallers);
+#endif
         RTMemFree(pThis);
+    }
 }
 
@@ -127 +188 @@
      */
     ASMAtomicIncU32(&pThis->u32Magic);
+#ifdef IN_RING0
     KeSetEvent(&pThis->Event, 0xfff, FALSE);
+#else
+    NtSetEvent(pThis->hEvent, NULL);
+#endif
+
     rtR0SemEventNtRelease(pThis);
     return VINF_SUCCESS;
@@ -143 +209 @@
     rtR0SemEventNtRetain(pThis);
 
+#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3)
+    if (pThis->fEverHadSignallers)
+    {
+        int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD);
+        if (RT_FAILURE(rc9))
+            return rc9;
+    }
+#endif
+
     /*
      * Signal the event object.
      */
+#ifdef IN_RING0
     KeSetEvent(&pThis->Event, 1, FALSE);
+#else
+    NTSTATUS rcNt = NtSetEvent(pThis->hEvent, NULL);
+#endif
 
     rtR0SemEventNtRelease(pThis);
+#ifdef IN_RING3
+    AssertMsgReturn(NT_SUCCESS(rcNt), ("Signaling hEventSem %p failed: %#x\n", pThis, rcNt), RTErrConvertFromNtStatus(rcNt));
+#endif
     return VINF_SUCCESS;
 }
@@ -171 +253 @@
     if (!pThis)
         return VERR_INVALID_PARAMETER;
-    AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
-    AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
-    AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
+    AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_FLAGS);
     NOREF(pSrcPos);
 
     rtR0SemEventNtRetain(pThis);
+
+    /*
+     * Lock validation needs to be done only when not polling.
+     */
+#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3)
+    RTTHREAD const hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) ? RTThreadSelfAutoAdopt() : RTThreadSelf();
+    if (   pThis->fEverHadSignallers
+        && (   uTimeout != 0
+            || (fFlags & (RTSEMWAIT_FLAGS_INDEFINITE | RTSEMWAIT_FLAGS_ABSOLUTE))) )
+    {
+        int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, NULL /*pSrcPos*/, false,
+                                                        fFlags & RTSEMWAIT_FLAGS_INDEFINITE
+                                                        ? RT_INDEFINITE_WAIT : RT_MS_30SEC /*whatever*/,
+                                                        RTTHREADSTATE_EVENT, true);
+        if (RT_FAILURE(rc9))
+            return rc9;
+    }
+#elif defined(IN_RING3)
+    RTTHREAD const hThreadSelf = RTThreadSelf();
+#endif
 
     /*
@@ -185 +287 @@
      * Lazy bird converts uTimeout to relative nanoseconds and then to Nt time.
      */
+#ifdef IN_RING3
+    uint64_t nsStartNow = 0;
+#endif
     if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
     {
         if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
-            uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
-                     ? uTimeout * UINT32_C(1000000)
+            uTimeout = uTimeout < UINT64_MAX / RT_NS_1MS
+                     ? uTimeout * RT_NS_1MS
                      : UINT64_MAX;
         if (uTimeout == UINT64_MAX)
@@ -195 +300 @@
         else
         {
+#ifdef IN_RING3
+            if (fFlags & (RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_ABSOLUTE))
+                nsStartNow = RTTimeSystemNanoTS();
+#endif
             if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE)
             {
-                uint64_t u64Now = RTTimeSystemNanoTS();
-                uTimeout = u64Now < uTimeout
-                         ? uTimeout - u64Now
+#ifdef IN_RING0
+                uint64_t const nsStartNow = RTTimeSystemNanoTS();
+#endif
+                uTimeout = nsStartNow < uTimeout
+                         ? uTimeout - nsStartNow
                          : 0;
             }
@@ -209 +320 @@
      * We're assuming interruptible waits should happen at UserMode level.
      */
-    NTSTATUS        rcNt;
-    BOOLEAN         fInterruptible = !!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
-    KPROCESSOR_MODE WaitMode   = fInterruptible ? UserMode : KernelMode;
-    if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
-        rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, NULL);
-    else
-    {
-        LARGE_INTEGER Timeout;
-        Timeout.QuadPart = -(int64_t)(uTimeout / 100);
-        rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, &Timeout);
-    }
     int rc;
-    if (pThis->u32Magic == RTSEMEVENT_MAGIC)
-    {
-        switch (rcNt)
+#ifdef IN_RING3
+    for (;;)
+#endif
+    {
+#ifdef IN_RING0
+        BOOLEAN         fInterruptible = !!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
+        KPROCESSOR_MODE WaitMode       = fInterruptible ? UserMode : KernelMode;
+#endif
+        NTSTATUS        rcNt;
+#ifdef IN_RING3
+        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT, true);
+#endif
+        if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
+#ifdef IN_RING0
+            rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, NULL);
+#else
+            rcNt = NtWaitForSingleObject(pThis->hEvent, TRUE /*Alertable*/, NULL);
+#endif
+        else
         {
-            case STATUS_SUCCESS:
-                rc = VINF_SUCCESS;
-                break;
-            case STATUS_ALERTED:
-                rc = VERR_INTERRUPTED;
-                break;
-            case STATUS_USER_APC:
-                rc = VERR_INTERRUPTED;
-                break;
-            case STATUS_TIMEOUT:
-                rc = VERR_TIMEOUT;
-                break;
-            default:
-                AssertMsgFailed(("pThis->u32Magic=%RX32 pThis=%p: wait returned %lx!\n",
-                                 pThis->u32Magic, pThis, (long)rcNt));
-                rc = VERR_INTERNAL_ERROR_4;
-                break;
+            LARGE_INTEGER Timeout;
+            Timeout.QuadPart = -(int64_t)(uTimeout / 100);
+#ifdef IN_RING0
+            rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, &Timeout);
+#else
+            rcNt = NtWaitForSingleObject(pThis->hEvent, TRUE /*Alertable*/, &Timeout);
+#endif
         }
-    }
-    else
-        rc = VERR_SEM_DESTROYED;
+#ifdef IN_RING3
+        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT);
+#endif
+        if (pThis->u32Magic == RTSEMEVENT_MAGIC)
+        {
+            switch (rcNt)
+            {
+                case STATUS_SUCCESS:
+                    rc = VINF_SUCCESS;
+                    break;
+
+                case STATUS_TIMEOUT:
+                    Assert(!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE));
+                    rc = VERR_TIMEOUT;
+                    break;
+
+                case STATUS_USER_APC:
+                case STATUS_ALERTED:
+                    rc = VERR_INTERRUPTED;
+#ifdef IN_RING3
+                    /* Loop if when automatically resuming on interruption, adjusting the timeout. */
+                    if (fFlags & RTSEMWAIT_FLAGS_RESUME)
+                    {
+                        if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE) && uTimeout > 0)
+                        {
+                            uint64_t const nsNewNow   = RTTimeSystemNanoTS();
+                            uint64_t const cNsElapsed = nsNewNow - nsStartNow;
+                            if (cNsElapsed < uTimeout)
+                                uTimeout -= cNsElapsed;
+                            else
+                                uTimeout = 0;
+                            nsStartNow = nsNewNow;
+                        }
+                        continue;
+                    }
+#endif
+                    break;
+
+#ifdef IN_RING3
+                case STATUS_ABANDONED_WAIT_0:
+                    rc = VERR_SEM_OWNER_DIED;
+                    break;
+#endif
+                default:
+                    AssertMsgFailed(("pThis->u32Magic=%RX32 pThis=%p: wait returned %x!\n", pThis->u32Magic, pThis, rcNt));
+                    rc = VERR_INTERNAL_ERROR_4;
+                    break;
+            }
+        }
+        else
+            rc = VERR_SEM_DESTROYED;
+#ifdef IN_RING3
+        break;
+#endif
+    }
 
     rtR0SemEventNtRelease(pThis);
@@ -273 +431 @@
 RTDECL(uint32_t) RTSemEventGetResolution(void)
 {
+    /*
+     * We need to figure the KeWaitForSingleObject / NtWaitForSingleObject timeout
+     * resolution, i.e. if we wish to wait for 1000ns how long are we likely to
+     * actually wait before woken up.
+     *
+     * In older versions of NT, these timeout were implemented using KTIMERs and
+     * have the same resolution as what them.  This should be found using
+     * ExSetTimerResolution or NtQueryTimerResolution.
+     *
+     * Probably since windows 8.1 the value returned by NtQueryTimerResolution (and
+     * set NtSetTimerResolution) have been virtualized and no longer reflects the
+     * timer wheel resolution, at least from what I can tell. ExSetTimerResolution
+     * still works as before, but it accesses variable that I cannot find out how
+     * to access from user land.  So, kernel will get (and be able to set) the right
+     * granularity, while in user land we'll be forced to reporting the max value.
+     *
+     * (The reason why I suspect it's since 8.1 is because the high resolution
+     * ExSetTimer APIs were introduced back then.)
+     */
+#ifdef IN_RING0
     return RTTimerGetSystemGranularity();
-}
-
-
+#else
+    ULONG cNtTicksMin = 0;
+    ULONG cNtTicksMax = 0;
+    ULONG cNtTicksCur = 0;
+    NTSTATUS rcNt = NtQueryTimerResolution(&cNtTicksMin, &cNtTicksMax, &cNtTicksCur);
+    if (NT_SUCCESS(rcNt))
+    {
+        Assert(cNtTicksMin >= cNtTicksMax);
+        if (RTSystemGetNtVersion() >= RTSYSTEM_MAKE_NT_VERSION(6,3,9600)) /** @todo check when the switch happened, might be much later... */
+            return cNtTicksMin * 100;
+        return cNtTicksCur * 100;
+    }
+    AssertFailed();
+    return 16 * RT_NS_1MS; /* the default on 64-bit windows 10 */
+#endif
+}
+
+
+#ifdef IN_RING0
 RTR0DECL(bool) RTSemEventIsSignalSafe(void)
 {
     return KeGetCurrentIrql() <= DISPATCH_LEVEL;
 }
-
+#endif
+
+#ifdef IN_RING3
+
+RTDECL(void) RTSemEventSetSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
+{
+# ifdef RTSEMEVENT_STRICT
+    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
+    AssertPtrReturnVoid(pThis);
+    AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC);
+
+    ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
+    RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL);
+# else
+    RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread);
+# endif
+}
+
+
+RTDECL(void) RTSemEventAddSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
+{
+# ifdef RTSEMEVENT_STRICT
+    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
+    AssertPtrReturnVoid(pThis);
+    AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC);
+
+    ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
+    RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL);
+# else
+    RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread);
+# endif
+}
+
+
+RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
+{
+# ifdef RTSEMEVENT_STRICT
+    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
+    AssertPtrReturnVoid(pThis);
+    AssertReturnVoid(pThis->u32Magic == RTSEMEVENT_MAGIC);
+
+    RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread);
+# else
+    RT_NOREF_PV(hEventSem); RT_NOREF_PV(hThread);
+# endif
+}
+
+#endif /* IN_RING3 */