Changeset 92792 in vbox for trunk/src/VBox

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

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (8 diffs)
• nt/semevent-nt.cpp (moved) (moved from trunk/src/VBox/Runtime/r0drv/nt/semevent-r0drv-nt.cpp ) (14 diffs)
• r3/win/RTSystemQueryOSInfo-win.cpp (modified) (2 diffs)
• r3/win/system-get-nt-xxx-win.cpp (copied) (copied from trunk/src/VBox/Runtime/r3/win/RTSystemQueryOSInfo-win.cpp ) (2 diffs, 1 prop)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstRTSemEvent.cpp (modified) (4 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -937 +937 @@
         generic/RTRandAdvCreateSystemFaster-generic.cpp \
         generic/RTRandAdvCreateSystemTruer-generic.cpp \
-        generic/RTSemEventWait-generic.cpp \
         generic/RTSemEventMultiWait-2-ex-generic.cpp \
         generic/RTSemEventMultiWaitNoResume-2-ex-generic.cpp \
@@ -964 +963 @@
         r3/nt/RTPathSetMode-r3-nt.cpp \
         r3/nt/RTProcQueryParent-r3-nt.cpp \
+        nt/semevent-nt.cpp \
         r3/win/env-win.cpp \
         r3/win/RTCrStoreCreateSnapshotById-win.cpp \
@@ -995 +995 @@
         r3/win/rtProcInitExePath-win.cpp \
         r3/win/sched-win.cpp \
-        r3/win/semevent-win.cpp \
+        generic/RTSemEventWait-2-ex-generic.cpp \
+        generic/RTSemEventWaitNoResume-2-ex-generic.cpp \
         r3/win/semeventmulti-win.cpp \
         r3/win/semmutex-win.cpp \
@@ -1001 +1002 @@
         r3/win/shmem-win.cpp \
         r3/win/symlink-win.cpp \
+        r3/win/system-get-nt-xxx-win.cpp \
         r3/win/thread-win.cpp \
         r3/win/thread2-win.cpp \
@@ -2050 +2052 @@
         nt/fileioutils-nt.cpp \
         nt/RTErrConvertFromNtStatus.cpp \
+        nt/semevent-nt.cpp \
         r3/nt/direnum-r3-nt.cpp \
         r3/nt/dirrel-r3-nt.cpp \
@@ -2076 +2079 @@
         r3/win/RTUuidCreate-win.cpp \
         r3/win/sched-win.cpp \
-        r3/win/semevent-win.cpp \
+        generic/RTSemEventWait-2-ex-generic.cpp \
+        generic/RTSemEventWaitNoResume-2-ex-generic.cpp \
         r3/win/semeventmulti-win.cpp \
         r3/win/semmutex-win.cpp \
         r3/win/symlink-win.cpp \
+        r3/win/system-get-nt-xxx-win.cpp \
         r3/win/thread-win.cpp \
         r3/win/thread2-win.cpp \
@@ -3212 +3217 @@
         nt/RTNtPathExpand8dot3PathA.cpp \
         nt/RTNtPathFindPossible8dot3Name.cpp \
+        nt/semevent-nt.cpp \
         r0drv/generic/threadctxhooks-r0drv-generic.cpp \
         r0drv/alloc-ef-r0drv.cpp \
@@ -3226 +3232 @@
         r0drv/nt/process-r0drv-nt.cpp \
         r0drv/nt/RTLogWriteDebugger-r0drv-nt.cpp \
-        r0drv/nt/semevent-r0drv-nt.cpp \
         r0drv/nt/semeventmulti-r0drv-nt.cpp \
         r0drv/nt/semfastmutex-r0drv-nt.cpp \

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 */

trunk/src/VBox/Runtime/r3/win/RTSystemQueryOSInfo-win.cpp

@@ -316 +316 @@
 
 
-
 RTDECL(int) RTSystemQueryOSInfo(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo)
 {
@@ -346 +345 @@
 }
 
-
-RTDECL(uint32_t) RTSystemGetNtBuildNo(void)
-{
-    return g_WinOsInfoEx.dwBuildNumber;
-}
-
-
-RTDECL(uint64_t) RTSystemGetNtVersion(void)
-{
-    return RTSYSTEM_MAKE_NT_VERSION(g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion, g_WinOsInfoEx.dwBuildNumber);
-}
-

trunk/src/VBox/Runtime/r3/win/system-get-nt-xxx-win.cpp

@@ -31 +31 @@
 #include "internal/iprt.h"
 #include <iprt/win/windows.h>
-#include <WinUser.h>
 
 #include "internal-r3-win.h"
 #include <iprt/system.h>
 #include <iprt/assert.h>
-#include <iprt/ctype.h>
-#include <iprt/errcore.h>
-#include <iprt/string.h>
-#include <iprt/utf16.h>
-
-
-/*********************************************************************************************************************************
-*   Structures and Typedefs                                                                                                      *
-*********************************************************************************************************************************/
-
-/**
- * These are the PRODUCT_* defines found in the Vista Platform SDK and returned
- * by GetProductInfo().
- *
- * We define them ourselves because we don't necessarily have any Vista PSDK around.
- */
-typedef enum RTWINPRODTYPE
-{
-    kRTWinProdType_UNDEFINED                    = 0x00000000,  ///< An unknown product
-    kRTWinProdType_BUSINESS                     = 0x00000006,  ///< Business Edition
-    kRTWinProdType_BUSINESS_N                   = 0x00000010,  ///< Business Edition
-    kRTWinProdType_CLUSTER_SERVER               = 0x00000012,  ///< Cluster Server Edition
-    kRTWinProdType_DATACENTER_SERVER            = 0x00000008,  ///< Server Datacenter Edition (full installation)
-    kRTWinProdType_DATACENTER_SERVER_CORE       = 0x0000000C,  ///< Server Datacenter Edition (core installation)
-    kRTWinProdType_ENTERPRISE                   = 0x00000004,  ///< Enterprise Edition
-    kRTWinProdType_ENTERPRISE_N                 = 0x0000001B,  ///< Enterprise Edition
-    kRTWinProdType_ENTERPRISE_SERVER            = 0x0000000A,  ///< Server Enterprise Edition (full installation)
-    kRTWinProdType_ENTERPRISE_SERVER_CORE       = 0x0000000E,  ///< Server Enterprise Edition (core installation)
-    kRTWinProdType_ENTERPRISE_SERVER_IA64       = 0x0000000F,  ///< Server Enterprise Edition for Itanium-based Systems
-    kRTWinProdType_HOME_BASIC                   = 0x00000002,  ///< Home Basic Edition
-    kRTWinProdType_HOME_BASIC_N                 = 0x00000005,  ///< Home Basic Edition
-    kRTWinProdType_HOME_PREMIUM                 = 0x00000003,  ///< Home Premium Edition
-    kRTWinProdType_HOME_PREMIUM_N               = 0x0000001A,  ///< Home Premium Edition
-    kRTWinProdType_HOME_SERVER                  = 0x00000013,  ///< Home Server Edition
-    kRTWinProdType_SERVER_FOR_SMALLBUSINESS     = 0x00000018,  ///< Server for Small Business Edition
-    kRTWinProdType_SMALLBUSINESS_SERVER         = 0x00000009,  ///< Small Business Server
-    kRTWinProdType_SMALLBUSINESS_SERVER_PREMIUM = 0x00000019,  ///< Small Business Server Premium Edition
-    kRTWinProdType_STANDARD_SERVER              = 0x00000007,  ///< Server Standard Edition (full installation)
-    kRTWinProdType_STANDARD_SERVER_CORE         = 0x0000000D,  ///< Server Standard Edition (core installation)
-    kRTWinProdType_STARTER                      = 0x0000000B,  ///< Starter Edition
-    kRTWinProdType_STORAGE_ENTERPRISE_SERVER    = 0x00000017,  ///< Storage Server Enterprise Edition
-    kRTWinProdType_STORAGE_EXPRESS_SERVER       = 0x00000014,  ///< Storage Server Express Edition
-    kRTWinProdType_STORAGE_STANDARD_SERVER      = 0x00000015,  ///< Storage Server Standard Edition
-    kRTWinProdType_STORAGE_WORKGROUP_SERVER     = 0x00000016,  ///< Storage Server Workgroup Edition
-    kRTWinProdType_ULTIMATE                     = 0x00000001,  ///< Ultimate Edition
-    kRTWinProdType_ULTIMATE_N                   = 0x0000001C,  ///< Ultimate Edition
-    kRTWinProdType_WEB_SERVER                   = 0x00000011,  ///< Web Server Edition (full)
-    kRTWinProdType_WEB_SERVER_CORE              = 0x0000001D   ///< Web Server Edition (core)
-} RTWINPRODTYPE;
-
-
-/**
- * Wrapper around the GetProductInfo API.
- *
- * @returns The vista type.
- */
-static RTWINPRODTYPE rtSystemWinGetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion, DWORD dwSpMinorVersion)
-{
-    BOOL (WINAPI *pfnGetProductInfo)(DWORD, DWORD, DWORD, DWORD, PDWORD);
-    pfnGetProductInfo = (BOOL (WINAPI *)(DWORD, DWORD, DWORD, DWORD, PDWORD))GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProductInfo");
-    if (pfnGetProductInfo)
-    {
-        DWORD dwProductType = kRTWinProdType_UNDEFINED;
-        if (pfnGetProductInfo(dwOSMajorVersion, dwOSMinorVersion, dwSpMajorVersion, dwSpMinorVersion, &dwProductType))
-            return (RTWINPRODTYPE)dwProductType;
-    }
-    return kRTWinProdType_UNDEFINED;
-}
-
-
-
-/**
- * Appends the product type if available.
- *
- * @param   pszTmp      The buffer. Assumes it's big enough.
- */
-static void rtSystemWinAppendProductType(char *pszTmp)
-{
-    RTWINPRODTYPE enmVistaType = rtSystemWinGetProductInfo(6, 0, 0, 0);
-    switch (enmVistaType)
-    {
-        case kRTWinProdType_BUSINESS:                        strcat(pszTmp, " Business Edition"); break;
-        case kRTWinProdType_BUSINESS_N:                      strcat(pszTmp, " Business Edition"); break;
-        case kRTWinProdType_CLUSTER_SERVER:                  strcat(pszTmp, " Cluster Server Edition"); break;
-        case kRTWinProdType_DATACENTER_SERVER:               strcat(pszTmp, " Server Datacenter Edition (full installation)"); break;
-        case kRTWinProdType_DATACENTER_SERVER_CORE:          strcat(pszTmp, " Server Datacenter Edition (core installation)"); break;
-        case kRTWinProdType_ENTERPRISE:                      strcat(pszTmp, " Enterprise Edition"); break;
-        case kRTWinProdType_ENTERPRISE_N:                    strcat(pszTmp, " Enterprise Edition"); break;
-        case kRTWinProdType_ENTERPRISE_SERVER:               strcat(pszTmp, " Server Enterprise Edition (full installation)"); break;
-        case kRTWinProdType_ENTERPRISE_SERVER_CORE:          strcat(pszTmp, " Server Enterprise Edition (core installation)"); break;
-        case kRTWinProdType_ENTERPRISE_SERVER_IA64:          strcat(pszTmp, " Server Enterprise Edition for Itanium-based Systems"); break;
-        case kRTWinProdType_HOME_BASIC:                      strcat(pszTmp, " Home Basic Edition"); break;
-        case kRTWinProdType_HOME_BASIC_N:                    strcat(pszTmp, " Home Basic Edition"); break;
-        case kRTWinProdType_HOME_PREMIUM:                    strcat(pszTmp, " Home Premium Edition"); break;
-        case kRTWinProdType_HOME_PREMIUM_N:                  strcat(pszTmp, " Home Premium Edition"); break;
-        case kRTWinProdType_HOME_SERVER:                     strcat(pszTmp, " Home Server Edition"); break;
-        case kRTWinProdType_SERVER_FOR_SMALLBUSINESS:        strcat(pszTmp, " Server for Small Business Edition"); break;
-        case kRTWinProdType_SMALLBUSINESS_SERVER:            strcat(pszTmp, " Small Business Server"); break;
-        case kRTWinProdType_SMALLBUSINESS_SERVER_PREMIUM:    strcat(pszTmp, " Small Business Server Premium Edition"); break;
-        case kRTWinProdType_STANDARD_SERVER:                 strcat(pszTmp, " Server Standard Edition (full installation)"); break;
-        case kRTWinProdType_STANDARD_SERVER_CORE:            strcat(pszTmp, " Server Standard Edition (core installation)"); break;
-        case kRTWinProdType_STARTER:                         strcat(pszTmp, " Starter Edition"); break;
-        case kRTWinProdType_STORAGE_ENTERPRISE_SERVER:       strcat(pszTmp, " Storage Server Enterprise Edition"); break;
-        case kRTWinProdType_STORAGE_EXPRESS_SERVER:          strcat(pszTmp, " Storage Server Express Edition"); break;
-        case kRTWinProdType_STORAGE_STANDARD_SERVER:         strcat(pszTmp, " Storage Server Standard Edition"); break;
-        case kRTWinProdType_STORAGE_WORKGROUP_SERVER:        strcat(pszTmp, " Storage Server Workgroup Edition"); break;
-        case kRTWinProdType_ULTIMATE:                        strcat(pszTmp, " Ultimate Edition"); break;
-        case kRTWinProdType_ULTIMATE_N:                      strcat(pszTmp, " Ultimate Edition"); break;
-        case kRTWinProdType_WEB_SERVER:                      strcat(pszTmp, " Web Server Edition (full installation)"); break;
-        case kRTWinProdType_WEB_SERVER_CORE:                 strcat(pszTmp, " Web Server Edition (core installation)"); break;
-        case kRTWinProdType_UNDEFINED:                       break;
-    }
-}
-
-
-/**
- * Services the  RTSYSOSINFO_PRODUCT, RTSYSOSINFO_RELEASE
- * and RTSYSOSINFO_SERVICE_PACK requests.
- *
- * @returns See RTSystemQueryOSInfo.
- * @param   enmInfo         See RTSystemQueryOSInfo.
- * @param   pszInfo         See RTSystemQueryOSInfo.
- * @param   cchInfo         See RTSystemQueryOSInfo.
- */
-static int rtSystemWinQueryOSVersion(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo)
-{
-    /*
-     * Make sure it's terminated correctly in case of error.
-     */
-    *pszInfo = '\0';
-
-    /*
-     * Check that we got the windows version at init time.
-     */
-    AssertReturn(g_WinOsInfoEx.dwOSVersionInfoSize, VERR_WRONG_ORDER);
-
-    /*
-     * Service the request.
-     */
-    char szTmp[512];
-    szTmp[0] = '\0';
-    switch (enmInfo)
-    {
-        /*
-         * The product name.
-         */
-        case RTSYSOSINFO_PRODUCT:
-        {
-            switch (g_enmWinVer)
-            {
-                case kRTWinOSType_95:           strcpy(szTmp, "Windows 95"); break;
-                case kRTWinOSType_95SP1:        strcpy(szTmp, "Windows 95 (Service Pack 1)"); break;
-                case kRTWinOSType_95OSR2:       strcpy(szTmp, "Windows 95 (OSR 2)"); break;
-                case kRTWinOSType_98:           strcpy(szTmp, "Windows 98"); break;
-                case kRTWinOSType_98SP1:        strcpy(szTmp, "Windows 98 (Service Pack 1)"); break;
-                case kRTWinOSType_98SE:         strcpy(szTmp, "Windows 98 (Second Edition)"); break;
-                case kRTWinOSType_ME:           strcpy(szTmp, "Windows Me"); break;
-                case kRTWinOSType_NT310:        strcpy(szTmp, "Windows NT 3.10"); break;
-                case kRTWinOSType_NT350:        strcpy(szTmp, "Windows NT 3.50"); break;
-                case kRTWinOSType_NT351:        strcpy(szTmp, "Windows NT 3.51"); break;
-                case kRTWinOSType_NT4:          strcpy(szTmp, "Windows NT 4.0"); break;
-                case kRTWinOSType_2K:           strcpy(szTmp, "Windows 2000"); break;
-                case kRTWinOSType_XP:
-                    strcpy(szTmp, "Windows XP");
-                    if (g_WinOsInfoEx.wSuiteMask & VER_SUITE_PERSONAL)
-                        strcat(szTmp, " Home");
-                    if (    g_WinOsInfoEx.wProductType == VER_NT_WORKSTATION
-                        && !(g_WinOsInfoEx.wSuiteMask & VER_SUITE_PERSONAL))
-                        strcat(szTmp, " Professional");
-#if 0 /** @todo fixme */
-                    if (GetSystemMetrics(SM_MEDIACENTER))
-                        strcat(szTmp, " Media Center");
-#endif
-                    break;
-
-                case kRTWinOSType_2003:         strcpy(szTmp, "Windows 2003"); break;
-                case kRTWinOSType_VISTA:
-                {
-                    strcpy(szTmp, "Windows Vista");
-                    rtSystemWinAppendProductType(szTmp);
-                    break;
-                }
-                case kRTWinOSType_2008:         strcpy(szTmp, "Windows 2008"); break;
-                case kRTWinOSType_7:            strcpy(szTmp, "Windows 7"); break;
-                case kRTWinOSType_2008R2:       strcpy(szTmp, "Windows 2008 R2"); break;
-                case kRTWinOSType_8:            strcpy(szTmp, "Windows 8"); break;
-                case kRTWinOSType_2012:         strcpy(szTmp, "Windows 2012"); break;
-                case kRTWinOSType_81:           strcpy(szTmp, "Windows 8.1"); break;
-                case kRTWinOSType_2012R2:       strcpy(szTmp, "Windows 2012 R2"); break;
-                case kRTWinOSType_10:           strcpy(szTmp, "Windows 10"); break;
-                case kRTWinOSType_2016:         strcpy(szTmp, "Windows 2016"); break;
-                case kRTWinOSType_2019:         strcpy(szTmp, "Windows 2019"); break;
-                case kRTWinOSType_2022:         strcpy(szTmp, "Windows 2022"); break;
-                case kRTWinOSType_11:           strcpy(szTmp, "Windows 11"); break;
-
-                case kRTWinOSType_NT_UNKNOWN:
-                    RTStrPrintf(szTmp, sizeof(szTmp), "Unknown NT v%u.%u",
-                                g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion);
-                    break;
-
-                default:
-                    AssertFailed();
-                case kRTWinOSType_UNKNOWN:
-                    RTStrPrintf(szTmp, sizeof(szTmp), "Unknown %d v%u.%u",
-                                g_WinOsInfoEx.dwPlatformId, g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion);
-                    break;
-            }
-            break;
-        }
-
-        /*
-         * The release.
-         */
-        case RTSYSOSINFO_RELEASE:
-        {
-            RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u.%u",
-                        g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion, g_WinOsInfoEx.dwBuildNumber);
-            break;
-        }
-
-
-        /*
-         * Get the service pack.
-         */
-        case RTSYSOSINFO_SERVICE_PACK:
-        {
-            if (g_WinOsInfoEx.wServicePackMajor)
-            {
-                if (g_WinOsInfoEx.wServicePackMinor)
-                    RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u",
-                                (unsigned)g_WinOsInfoEx.wServicePackMajor, (unsigned)g_WinOsInfoEx.wServicePackMinor);
-                else
-                    RTStrPrintf(szTmp, sizeof(szTmp), "%u",
-                                (unsigned)g_WinOsInfoEx.wServicePackMajor);
-            }
-            else if (g_WinOsInfoEx.szCSDVersion[0])
-            {
-                /* just copy the entire string. */
-                char *pszTmp = szTmp;
-                int rc = RTUtf16ToUtf8Ex(g_WinOsInfoEx.szCSDVersion, RT_ELEMENTS(g_WinOsInfoEx.szCSDVersion),
-                                         &pszTmp, sizeof(szTmp), NULL);
-                if (RT_SUCCESS(rc))
-                    RTStrStripR(szTmp);
-                else
-                    szTmp[0] = '\0';
-                AssertCompile(sizeof(szTmp) > sizeof(g_WinOsInfoEx.szCSDVersion));
-            }
-            else
-            {
-                switch (g_enmWinVer)
-                {
-                    case kRTWinOSType_95SP1:    strcpy(szTmp, "1"); break;
-                    case kRTWinOSType_98SP1:    strcpy(szTmp, "1"); break;
-                    default:
-                        break;
-                }
-            }
-            break;
-        }
-
-        default:
-            AssertFatalFailed();
-    }
-
-    /*
-     * Copy the result to the return buffer.
-     */
-    size_t cchTmp = strlen(szTmp);
-    Assert(cchTmp < sizeof(szTmp));
-    if (cchTmp < cchInfo)
-    {
-        memcpy(pszInfo, szTmp, cchTmp + 1);
-        return VINF_SUCCESS;
-    }
-    memcpy(pszInfo, szTmp, cchInfo - 1);
-    pszInfo[cchInfo - 1] = '\0';
-    return VERR_BUFFER_OVERFLOW;
-}
-
-
-
-RTDECL(int) RTSystemQueryOSInfo(RTSYSOSINFO enmInfo, char *pszInfo, size_t cchInfo)
-{
-    /*
-     * Quick validation.
-     */
-    AssertReturn(enmInfo > RTSYSOSINFO_INVALID && enmInfo < RTSYSOSINFO_END, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pszInfo, VERR_INVALID_POINTER);
-    if (!cchInfo)
-        return VERR_BUFFER_OVERFLOW;
-
-
-    /*
-     * Handle the request.
-     */
-    switch (enmInfo)
-    {
-        case RTSYSOSINFO_PRODUCT:
-        case RTSYSOSINFO_RELEASE:
-        case RTSYSOSINFO_SERVICE_PACK:
-            return rtSystemWinQueryOSVersion(enmInfo, pszInfo, cchInfo);
-
-        case RTSYSOSINFO_VERSION:
-        default:
-            *pszInfo = '\0';
-    }
-
-    return VERR_NOT_SUPPORTED;
-}
 
 
 RTDECL(uint32_t) RTSystemGetNtBuildNo(void)
 {
+    Assert(g_WinOsInfoEx.dwOSVersionInfoSize > 0);
     return g_WinOsInfoEx.dwBuildNumber;
 }
