Changeset 39004 in vbox for trunk/src/VBox/Runtime/r0drv/linux

Timestamp:

Oct 17, 2011 2:12:14 PM (14 years ago)

Author:

vboxsync

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

74405

Message:

timer-r0drv-linux.c, ++: Don't use del_timer_sync when calling from a handler since we're in an atomic context and trigger the WARN_ON in del_timer_sync().

Location:

trunk/src/VBox/Runtime/r0drv/linux

Files:

• initterm-r0drv-linux.c (modified) (4 diffs)
• the-linux-kernel.h (modified) (3 diffs)
• timer-r0drv-linux.c (modified) (10 diffs)

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -37 +37 @@
 
 /*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+/** The IPRT work queue. */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+static struct workqueue_struct *g_prtR0LnxWorkQueue;
+#else
+static DECLARE_TASK_QUEUE(g_rtR0LnxWorkQueue);
+#endif
+
+
+/*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
@@ -45 +56 @@
 
 
+/**
+ * Pushes an item onto the IPRT work queue.
+ *
+ * @param   pWork               The work item.
+ * @param   pfnWorker           The callback function.  It will be called back
+ *                              with @a pWork as argument.
+ */
+DECLHIDDEN(void) rtR0LnxWorkqueuePush(RTR0LNXWORKQUEUEITEM *pWork, void (*pfnWorker)(RTR0LNXWORKQUEUEITEM *))
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+    INIT_WORK(pWork, pfnWorker);
+    queue_work(g_prtR0LnxWorkQueue, pWork);
+#else
+    INIT_TQUEUE(pWork, pfnWorker, pWork);
+    queue_task(pWork, &g_rtR0LnxWorkQueue);
+#endif
+}
+
+
+/**
+ * Flushes all items in the IPRT work queue.
+ *
+ * @remarks This is mostly for 2.4.x compatability.  Must not be called from
+ *          atomic contexts or with unncessary locks held.
+ */
+DECLHIDDEN(void) rtR0LnxWorkqueueFlush(void)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+    flush_workqueue(g_prtR0LnxWorkQueue);
+#else
+    run_task_queue(&g_rtR0LnxWorkQueue);
+#endif
+}
+
+
 DECLHIDDEN(int) rtR0InitNative(void)
 {
+    g_prtR0LnxWorkQueue = create_workqueue("iprt");
+    if (!g_prtR0LnxWorkQueue)
+        return VERR_NO_MEMORY;
+
     return VINF_SUCCESS;
 }
@@ -53 +103 @@
 DECLHIDDEN(void) rtR0TermNative(void)
 {
+    rtR0LnxWorkqueueFlush();
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+    destroy_workqueue(g_prtR0LnxWorkQueue);
+    g_prtR0LnxWorkQueue = NULL;
+#endif
+
 #ifdef RT_ARCH_AMD64
     rtR0MemExecCleanup();

trunk/src/VBox/Runtime/r0drv/linux/the-linux-kernel.h

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -119 +119 @@
 #include <asm/div64.h>
 
+/* for workqueue / task queues. */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+# include <linux/workqueue.h>
+#else
+# include <linux/tqueue.h>
+#endif
+
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
 # include <linux/kthread.h>
@@ -368 +375 @@
 #endif
 
-#endif
+/*
+ * Workqueue stuff, see initterm-r0drv-linux.c.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
+typedef struct work_struct  RTR0LNXWORKQUEUEITEM;
+#else
+typedef struct tq_struct    RTR0LNXWORKQUEUEITEM;
+#endif
+DECLHIDDEN(void) rtR0LnxWorkqueuePush(RTR0LNXWORKQUEUEITEM *pWork, void (*pfnWorker)(RTR0LNXWORKQUEUEITEM *));
+DECLHIDDEN(void) rtR0LnxWorkqueueFlush(void);
+
+
+#endif

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2010 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -175 +175 @@
     /** The change interval spinlock for standard timers only. */
     spinlock_t              ChgIntLock;
+    /** Workqueue item for delayed destruction. */
+    RTR0LNXWORKQUEUEITEM    DtorWorkqueueItem;
     /** Sub-timers.
      * Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
@@ -386 +388 @@
 #ifdef RTTIMER_LINUX_WITH_HRTIMER
     if (fHighRes)
-        hrtimer_cancel(&pSubTimer->u.Hr.LnxTimer);
+    {
+        /* There is no equivalent to del_timer in the hrtimer API,
+           hrtimer_cancel() == del_timer_sync().  Just like the WARN_ON in
+           del_timer_sync() asserts, waiting for a timer callback to complete
+           is deadlock prone, so don't do it.  */
+        int rc = hrtimer_try_to_cancel(&pSubTimer->u.Hr.LnxTimer);
+        if (rc < 0)
+        {
+            hrtimer_start(&pSubTimer->u.Hr.LnxTimer, ktime_set(KTIME_SEC_MAX, 0), HRTIMER_MODE_ABS);
+            hrtimer_try_to_cancel(&pSubTimer->u.Hr.LnxTimer);
+        }
+    }
     else
 #endif
