Changeset 32572 in vbox for trunk/src/VBox/Runtime

Timestamp:

Sep 16, 2010 4:18:12 PM (14 years ago)

Author:

vboxsync

Message:

VMM,SUPDrv,IPRT: More changes for related to the priodic preemption timer. (still disabled)

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• generic/RTMpGetArraySize-generic.cpp (added)
• generic/timer-generic.cpp (modified) (2 diffs)
• r0drv/freebsd/timer-r0drv-freebsd.c (modified) (4 diffs)
• r0drv/linux/timer-r0drv-linux.c (modified) (29 diffs)
• r0drv/nt/timer-r0drv-nt.cpp (modified) (7 diffs)
• r0drv/os2/timer-r0drv-os2.cpp (modified) (2 diffs)
• r0drv/solaris/vbi/timer-r0drv-solaris.c (modified) (5 diffs)
• r3/posix/timer-posix.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -1390 +1390 @@
         generic/RTLogWriteStdErr-stub-generic.cpp \
         generic/RTLogWriteUser-generic.cpp \
+        generic/RTMpGetArraySize-generic.cpp \
         generic/RTRandAdvCreateSystemFaster-generic.cpp \
         generic/uuid-generic.cpp \

trunk/src/VBox/Runtime/generic/timer-generic.cpp

@@ -87 +87 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     *ppTimer = NULL;
@@ -225 +225 @@
 }
 RT_EXPORT_SYMBOL(RTTimerStop);
+
+
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    if (!rtTimerIsValid(pTimer))
+        return VERR_INVALID_HANDLE;
+    return VERR_NOT_SUPPORTED;
+}
+RT_EXPORT_SYMBOL(RTTimerChangeInterval);
 
 

trunk/src/VBox/Runtime/r0drv/freebsd/timer-r0drv-freebsd.c

@@ -90 +90 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     *ppTimer = NULL;
@@ -102 +102 @@
         &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
         &&  (fFlags & RTTIMER_FLAGS_CPU_MASK) > mp_maxid)
-        return VERR_INVALID_PARAMETER;
+        return VERR_CPU_NOT_FOUND;
 
     /*
@@ -166 +166 @@
     if (!pTimer->fSuspended)
         return VERR_TIMER_ACTIVE;
+    if (   pTimer->fSpecificCpu
+        && !RTMpIsCpuOnline(pTimer->idCpu))
+        return VERR_CPU_OFFLINE;
 
     /*
@@ -199 +202 @@
 
     return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    if (!rtTimerIsValid(pTimer))
+        return VERR_INVALID_HANDLE;
+    return VERR_NOT_SUPPORTED;
 }
 

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2008 Oracle Corporation
+ * Copyright (C) 2006-2010 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -44 +44 @@
 #include "internal/magics.h"
 
-/* We use the API of Linux 2.6.28+ (hrtimer_add_expires_ns()) */
-#if !defined(RT_USE_LINUX_HRTIMER) \
-    && LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28) \
+/** @def RTTIMER_LINUX_HAVE_HRTIMER
+ * Whether the kernel support high resolution timers (Linux kernel versions
+ * 2.6.28 and later (hrtimer_add_expires_ns()). */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
+# define RTTIMER_LINUX_HAVE_HRTIMER
+#endif
+
+/** @def RTTIMER_LINUX_ONLY_HRTIMER
+ * Whether to use high resolution timers for everything or not.  Implies
+ * RTTIMER_LINUX_WITH_HRTIMER. */
+#if !defined(RTTIMER_LINUX_ONLY_HRTIMER) \
+    && defined(RTTIMER_LINUX_HAVE_HRTIMER) \
     && 0 /* currently disabled */
-# define RT_USE_LINUX_HRTIMER
+# define RTTIMER_LINUX_ONLY_HRTIMER
 #endif
 
 /* This check must match the ktime usage in rtTimeGetSystemNanoTS() / time-r0drv-linux.c. */