@@ -355 +46 @@
 RTDECL(uint64_t) RTSystemGetNtVersion(void)
 {
+    Assert(g_WinOsInfoEx.dwOSVersionInfoSize > 0);
     return RTSYSTEM_MAKE_NT_VERSION(g_WinOsInfoEx.dwMajorVersion, g_WinOsInfoEx.dwMinorVersion, g_WinOsInfoEx.dwBuildNumber);
 }

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -112 +112 @@
         tstRand \
         tstRTReqPool \
+        tstRTSemEvent \
         tstRTSemEventMulti \
         tstSemMutex \
@@ -614 +615 @@
 tstSemMutex_SOURCES = tstSemMutex.cpp
 
+tstRTSemEvent_TEMPLATE = VBOXR3TSTEXE
+tstRTSemEvent_SOURCES = tstRTSemEvent.cpp
+
 tstRTSemEventMulti_TEMPLATE = VBOXR3TSTEXE
 tstRTSemEventMulti_SOURCES = tstRTSemEventMulti.cpp

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

@@ -56 +56 @@
 *********************************************************************************************************************************/
 /** Pair of event semphores for the first benchmark test. */
-static RTSEMEVENT   g_ahEvtBench1[2];
-static uint64_t     g_cBench1Iterations;
-static uint64_t     g_uTimeoutBench1;
-static uint64_t     g_fWaitBench1;
+static RTSEMEVENT           g_ahEvtBench1[2];
+static uint64_t             g_uTimeoutBench1;
+static uint64_t             g_fWaitBench1;
+static uint64_t volatile    g_cBench1Iterations;
 
 
@@ -135 +135 @@
      * Report the result.
      */