-    {
-        if (timer_pending(&pSubTimer->u.Std.LnxTimer))
-            del_timer_sync(&pSubTimer->u.Std.LnxTimer);
-    }
+        del_timer(&pSubTimer->u.Std.LnxTimer);
 
     rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED);
@@ -405 +415 @@
 static void rtTimerLnxDestroyIt(PRTTIMER pTimer)
 {
-    RTSPINLOCK hSpinlock = pTimer->hSpinlock;
+    RTSPINLOCK  hSpinlock = pTimer->hSpinlock;
+    RTCPUID     iCpu;
     Assert(pTimer->fSuspended);
     RTTIMERLNX_LOG(("destroyit %p\n", pTimer));
@@ -423 +434 @@
 
     /*
-     * Uninitialize the structure and free the associated resources.
-     * The spinlock goes last.
+     * Invalidate the handle.
      */
     ASMAtomicWriteU32(&pTimer->u32Magic, ~RTTIMER_MAGIC);
+
+    /*
+     * Make sure all timers have stopped executing since we're stopping them in
+     * an asynchronous manner up in rtTimerLnxStopSubTimer.
+     */
+    iCpu = pTimer->cCpus;
+    while (iCpu-- > 0)
+    {
+#ifdef RTTIMER_LINUX_WITH_HRTIMER
+        if (pTimer->fHighRes)
+            hrtimer_cancel(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer);
+        else
+#endif
+            del_timer_sync(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
+    }
+
+    /*
+     * Finally, free the resources.
+     */
     RTMemFreeEx(pTimer, RT_OFFSETOF(RTTIMER, aSubTimers[pTimer->cCpus]));
     if (hSpinlock != NIL_RTSPINLOCK)
         RTSpinlockDestroy(hSpinlock);
+}
+
+
+/**
+ * Workqueue callback (no DECLCALLBACK!) for deferred destruction.
+ *
+ * @param   pWork        Pointer to the DtorWorkqueueItem member of our timer
+ *                       structure.
+ */
+static void rtTimerLnxDestroyDeferred(RTR0LNXWORKQUEUEITEM *pWork)
+{
+    PRTTIMER pTimer = RT_FROM_MEMBER(pWork, RTTIMER, DtorWorkqueueItem);
+    rtTimerLnxDestroyIt(pTimer);
 }
 
@@ -464 +506 @@
     }
 
-    rtTimerLnxDestroyIt(pTimer);
+    /*
+     * Destroying a timer from the callback is unsafe since the callout code
+     * might be touching the timer structure upon return (hrtimer does!).  So,
+     * we have to defer the actual destruction to the IRPT workqueue.
+     */
+    rtR0LnxWorkqueuePush(&pTimer->DtorWorkqueueItem, rtTimerLnxDestroyDeferred);
 }
 
@@ -933 +980 @@
     RTSPINLOCKTMP   Tmp = RTSPINLOCKTMP_INITIALIZER;
     RTCPUID         iCpu;
+    RTTIMERLNXSTATE enmState;
 
 
@@ -944 +992 @@
     for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
     {
-        RTTIMERLNXSTATE enmState;
         for (;;)
         {
@@ -978 +1025 @@
     /*
      * Do the actual stopping. Fortunately, this doesn't require any IPIs.
-     * Unfortunately it cannot be done synchronously from within the spinlock,
-     * because we might end up in an active waiting for a handler to complete.
+     * Unfortunately it cannot be done synchronously.
      */
     for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
@@ -1419 +1465 @@
     int         rc;
 
+    rtR0LnxWorkqueueFlush();                /* for 2.4 */
     *ppTimer = NULL;