-#if defined(RT_USE_LINUX_HRTIMER) \
- && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 28)
-# error "RT_USE_LINUX_HRTIMER requires 2.6.28 or later, sorry."
+#if defined(RTTIMER_LINUX_ONLY_HRTIMER) \
+ && !defined(RTTIMER_LINUX_HAVE_HRTIMER)
+# error "RTTIMER_LINUX_ONLY_HRTIMER requires 2.6.28 or later, sorry."
+#endif
+
+/** @def RTTIMER_LINUX_WITH_HRTIMER
+ * Whether to use high resolution timers.  */
+#if !defined(RTTIMER_LINUX_WITH_HRTIMER) \
+    && defined(RTTIMER_LINUX_HAVE_HRTIMER)
+# define RTTIMER_LINUX_WITH_HRTIMER
 #endif
 
@@ -96 +112 @@
 typedef struct RTTIMERLNXSUBTIMER
 {
-    /** The linux timer structure. */
-#ifdef RT_USE_LINUX_HRTIMER
-    struct hrtimer          LnxTimer;
-#else
-    struct timer_list       LnxTimer;
-    /** The start of the current run (ns).
-     * This is used to calculate when the timer ought to fire the next time. */
-    uint64_t                u64StartTS;
-    /** The start of the current run (ns).
-     * This is used to calculate when the timer ought to fire the next time. */
-    uint64_t                u64NextTS;
-#endif
-    /** The current tick number (since u64StartTS). */
+    /** Timer specific data.  */
+    union
+    {
+#if defined(RTTIMER_LINUX_WITH_HRTIMER)
+        /** High resolution timer. */
+        struct
+        {
+            /** The linux timer structure. */
+            struct hrtimer          LnxTimer;
+        } Hr;
+#endif
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
+        /** Standard timer. */
+        struct
+        {
+            /** The linux timer structure. */
+            struct timer_list       LnxTimer;
+            /** The start of the current run (ns).
+             * This is used to calculate when the timer ought to fire the next time. */
+            uint64_t                u64StartTS;
+            /** The start of the current run (ns).
+             * This is used to calculate when the timer ought to fire the next time. */
+            uint64_t                u64NextTS;
+            /** The u64NextTS in jiffies. */
+            unsigned long           ulNextJiffies;
+        } Std;
+#endif
+    } u;
+    /** The current tick number (since u.Std.u64StartTS). */
     uint64_t                iTick;
     /** Pointer to the parent timer. */
     PRTTIMER                pParent;
-#ifndef RT_USE_LINUX_HRTIMER
-    /** The u64NextTS in jiffies. */
-    unsigned long           ulNextJiffies;
-#endif
     /** The current sub-timer state. */
     RTTIMERLNXSTATE volatile enmState;
@@ -121 +149 @@
 /** Pointer to a linux sub-timer. */
 typedef RTTIMERLNXSUBTIMER *PRTTIMERLNXSUBTIMER;
-AssertCompileMemberOffset(RTTIMERLNXSUBTIMER, LnxTimer, 0);
 
 
@@ -144 +171 @@
     bool                    fAllCpus;
 #endif /* else: All -> specific on non-SMP kernels */
-    /** The CPU it must run on if fSpecificCpu is set. */
+    /** Whether it is a high resolution timer or a standard one. */
+    bool                    fHighRes;
+    /** The id of the CPU it must run on if fSpecificCpu is set. */
     RTCPUID                 idCpu;
     /** The number of CPUs this timer should run on. */
@@ -153 +182 @@
     void                   *pvUser;
     /** The timer interval. 0 if one-shot. */
-    uint64_t                u64NanoInterval;
-#ifndef RT_USE_LINUX_HRTIMER
+    uint64_t volatile       u64NanoInterval;
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
     /** This is set to the number of jiffies between ticks if the interval is
      * an exact number of jiffies. */
@@ -210 +239 @@
 }
 
-
-#ifdef RT_USE_LINUX_HRTIMER
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+
 /**
  * Converts a nano second time stamp to ktime_t.
@@ -239 +268 @@
 }
 
-#else /* ! RT_USE_LINUX_HRTIMER */
-
+#endif /* RTTIMER_LINUX_WITH_HRTIMER */
+
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
 /**
  * Converts a nano second interval to jiffies.
@@ -258 +288 @@
     return (cNanoSecs + (TICK_NSEC-1)) / TICK_NSEC;
 }
-#endif /* ! RT_USE_LINUX_HRTIMER */
+#endif /* !RTTIMER_LINUX_ONLY_HRTIMER */
 
 
@@ -269 +299 @@
  * @param   fPinned     true = timer pinned to a specific CPU,
  *                      false = timer can migrate between CPUs
