Changeset 53471 in vbox for trunk/src/VBox/Runtime/r3/nt

Timestamp:

Dec 6, 2014 3:57:52 AM (10 years ago)

Author:

vboxsync

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

97201

Message:

IPRT/r3/nt&win: Precision time APIs for NT (not enabled).

File:

• trunk/src/VBox/Runtime/r3/nt/time-nt.cpp (copied) (copied from trunk/src/VBox/Runtime/r3/win/time-win.cpp ) (1 diff)

trunk/src/VBox/Runtime/r3/nt/time-nt.cpp

@@ -30 +30 @@
 *******************************************************************************/
 #define LOG_GROUP RTLOGGROUP_TIME
-#include <Windows.h>
+#include "internal-r3-nt.h"
 
 #include <iprt/time.h>
-#include "internal/iprt.h"
-
 #include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/err.h>
+#include <iprt/ldr.h>
+#include <iprt/uint128.h>
 #include "internal/time.h"
 
-/*
- * Note! The selected time source be the exact same one as we use in kernel land!
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+/** Whether we've tried to resolve g_pfnRtlGetSystemTimePrecise or not. */
+static bool                         g_fInitialized = false;
+/** Pointer to RtlGetSystemTimePrecise, added in 6.2 (windows 8).   */
+static PFNRTLGETSYSTEMTIMEPRECISE   g_pfnRtlGetSystemTimePrecise = NULL;
+
+
+/**
+ * Initializes globals.
  */
