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

Timestamp:

Sep 23, 2010 4:20:05 PM (14 years ago)

Author:

vboxsync

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

66176

Message:

timer-r0drv-linux.c: Fixes.

File:

• trunk/src/VBox/Runtime/r0drv/linux/timer-r0drv-linux.c (modified) (22 diffs)

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

@@ -123 +123 @@
             /** 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;
+            /** Set when starting or changing the timer so that u64StartTs
+             *  and u64NextTS gets reinitialized (eliminating some jitter). */
+            bool volatile           fFirstAfterChg;
         } Std;
     } u;
-    /** The current tick number (since u.Std.u64StartTS). */
+    /** The current tick number. */
     uint64_t                iTick;
     /** Restart the single shot timer at this specific time.
@@ -179 +179 @@
     /** This is set to the number of jiffies between ticks if the interval is
      * an exact number of jiffies. (Standard timers only.) */
-    unsigned long           cJiffies;
+    unsigned long volatile  cJiffies;
+    /** The change interval spinlock for standard timers only. */
+    spinlock_t              ChgIntLock;
     /** Sub-timers.
      * Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
@@ -193 +195 @@
 typedef struct RTTIMERLINUXSTARTONCPUARGS
 {
-    /** The current time (RTTimeNanoTS). */
+    /** The current time (RTTimeSystemNanoTS). */
     uint64_t                u64Now;
     /** When to start firing (delta). */
@@ -284 +286 @@
  * Converts a nano second time stamp to ktime_t.
  *
- * ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
+ * ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
  *
  * @returns ktime_t.
@@ -298 +300 @@
  * Converts ktime_t to a nano second time stamp.
  *
- * ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
+ * ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
  *
  * @returns nano second time stamp.
@@ -333 +335 @@
  *
  * @param   pSubTimer   The sub-timer to start.
- * @param   u64Now      The current timestamp (RTTimeNanoTS()).
+ * @param   u64Now      The current timestamp (RTTimeSystemNanoTS()).
  * @param   u64First    The interval from u64Now to the first time the timer should fire.
  * @param   fPinned     true = timer pinned to a specific CPU,
@@ -348 +350 @@
     uint64_t u64NextTS = u64Now + u64First;
     if (fHighRes)
-    {
-        pSubTimer->u.Std.u64StartTS = u64NextTS;
-        pSubTimer->u.Std.u64NextTS  = u64NextTS;
-    }
+        pSubTimer->u.Std.u64NextTS = u64NextTS;
     dprintf(("startsubtimer %p\n", pSubTimer->pParent));
 
@@ -364 +363 @@
     {
         unsigned long cJiffies = !u64First ? 0 : rtTimerLnxNanoToJiffies(u64First);
-        pSubTimer->u.Std.ulNextJiffies = jiffies + cJiffies;
+        pSubTimer->u.Std.ulNextJiffies  = jiffies + cJiffies;
+        pSubTimer->u.Std.fFirstAfterChg = true;
 #ifdef CONFIG_SMP
         if (fPinned)
@@ -697 +697 @@
     {
         /*
-         * Interval timer, calculate the next timeout and re-arm it.
+         * Interval timer, calculate the next timeout.
          *
-         * The first time around, we'll re-adjust the u.Std.u64StartTS to
+         * The first time around, we'll re-adjust the u.Std.u64NextTS to
          * try prevent some jittering if we were started at a bad time.
          */
-        const uint64_t u64NanoInterval  = pTimer->u64NanoInterval;
-        const uint64_t iTick            = ++pSubTimer->iTick;
-        const uint64_t u64NanoTS        = RTTimeNanoTS();
-
-        if (RT_UNLIKELY(iTick == 1))
-        {
-            pSubTimer->u.Std.u64StartTS    = u64NanoTS;
-            pSubTimer->u.Std.u64NextTS     = u64NanoTS;
-            pSubTimer->u.Std.ulNextJiffies = jiffies;
-        }
+        const uint64_t  iTick = ++pSubTimer->iTick;
+        uint64_t        u64NanoInterval;
+        unsigned long   cJiffies;
+        unsigned long   flFlags;
+
+        spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
+        u64NanoInterval = pTimer->u64NanoInterval;
+        cJiffies        = pTimer->cJiffies;
+        if (RT_UNLIKELY(pSubTimer->u.Std.fFirstAfterChg))
+        {
+            pSubTimer->u.Std.fFirstAfterChg = false;
+            pSubTimer->u.Std.u64NextTS      = RTTimeSystemNanoTS();
+            pSubTimer->u.Std.ulNextJiffies  = jiffies;
+        }
+        spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
 
         pSubTimer->u.Std.u64NextTS += u64NanoInterval;
-        if (pTimer->cJiffies)
-        {
-            pSubTimer->u.Std.ulNextJiffies += pTimer->cJiffies;
+        if (cJiffies)
+        {
+            pSubTimer->u.Std.ulNextJiffies += cJiffies;
             /* Prevent overflows when the jiffies counter wraps around.
              * Special thanks to Ken Preslan for helping debugging! */
             while (time_before(pSubTimer->u.Std.ulNextJiffies, jiffies))
             {
-                pSubTimer->u.Std.ulNextJiffies += pTimer->cJiffies;
+                pSubTimer->u.Std.ulNextJiffies += cJiffies;
                 pSubTimer->u.Std.u64NextTS     += u64NanoInterval;
             }
@@ -727 +732 @@
         else
         {
+            const uint64_t u64NanoTS = RTTimeSystemNanoTS();
             while (pSubTimer->u.Std.u64NextTS < u64NanoTS)
                 pSubTimer->u.Std.u64NextTS += u64NanoInterval;
@@ -732 +738 @@
         }
 
-#ifdef CONFIG_SMP
-        if (pTimer->fSpecificCpu || pTimer->fAllCpus)
-            mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
-        else
-#endif
-            mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
-
         /*
-         * Run the timer.
+         * Run the timer and re-arm it unless the state changed                                                                                                        .
+         *                                                                                                                                                             .
+         * We must re-arm it afterwards as we're not in a position to undo this                                                                                        .
+         * operation if for instance someone stopped or destroyed us while we                                                                                          .
+         * were in the callback.  (Linux takes care of any races here.)
          */
         pTimer->pfnTimer(pTimer, pTimer->pvUser, iTick);
         if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CALLBACK)))
+        {
+#ifdef CONFIG_SMP
+            if (pTimer->fSpecificCpu || pTimer->fAllCpus)
+                mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
+            else
+#endif
+                mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
             return;
+        }
     }
     else