- */
-static void rtTimerLnxStartSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, uint64_t u64Now, uint64_t u64First, bool fPinned)
+ * @param   fHighRes    Whether the user requested a high resolution timer or not.
+ */
+static void rtTimerLnxStartSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, uint64_t u64Now, uint64_t u64First,
+                                    bool fPinned, bool fHighRes)
 {
     /*
@@ -276 +308 @@
      */
     uint64_t u64NextTS = u64Now + u64First;
-#ifndef RT_USE_LINUX_HRTIMER
-    pSubTimer->u64StartTS = u64NextTS;
-    pSubTimer->u64NextTS = u64NextTS;
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    if (fHighRes)
+    {
+        pSubTimer->u.Std.u64StartTS = u64NextTS;
+        pSubTimer->u.Std.u64NextTS  = u64NextTS;
+    }
 #endif
 
     pSubTimer->iTick = 0;
 
-#ifdef RT_USE_LINUX_HRTIMER
-    hrtimer_start(&pSubTimer->LnxTimer, rtTimerLnxNanoToKt(u64NextTS),
-                  fPinned ? HRTIMER_MODE_ABS_PINNED : HRTIMER_MODE_ABS);
-#else
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    if (fHighRes)
+# endif
+        hrtimer_start(&pSubTimer->u.Hr.LnxTimer, rtTimerLnxNanoToKt(u64NextTS),
+                      fPinned ? HRTIMER_MODE_ABS_PINNED : HRTIMER_MODE_ABS);
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    else
+# endif
+#endif
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
     {
         unsigned long cJiffies = !u64First ? 0 : rtTimerLnxNanoToJiffies(u64First);
-        pSubTimer->ulNextJiffies = jiffies + cJiffies;
+        pSubTimer->u.Std.ulNextJiffies = jiffies + cJiffies;
 # ifdef CONFIG_SMP
         if (fPinned)
-            mod_timer_pinned(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
+            mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
         else
 # endif
-            mod_timer(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
+            mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
     }
 #endif
@@ -310 +352 @@
 static void rtTimerLnxStopSubTimer(PRTTIMERLNXSUBTIMER pSubTimer)
 {
-#ifdef RT_USE_LINUX_HRTIMER
-    hrtimer_cancel(&pSubTimer->LnxTimer);
-#else
-    if (timer_pending(&pSubTimer->LnxTimer))
-        del_timer_sync(&pSubTimer->LnxTimer);
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    if (pSubTimer->pParent->fHighRes)
+# endif
+        hrtimer_cancel(&pSubTimer->u.Hr.LnxTimer);
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    else
+# endif
+#endif
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    {
+        if (timer_pending(&pSubTimer->u.Std.LnxTimer))
+            del_timer_sync(&pSubTimer->u.Std.LnxTimer);
+    }
 #endif
 
@@ -321 +372 @@
 
 
-#ifdef RT_USE_LINUX_HRTIMER
-/**
- * Timer callback function.
- * @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a one-shot or interval timer.
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+/**
+ * Timer callback function for high resolution timers.
+ *
+ * @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a
+ *          one-shot or interval timer.
  * @param   pHrTimer    Pointer to the sub-timer structure.
  */
-static enum hrtimer_restart rtTimerLinuxCallback(struct hrtimer *pHrTimer)
-#else
-/**
- * Timer callback function.
- * @param   ulUser      Address of the sub-timer structure.
- */
-static void rtTimerLinuxCallback(unsigned long ulUser)
-#endif
-{
-#ifdef RT_USE_LINUX_HRTIMER
-    enum hrtimer_restart rc;
-    PRTTIMERLNXSUBTIMER pSubTimer = (PRTTIMERLNXSUBTIMER)pHrTimer;
-#else
-    PRTTIMERLNXSUBTIMER pSubTimer = (PRTTIMERLNXSUBTIMER)ulUser;
-#endif
-    PRTTIMER pTimer = pSubTimer->pParent;
+static enum hrtimer_restart rtTimerLinuxHrCallback(struct hrtimer *pHrTimer)
+{
+    PRTTIMERLNXSUBTIMER     pSubTimer = RT_FROM_MEMBER(pHrTimer, RTTIMERLNXSUBTIMER, u.Hr.LnxTimer);
+    PRTTIMER                pTimer    = pSubTimer->pParent;
+    enum hrtimer_restart    rc;
 
     /*
@@ -359 +401 @@
     {
         rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_ACTIVE);
-# ifdef RT_USE_LINUX_HRTIMER
         rc = HRTIMER_NORESTART;
-# endif
     }
     else if (!pTimer->u64NanoInterval)
@@ -371 +411 @@
             ASMAtomicWriteBool(&pTimer->fSuspended, true);
         rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_ACTIVE);
-#ifdef RT_USE_LINUX_HRTIMER
         rc = HRTIMER_NORESTART;
-#else
-        /* detached before we're called, nothing to do for this case. */
-#endif
-
         pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
     }
     else
     {
+        /*
+         * Run the timer.  Update the timer after calling the method.
+         */
         const uint64_t iTick = ++pSubTimer->iTick;
-
-#ifdef RT_USE_LINUX_HRTIMER
-        hrtimer_add_expires_ns(&pSubTimer->LnxTimer, pTimer->u64NanoInterval);
-        rc = HRTIMER_RESTART;
-#else
-        const uint64_t u64NanoTS = RTTimeNanoTS();
-
+        pTimer->pfnTimer(pTimer, pTimer->pvUser, iTick);
+
+        /** @todo Check reference counting wrt. RTTimerDestroy from the
+         *        callback? */
+        if (   pSubTimer->enmState == RTTIMERLNXSTATE_ACTIVE
+            || pSubTimer->enmState == RTTIMERLNXSTATE_MP_STARTING)
+        {
+            hrtimer_add_expires_ns(&pSubTimer->u.Hr.LnxTimer, ASMAtomicReadU64(&pTimer->u64NanoInterval));
+            rc = HRTIMER_RESTART;
+        }
+        else
+            rc = HRTIMER_NORESTART;
+    }
+
+    return rc;
+}
+#endif /* RTTIMER_LINUX_ONLY_HRTIMER */
+
+
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
+/**
+ * Timer callback function for standard timers.
+ *
+ * @param   ulUser      Address of the sub-timer structure.
+ */
+static void rtTimerLinuxStdCallback(unsigned long ulUser)
+{
+    PRTTIMERLNXSUBTIMER pSubTimer = (PRTTIMERLNXSUBTIMER)ulUser;
+    PRTTIMER            pTimer    = pSubTimer->pParent;
+
+    /*
+     * Don't call the handler if the timer has been suspended.
+     * Also, when running on all CPUS, make sure we don't call out twice
+     * on a CPU because of timer migration.
+     *
+     * For the specific cpu case, we're just ignoring timer migration for now... (bad)
+     */
+    if (    ASMAtomicUoReadBool(&pTimer->fSuspended)
+#ifdef CONFIG_SMP
+        ||  (   pTimer->fAllCpus
+             && (RTCPUID)(pSubTimer - &pTimer->aSubTimers[0]) != RTMpCpuId())
+#endif
+       )
+        rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_ACTIVE);
+    else if (!pTimer->u64NanoInterval)
+    {
+        /*
+         * One shot timer, stop it before dispatching it.
+         */
+        if (pTimer->cCpus == 1)
+            ASMAtomicWriteBool(&pTimer->fSuspended, true);
+        rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_ACTIVE);
+        pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
+    }
+    else
+    {
         /*
          * Interval timer, calculate the next timeout and re-arm it.
          *
-         * The first time around, we'll re-adjust the u64StartTS to
+         * The first time around, we'll re-adjust the u.Std.u64StartTS to
          * try prevent some jittering if we were started at a bad time.
          * This may of course backfire with highres timers...
+         *
+         * Note! u64NanoInterval won't change for standard timers.
          */
+        const uint64_t iTick            = ++pSubTimer->iTick;
+        const uint64_t u64NanoInterval  = pTimer->u64NanoInterval;
+        const uint64_t u64NanoTS        = RTTimeNanoTS();
+
         if (RT_UNLIKELY(iTick == 1))
         {
-            pSubTimer->u64StartTS = pSubTimer->u64NextTS = u64NanoTS;
-            pSubTimer->ulNextJiffies = jiffies;
+            pSubTimer->u.Std.u64StartTS    = u64NanoTS;
+            pSubTimer->u.Std.u64NextTS     = u64NanoTS;
+            pSubTimer->u.Std.ulNextJiffies = jiffies;
         }
 
-        pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+        pSubTimer->u.Std.u64NextTS += u64NanoInterval;
         if (pTimer->cJiffies)
         {
-            pSubTimer->ulNextJiffies += pTimer->cJiffies;
+            pSubTimer->u.Std.ulNextJiffies += pTimer->cJiffies;
             /* Prevent overflows when the jiffies counter wraps around.
              * Special thanks to Ken Preslan for helping debugging! */
-            while (time_before(pSubTimer->ulNextJiffies, jiffies))
+            while (time_before(pSubTimer->u.Std.ulNextJiffies, jiffies))
             {
-                pSubTimer->ulNextJiffies += pTimer->cJiffies;
-                pSubTimer->u64NextTS += pTimer->u64NanoInterval;
+                pSubTimer->u.Std.ulNextJiffies += pTimer->cJiffies;
+                pSubTimer->u.Std.u64NextTS += u64NanoInterval;
             }
         }
         else
         {
-            while (pSubTimer->u64NextTS < u64NanoTS)
-                pSubTimer->u64NextTS += pTimer->u64NanoInterval;
-            pSubTimer->ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u64NextTS - u64NanoTS);
+            while (pSubTimer->u.Std.u64NextTS < u64NanoTS)
+                pSubTimer->u.Std.u64NextTS += u64NanoInterval;
+            pSubTimer->u.Std.ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u.Std.u64NextTS - u64NanoTS);
         }
 
 # ifdef CONFIG_SMP
         if (pTimer->fSpecificCpu || pTimer->fAllCpus)
-            mod_timer_pinned(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
+            mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
         else
 # endif
-            mod_timer(&pSubTimer->LnxTimer, pSubTimer->ulNextJiffies);
-#endif
+            mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
 
         /*
@@ -434 +527 @@
         pTimer->pfnTimer(pTimer, pTimer->pvUser, iTick);
     }
-
-#ifdef RT_USE_LINUX_HRTIMER
-    return rc;
-#endif
-}
+}
+#endif /* !RTTIMER_LINUX_ONLY_HRTIMER */
+
 
 
@@ -455 +546 @@
     PRTTIMER pTimer = (PRTTIMER)pvUser1;
     Assert(idCpu < pTimer->cCpus);
-    rtTimerLnxStartSubTimer(&pTimer->aSubTimers[idCpu], pArgs->u64Now, pArgs->u64First, true /*fPinned*/);
+    rtTimerLnxStartSubTimer(&pTimer->aSubTimers[idCpu], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
 }
 
@@ -607 +698 @@
             PRTTIMERLNXSUBTIMER pSubTimer = &pTimer->aSubTimers[idCpu];
             if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
-                rtTimerLnxStartSubTimer(pSubTimer, pArgs->u64Now, pArgs->u64First, true /*fPinned*/);
+                rtTimerLnxStartSubTimer(pSubTimer, pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
         }
 
@@ -660 +751 @@
 
                     if (RTMpCpuId() == idCpu)
-                        rtTimerLnxStartSubTimer(pSubTimer, Args.u64Now, Args.u64First, true /*fPinned*/);
+                        rtTimerLnxStartSubTimer(pSubTimer, Args.u64Now, Args.u64First, true /*fPinned*/, pTimer->fHighRes);
                     else
                     {
@@ -708 +799 @@
     PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
     PRTTIMER pTimer = (PRTTIMER)pvUser1;
-    rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], pArgs->u64Now, pArgs->u64First, true /*fPinned*/);
+    rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
 }
 
@@ -742 +833 @@
     ASMAtomicWriteBool(&pTimer->fSuspended, false);
     if (!pTimer->fSpecificCpu)
-        rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], Args.u64Now, Args.u64First, false /*fPinned*/);
+    {
+        rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], Args.u64Now, Args.u64First, false /*fPinned*/, pTimer->fHighRes);
+    }
     else
     {
@@ -792 +885 @@
 
 
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    int rc = VINF_SUCCESS;
+
+    /*
+     * Validate.
+     */
+    AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
+    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(u64NanoInterval, VERR_INVALID_PARAMETER);
+
+    /*
+     * Make the change.
+     */
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    if (pTimer->fHighRes)
+# endif
+        ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+    else
+# endif
+#endif
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
+        rc = VERR_NOT_SUPPORTED; /** @todo Implement this if needed. */
+#endif
+
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTTimerChangeInterval);
+
+
 RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
 {
@@ -836 +961 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
-{
-    PRTTIMER pTimer;
-    RTCPUID  iCpu;
-    unsigned cCpus;
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+{
+    PRTTIMER    pTimer;
+    RTCPUID     iCpu;
+    unsigned    cCpus;
 
     *ppTimer = NULL;
@@ -851 +976 @@
     if (    (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
         &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
-        &&  !RTMpIsCpuOnline(fFlags & RTTIMER_FLAGS_CPU_MASK))
-        return (fFlags & RTTIMER_FLAGS_CPU_MASK) > RTMpGetMaxCpuId()
-             ? VERR_CPU_NOT_FOUND
-             : VERR_CPU_OFFLINE;
+        &&  !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
+        return VERR_CPU_NOT_FOUND;
 
     /*
@@ -879 +1002 @@
     pTimer->hSpinlock = NIL_RTSPINLOCK;
     pTimer->fSuspended = true;
+    pTimer->fHighRes = !!(fFlags & RTTIMER_FLAGS_HIGH_RES);
 #ifdef CONFIG_SMP
     pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
     pTimer->fAllCpus = (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL;
-    pTimer->idCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
+    pTimer->idCpu = pTimer->fSpecificCpu ? RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK) : NIL_RTCPUID;
 #else
     pTimer->fSpecificCpu = !!(fFlags & RTTIMER_FLAGS_CPU_SPECIFIC);
@@ -891 +1015 @@
     pTimer->pvUser = pvUser;
     pTimer->u64NanoInterval = u64NanoInterval;
-#ifndef RT_USE_LINUX_HRTIMER
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
     pTimer->cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
     if (pTimer->cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
@@ -899 +1023 @@
     for (iCpu = 0; iCpu < cCpus; iCpu++)
     {
-#ifdef RT_USE_LINUX_HRTIMER
-        hrtimer_init(&pTimer->aSubTimers[iCpu].LnxTimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-        pTimer->aSubTimers[iCpu].LnxTimer.function = rtTimerLinuxCallback;
-#else
-        init_timer(&pTimer->aSubTimers[iCpu].LnxTimer);
-        pTimer->aSubTimers[iCpu].LnxTimer.data     = (unsigned long)&pTimer->aSubTimers[iCpu];
-        pTimer->aSubTimers[iCpu].LnxTimer.function = rtTimerLinuxCallback;
-        pTimer->aSubTimers[iCpu].LnxTimer.expires  = jiffies;
-        pTimer->aSubTimers[iCpu].u64StartTS = 0;
-        pTimer->aSubTimers[iCpu].u64NextTS = 0;
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+        if (pTimer->fHighRes)
+# endif
+        {
+            hrtimer_init(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+            pTimer->aSubTimers[iCpu].u.Hr.LnxTimer.function = rtTimerLinuxHrCallback;
+        }
+# ifndef RTTIMER_LINUX_ONLY_HRTIMER
+        else
+# endif
+#endif
+#ifndef RTTIMER_LINUX_ONLY_HRTIMER
+        {
+            init_timer(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
+            pTimer->aSubTimers[iCpu].u.Std.LnxTimer.data     = (unsigned long)&pTimer->aSubTimers[iCpu];
+            pTimer->aSubTimers[iCpu].u.Std.LnxTimer.function = rtTimerLinuxStdCallback;
+            pTimer->aSubTimers[iCpu].u.Std.LnxTimer.expires  = jiffies;
+            pTimer->aSubTimers[iCpu].u.Std.u64StartTS = 0;
+            pTimer->aSubTimers[iCpu].u.Std.u64NextTS = 0;
+        }
 #endif
         pTimer->aSubTimers[iCpu].iTick = 0;
@@ -945 +1080 @@
 RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
 {
-#ifdef RT_USE_LINUX_HRTIMER
+#ifdef RTTIMER_LINUX_ONLY_HRTIMER
+    /** @todo Not sure if this is what we want or not... Add new API for
+     *        querying the resolution of the high res timers? */
     struct timespec Ts;
     int rc = hrtimer_get_res(CLOCK_MONOTONIC, &Ts);
@@ -975 +1112 @@
 RTDECL(bool) RTTimerCanDoHighResolution(void)
 {
-#ifdef RT_USE_LINUX_HRTIMER
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
     return true;
 #else

trunk/src/VBox/Runtime/r0drv/nt/timer-r0drv-nt.cpp

@@ -218 +218 @@
     if (!ASMAtomicUoReadBool(&pTimer->fSuspended))
         return VERR_TIMER_ACTIVE;
+    if (   pTimer->fSpecificCpu
+        && !RTMpIsCpuOnline(pTimer->idCpu))
+        return VERR_CPU_OFFLINE;
 
     /*
@@ -291 +294 @@
 
 
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
+    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
+
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
 {
@@ -300 +312 @@
 
     /*
-     * Invalidate the timer, stop it if it's running and finally                   .
+     * Invalidate the timer, stop it if it's running and finally
      * free up the memory.
      */
@@ -312 +324 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     *ppTimer = NULL;
@@ -323 +335 @@
     if (    (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
         &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
-        &&  !RTMpIsCpuOnline(fFlags & RTTIMER_FLAGS_CPU_MASK))
-        return (fFlags & RTTIMER_FLAGS_CPU_MASK) > RTMpGetMaxCpuId()
-             ? VERR_CPU_NOT_FOUND
-             : VERR_CPU_OFFLINE;
+        &&  !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
+        return VERR_CPU_NOT_FOUND;
 
     /*
@@ -349 +359 @@
     pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
     pTimer->fOmniTimer = (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL;
-    pTimer->idCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
+    pTimer->idCpu = pTimer->fSpecificCpu ? RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK) : NIL_RTCPUID;
     pTimer->cSubTimers = cSubTimers;
     pTimer->pfnTimer = pfnTimer;
@@ -362 +372 @@
          * ASSUMES that no cpus will ever go offline.
          */
-        pTimer->idCpu = NIL_RTCPUID; /* */
+        pTimer->idCpu = NIL_RTCPUID;
         for (unsigned iCpu = 0; iCpu < cSubTimers; iCpu++)
         {

trunk/src/VBox/Runtime/r0drv/os2/timer-r0drv-os2.cpp

@@ -109 +109 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     *ppTimer = NULL;
@@ -289 +289 @@
 
 
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    if (!rtTimerIsValid(pTimer))
+        return VERR_INVALID_HANDLE;
+
+    return VERR_NOT_SUPPORTED;
+}
+
+
 DECLASM(void) rtTimerOs2Tick(void)
 {

trunk/src/VBox/Runtime/r0drv/solaris/vbi/timer-r0drv-solaris.c

@@ -103 +103 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     RT_ASSERT_PREEMPTIBLE();
@@ -118 +118 @@
     if (    (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
         &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
-        &&  !RTMpIsCpuPossible((fFlags & RTTIMER_FLAGS_CPU_MASK)))
+        &&  !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
         return VERR_CPU_NOT_FOUND;
 
@@ -143 +143 @@
         pTimer->fAllCpu = false;
         pTimer->fSpecificCpu = true;
-        pTimer->iCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
+        pTimer->iCpu = fFlags & RTTIMER_FLAGS_CPU_MASK; /* ASSUMES: index == cpuid */
     }
     else
@@ -237 +237 @@
 
 
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    RTTIMER_ASSERT_VALID_RET(pTimer);
+
+    /** @todo implement me! */
+
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
 {
@@ -257 +267 @@
 RTDECL(bool) RTTimerCanDoHighResolution(void)
 {
-    return true;
-}
-
+    /** @todo return true; - when missing bits have been implemented and tested*/
+    return false;
+}
+

trunk/src/VBox/Runtime/r3/posix/timer-posix.cpp

@@ -397 +397 @@
 
 
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
+RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
 {
     /*
@@ -811 +811 @@
 }
 
+
+RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
+{
+    AssertPtrReturn(pTimer, VERR_INVALID_POINTER);
+    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_MAGIC);
+    return VERR_NOT_SUPPORTED;
+}
+