-    RTTestValue(g_hTest, "Throughput", g_cBench1Iterations * RT_NS_1SEC / cNsElapsed, RTTESTUNIT_OCCURRENCES_PER_SEC);
-    RTTestValue(g_hTest, "Roundtrip", cNsElapsed / g_cBench1Iterations, RTTESTUNIT_NS_PER_OCCURRENCE);
-
+    uint64_t cIterations = g_cBench1Iterations;
+    RTTestValue(g_hTest, "Throughput", cIterations * RT_NS_1SEC / cNsElapsed, RTTESTUNIT_OCCURRENCES_PER_SEC);
+    RTTestValue(g_hTest, "Roundtrip", cNsElapsed / RT_MAX(cIterations, 1), RTTESTUNIT_NS_PER_OCCURRENCE);
 }
 
@@ -190 +190 @@
 *   Basic tests                                                                                                                  *
 *********************************************************************************************************************************/
+
+/**
+ * Just do a number of short waits and calculate min, max and average.
+ */
+static void resolution(void)
+{
+    RTTestISub("Timeout resolution");
+
+    RTSEMEVENT hSem;
+    RTTESTI_CHECK_RC_RETV(RTSemEventCreate(&hSem), VINF_SUCCESS);
+
+    uint64_t cNsMin   = UINT64_MAX;
+    uint64_t cNsMax   = 0;
+    uint64_t cNsTotal = 0;
+    uint32_t cLoops;
+    for (cLoops = 0; cLoops < 256; cLoops++)
+    {
+        uint64_t const nsStart    = RTTimeNanoTS();
+        int rc = RTSemEventWaitEx(hSem, RTSEMWAIT_FLAGS_NORESUME | RTSEMWAIT_FLAGS_RELATIVE | RTSEMWAIT_FLAGS_NANOSECS, RT_NS_1US);
+        uint64_t const cNsElapsed = RTTimeNanoTS() - nsStart;
+        RTTESTI_CHECK_RC(rc, VERR_TIMEOUT);
+        cNsTotal += cNsElapsed;
+        if (cNsElapsed < cNsMin)
+            cNsMin = cNsElapsed;
+        if (cNsElapsed > cNsMax)
+            cNsMax = cNsElapsed;
+    }
+
+    RTTestIValue("min", cNsMin, RTTESTUNIT_NS);
+    RTTestIValue("max", cNsMax, RTTESTUNIT_NS);
+    RTTestIValue("average", cNsTotal / cLoops, RTTESTUNIT_NS);
+    RTTestIValue("RTSemEventGetResolution", RTSemEventGetResolution(), RTTESTUNIT_NS);
+
+    RTTESTI_CHECK_RC_RETV(RTSemEventDestroy(hSem), VINF_SUCCESS);
+}
+
 
 
@@ -341 +377 @@
     {
         test1();
+        resolution();
     }
     if (!RTTestErrorCount(g_hTest))