@@ -762 +773 @@
      * Some state change occured while we were in the callback routine.
      */
-    if (pTimer->u64NanoInterval)
-        del_timer_sync(&pSubTimer->u.Std.LnxTimer);
     for (;;)
     {
@@ -781 +790 @@
                 if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CB_RESTARTING))
                 {
-                    const uint64_t u64NanoTS = RTTimeNanoTS();
-                    const uint64_t u64NextTS = pSubTimer->uNsRestartAt;
-                    if (pTimer->fHighRes)
-                    {
-                        pSubTimer->u.Std.u64StartTS = u64NextTS;
-                        pSubTimer->u.Std.u64NextTS  = u64NextTS;
-                    }
-                    pSubTimer->iTick = 0;
-                    pSubTimer->u.Std.ulNextJiffies = u64NextTS > u64NanoTS
-                                                   ? jiffies + rtTimerLnxNanoToJiffies(u64NextTS - u64NanoTS)
-                                                   : jiffies;
+                    uint64_t        u64NanoTS;
+                    uint64_t        u64NextTS;
+                    unsigned long   flFlags;
+
+                    spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
+                    u64NextTS = pSubTimer->uNsRestartAt;
+                    u64NanoTS = RTTimeSystemNanoTS();
+                    pSubTimer->iTick                = 0;
+                    pSubTimer->u.Std.u64NextTS      = u64NextTS;
+                    pSubTimer->u.Std.fFirstAfterChg = true;
+                    pSubTimer->u.Std.ulNextJiffies  = u64NextTS > u64NanoTS
+                                                    ? jiffies + rtTimerLnxNanoToJiffies(u64NextTS - u64NanoTS)
+                                                    : jiffies;
+                    spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
+
 #ifdef CONFIG_SMP
                     if (pTimer->fSpecificCpu || pTimer->fAllCpus)
@@ -881 +894 @@
      * do this without the cross calls).
      */
-    pArgs->u64Now = RTTimeNanoTS();
+    pArgs->u64Now = RTTimeSystemNanoTS();
     rc2 = RTMpOnAll(rtTimerLnxStartAllOnCpu, pTimer, pArgs);
     AssertRC(rc2); /* screw this if it fails. */
@@ -1054 +1067 @@
                 {
                     RTTIMERLINUXSTARTONCPUARGS Args;
-                    Args.u64Now = RTTimeNanoTS();
+                    Args.u64Now = RTTimeSystemNanoTS();
                     Args.u64First = 0;
 
@@ -1153 +1166 @@
      * Simple timer - Pretty straight forward if it wasn't for restarting.
      */
-    Args.u64Now = RTTimeNanoTS();
+    Args.u64Now = RTTimeSystemNanoTS();
     ASMAtomicWriteU64(&pTimer->aSubTimers[0].uNsRestartAt, Args.u64Now + u64First);
     for (;;)
@@ -1229 +1242 @@
         {
             case RTTIMERLNXSTATE_ACTIVE:
-                if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_MP_STOPPING, RTTIMERLNXSTATE_ACTIVE))
+                if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STOPPING, RTTIMERLNXSTATE_ACTIVE))
                 {
                     rtTimerLnxStopSubTimer(&pTimer->aSubTimers[0], pTimer->fHighRes);
@@ -1241 +1254 @@
                 Assert(enmState != RTTIMERLNXSTATE_CB_STOPPING || fForDestroy);
                 if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState,
-                                           !fForDestroy ? RTTIMERLNXSTATE_STOPPED : RTTIMERLNXSTATE_CB_DESTROYING,
+                                           !fForDestroy ? RTTIMERLNXSTATE_CB_STOPPING : RTTIMERLNXSTATE_CB_DESTROYING,
                                            enmState))
                     return true;
@@ -1288 +1301 @@
 RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
 {
+    unsigned long cJiffies;
+    unsigned long flFlags;
+
     /*
      * Validate.
@@ -1314 +1330 @@
     if (pTimer->cCpus > 1)
         return VERR_NOT_SUPPORTED;
-    RTTimerStop(pTimer);
-    return RTTimerStart(pTimer, u64NanoInterval);
+
+    cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
+    if (cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
+        cJiffies = 0;
+
+    spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
+    pTimer->aSubTimers[0].u.Std.fFirstAfterChg = true;
+    pTimer->cJiffies = cJiffies;
+    ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
+    spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
+    return VINF_SUCCESS;
 }
 RT_EXPORT_SYMBOL(RTTimerChangeInterval);
@@ -1445 +1470 @@
     if (pTimer->cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
         pTimer->cJiffies    = 0;
+    spin_lock_init(&pTimer->ChgIntLock);
 
     for (iCpu = 0; iCpu < cCpus; iCpu++)
@@ -1461 +1487 @@
             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;
         }