-//#define USE_TICK_COUNT
-//#define USE_PERFORMANCE_COUNTER
-//# define USE_FILE_TIME
-//#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
-# define USE_INTERRUPT_TIME
-//#else
-//# define USE_TICK_COUNT
-//#endif
-
-
-#ifdef USE_INTERRUPT_TIME
-
-typedef struct _MY_KSYSTEM_TIME
-{
-    ULONG LowPart;
-    LONG High1Time;
-    LONG High2Time;
-} MY_KSYSTEM_TIME;
-
-typedef struct _MY_KUSER_SHARED_DATA
-{
-    ULONG TickCountLowDeprecated;
-    ULONG TickCountMultiplier;
-    volatile MY_KSYSTEM_TIME InterruptTime;
-    /* The rest is not relevant. */
-} MY_KUSER_SHARED_DATA, *PMY_KUSER_SHARED_DATA;
-
-#endif /* USE_INTERRUPT_TIME */
-
-
-DECLINLINE(uint64_t) rtTimeGetSystemNanoTS(void)
-{
-#if defined USE_TICK_COUNT
-    /*
-     * This would work if it didn't flip over every 49 (or so) days.
-     */
-    return (uint64_t)GetTickCount() * RT_NS_1MS_64;
-
-#elif defined USE_PERFORMANCE_COUNTER
-    /*
-     * Slow and not derived from InterruptTime.
-     */
-    static LARGE_INTEGER    llFreq;
-    static unsigned         uMult;
-    if (!llFreq.QuadPart)
-    {
-        if (!QueryPerformanceFrequency(&llFreq))
-            return (uint64_t)GetTickCount() * RT_NS_1MS_64;
-        llFreq.QuadPart /=    1000;
-        uMult            = 1000000;     /* no math genius, but this seemed to help avoiding floating point. */
+static void rtTimeNtInitialize(void)
+{
+    /*
+     * Make sure we don't recurse here when calling into RTLdr.
+     */
+    if (ASMAtomicCmpXchgBool(&g_fInitialized, true, false))
+    {
+        void *pvFunc = RTLdrGetSystemSymbol("ntdll.dll", "RtlGetSystemTimePrecise");
+        if (pvFunc)
+            ASMAtomicWritePtr((void * volatile *)&g_pfnRtlGetSystemTimePrecise, pvFunc);
+        ASMCompilerBarrier();
     }
-
-    LARGE_INTEGER   ll;
-    if (QueryPerformanceCounter(&ll))
-        return (ll.QuadPart * uMult) / llFreq.QuadPart;
-    return (uint64_t)GetTickCount() * RT_NS_1MS_64;
-
-#elif defined USE_FILE_TIME
-    /*
-     * This is SystemTime not InterruptTime.
-     */
-    uint64_t u64; /* manual say larger integer, should be safe to assume it's the same. */
-    GetSystemTimeAsFileTime((LPFILETIME)&u64);
-    return u64 * 100;
-
-#elif defined USE_INTERRUPT_TIME
-# if 0 /* ASSUME 0x7ffe0000 is set in stone */
-    /*
-     * This is exactly what we want, but we have to obtain it by non-official
-     * means.
-     */
-    static MY_KUSER_SHARED_DATA *s_pUserSharedData = NULL;
-    if (!s_pUserSharedData)
-    {
-        /** @todo find official way of getting this or some more clever
-         * detection algorithm if necessary. The com debugger class
-         * exports this too, windbg knows it too... */
-        s_pUserSharedData = (PMY_KUSER_SHARED_DATA)(uintptr_t)0x7ffe0000;
-    }
-# endif
-    PMY_KUSER_SHARED_DATA pUserSharedData = (PMY_KUSER_SHARED_DATA)(uintptr_t)0x7ffe0000;
-
-    /* use interrupt time */
-    LARGE_INTEGER Time;
-    do
-    {
-        Time.HighPart = pUserSharedData->InterruptTime.High1Time;
-        Time.LowPart  = pUserSharedData->InterruptTime.LowPart;
-    } while (pUserSharedData->InterruptTime.High2Time != Time.HighPart);
-
-    return (uint64_t)Time.QuadPart * 100;
-
-#else
-# error "Must select a method bright guy!"
-#endif
-}
-
-
-RTDECL(uint64_t) RTTimeSystemNanoTS(void)
-{
-    return rtTimeGetSystemNanoTS();
-}
-
-
-RTDECL(uint64_t) RTTimeSystemMilliTS(void)
-{
-    return rtTimeGetSystemNanoTS() / RT_NS_1MS;
-}
-
-
-RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime)
-{
-    uint64_t u64;
-    AssertCompile(sizeof(u64) == sizeof(FILETIME));
-    GetSystemTimeAsFileTime((LPFILETIME)&u64);
-    return RTTimeSpecSetNtTime(pTime, u64);
-}
-
-
-RTDECL(int) RTTimeSet(PCRTTIMESPEC pTime)
-{
-    FILETIME    FileTime;
-    SYSTEMTIME  SysTime;
-    if (FileTimeToSystemTime(RTTimeSpecGetNtFileTime(pTime, &FileTime), &SysTime))
-    {
-        if (SetSystemTime(&SysTime))
-            return VINF_SUCCESS;
-    }
-    return RTErrConvertFromWin32(GetLastError());
-}
-
-
-RTDECL(PRTTIMESPEC) RTTimeLocalNow(PRTTIMESPEC pTime)
-{
-    uint64_t u64;
-    AssertCompile(sizeof(u64) == sizeof(FILETIME));
-    GetSystemTimeAsFileTime((LPFILETIME)&u64);
-    uint64_t u64Local;
-    if (!FileTimeToLocalFileTime((FILETIME const *)&u64, (LPFILETIME)&u64Local))
-        u64Local = u64;
-    return RTTimeSpecSetNtTime(pTime, u64Local);
-}
-
-
-RTDECL(int64_t) RTTimeLocalDeltaNano(void)
-{
-    /*
-     * UTC = local + Tzi.Bias;
-     * The bias is given in minutes.
-     */
-    TIME_ZONE_INFORMATION Tzi;
-    Tzi.Bias = 0;
-    if (GetTimeZoneInformation(&Tzi) != TIME_ZONE_ID_INVALID)
-        return -(int64_t)Tzi.Bias * 60 * RT_NS_1SEC_64;
-    return 0;
-}
-
-
-RTDECL(PRTTIME) RTTimeLocalExplode(PRTTIME pTime, PCRTTIMESPEC pTimeSpec)
-{
-    /*
-     * FileTimeToLocalFileTime does not do the right thing, so we'll have
-     * to convert to system time and SystemTimeToTzSpecificLocalTime instead.
-     */
-    RTTIMESPEC LocalTime;
-    SYSTEMTIME SystemTimeIn;
-    FILETIME FileTime;
-    if (FileTimeToSystemTime(RTTimeSpecGetNtFileTime(pTimeSpec, &FileTime), &SystemTimeIn))
-    {
-        SYSTEMTIME SystemTimeOut;
-        if (SystemTimeToTzSpecificLocalTime(NULL /* use current TZI */,
-                                            &SystemTimeIn,
-                                            &SystemTimeOut))
+}
+
+
+static uint64_t rtTimeGetSystemNanoTS(void)
+{
+    if (RT_UNLIKELY(!g_fInitialized))
+        rtTimeNtInitialize();
+
+    KUSER_SHARED_DATA volatile *pUserSharedData = (KUSER_SHARED_DATA volatile *)MM_SHARED_USER_DATA_VA;
+
+#if 1
+    /*
+     * If there is precise time, get the precise system time and calculate the
+     * interrupt time from it.  (Microsoft doesn't expose interrupt time to user
+     * application, which is very unfortunate as there are a lot place where
+     * monotonic time is applicable but developer is "forced" to use wall clock.)
+     */
+    if (g_pfnRtlGetSystemTimePrecise)
+    {
+        for (;;)
         {
-            if (SystemTimeToFileTime(&SystemTimeOut, &FileTime))
+            uint64_t uUpdateLockBefore;
+            while ((uUpdateLockBefore = pUserSharedData->TimeUpdateLock) & 1)
+                ASMNopPause();
+
+            uint64_t        uInterruptTime                  = *(uint64_t volatile *)&pUserSharedData->InterruptTime;
+            uint64_t        uBaselineInterruptTimeQpc       = pUserSharedData->BaselineInterruptTimeQpc;
+            uint64_t        uQpcInterruptTimeIncrement      = pUserSharedData->QpcInterruptTimeIncrement;
+            uint8_t         uQpcInterruptTimeIncrementShift = pUserSharedData->QpcInterruptTimeIncrementShift;
+            LARGE_INTEGER   QpcValue;
+            RtlQueryPerformanceCounter(&QpcValue);
+
+            if (pUserSharedData->TimeUpdateLock == uUpdateLockBefore)
             {
-                RTTimeSpecSetNtFileTime(&LocalTime, &FileTime);
-                pTime = RTTimeExplode(pTime, &LocalTime);
-                if (pTime)
-                    pTime->fFlags = (pTime->fFlags & ~RTTIME_FLAGS_TYPE_MASK) | RTTIME_FLAGS_TYPE_LOCAL;
-                return pTime;
+                uint64_t uQpcValue = QpcValue.QuadPart;
+                if (uQpcValue <= uBaselineInterruptTimeQpc)
+                    return uInterruptTime * 100;
+
+                /* Calc QPC delta since base line. */
+                uQpcValue -= uBaselineInterruptTimeQpc;
+                uQpcValue--;
+
+                /* Multiply by 10 million. */
+                uQpcValue *= UINT32_C(10000000);
+
+                /* Multiply by QPC interrupt time increment value. */
+                RTUINT128U Tmp128;
+                RTUInt128MulU64ByU64(&Tmp128, uQpcValue, uQpcInterruptTimeIncrement);
+
+                /* Shift the upper 64 bits by the increment shift factor. */
+                uint64_t uResult = Tmp128.s.Hi >> uQpcInterruptTimeIncrementShift;
+
+                /* Add to base interrupt time value. */
+                uResult += uInterruptTime;
+
+                /* Convert from NT unit to nano seconds. */
+                return uResult * 100;
             }
+
+            ASMNopPause();
         }
     }
-
-    /*
-     * The fallback is to use the current offset.
-     * (A better fallback would be to use the offset of the same time of the year.)
-     */
-    LocalTime = *pTimeSpec;
-    RTTimeSpecAddNano(&LocalTime, RTTimeLocalDeltaNano());
-    pTime = RTTimeExplode(pTime, &LocalTime);
-    if (pTime)
-        pTime->fFlags = (pTime->fFlags & ~RTTIME_FLAGS_TYPE_MASK) | RTTIME_FLAGS_TYPE_LOCAL;
-    return pTime;
-}
-
+#endif
+
+    /*
+     * Just read interrupt time.
+     */
+#if ARCH_BITS >= 64
+    uint64_t uRet = *(uint64_t volatile *)&pUserSharedData->InterruptTime; /* This is what KeQueryInterruptTime does. */
+    uRet *= 100;
+    return uRet;
+#else
+
+    LARGE_INTEGER NtTime;
+    do
+    {
+        NtTime.HighPart = pUserSharedData->InterruptTime.High1Time;
+        NtTime.LowPart  = pUserSharedData->InterruptTime.LowPart;
+    } while (pUserSharedData->InterruptTime.High2Time != NtTime.HighPart);
+
+    return (uint64_t)NtTime.QuadPart * 100;
+#endif
+}
+
+
+RTDECL(uint64_t) RTTimeSystemNanoTS(void)
+{
+    return rtTimeGetSystemNanoTS();
+}
+
+
+RTDECL(uint64_t) RTTimeSystemMilliTS(void)
+{
+    return rtTimeGetSystemNanoTS() / RT_NS_1MS;
+}
+
+
+RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime)
+{
+    /*
+     * Get the precise time if possible.
+     */
+    if (RT_UNLIKELY(!g_fInitialized))
+        rtTimeNtInitialize();
+    if (g_pfnRtlGetSystemTimePrecise != NULL)
+        return RTTimeSpecSetNtTime(pTime, g_pfnRtlGetSystemTimePrecise());
+
+    /*
+     * Just read system time.
+     */
+    KUSER_SHARED_DATA volatile *pUserSharedData = (KUSER_SHARED_DATA volatile *)MM_SHARED_USER_DATA_VA;
+#ifdef RT_ARCH_AMD64
+    uint64_t uRet = *(uint64_t volatile *)&pUserSharedData->SystemTime; /* This is what KeQuerySystemTime does. */
+    return RTTimeSpecSetNtTime(pTime, uRet);
+#else
+
+    LARGE_INTEGER NtTime;
+    do
+    {
+        NtTime.HighPart = pUserSharedData->SystemTime.High1Time;
+        NtTime.LowPart  = pUserSharedData->SystemTime.LowPart;
+    } while (pUserSharedData->SystemTime.High2Time != NtTime.HighPart);
+    return RTTimeSpecSetNtTime(pTime, NtTime.QuadPart);
+#endif
+}
+
+
+RTDECL(PRTTIMESPEC) RTTimeLocalNow(PRTTIMESPEC pTime)
+{
+    return RTTimeSpecAddNano(RTTimeNow(pTime), RTTimeLocalDeltaNano());
+}
+
+
+RTDECL(int64_t) RTTimeLocalDeltaNano(void)
+{
+    /*
+     * UTC = local + TimeZoneBias; The bias is given in NT units.
+     */
+    KUSER_SHARED_DATA volatile *pUserSharedData = (KUSER_SHARED_DATA volatile *)MM_SHARED_USER_DATA_VA;
+    LARGE_INTEGER               Delta;
+#if ARCH_BITS == 64
+    Delta.QuadPart = *(int64_t volatile *)&pUserSharedData->TimeZoneBias;
+#else
+    do
+    {
+        Delta.HighPart = pUserSharedData->TimeZoneBias.High1Time;
+        Delta.LowPart  = pUserSharedData->TimeZoneBias.LowPart;
+    } while (pUserSharedData->TimeZoneBias.High2Time != Delta.HighPart);
+#endif
+    return Delta.QuadPart * -100;
+}
+