Changeset 36233 in vbox

Timestamp:

Mar 9, 2011 5:05:12 PM (14 years ago)

Author:

vboxsync

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

70454

Message:

IPRT: linux R0 threads

Location:

trunk/src/VBox

Files:

• HostDrivers/Support/SUPDrv.c (modified) (2 diffs)
• HostDrivers/Support/linux/Makefile (modified) (2 diffs)
• HostDrivers/Support/linux/files_vboxdrv (modified) (3 diffs)
• Runtime/common/misc/thread.cpp (modified) (21 diffs)
• Runtime/common/table/avl_Base.cpp.h (modified) (1 diff)
• Runtime/r0drv/initterm-r0drv.cpp (modified) (3 diffs)
• Runtime/r0drv/linux/the-linux-kernel.h (modified) (2 diffs)
• Runtime/r0drv/linux/thread2-r0drv-linux.c (modified) (1 diff)

trunk/src/VBox/HostDrivers/Support/SUPDrv.c

@@ -289 +289 @@
     { "RTThreadUserWait",                       (void *)RTThreadUserWait },
     { "RTThreadUserWaitNoResume",               (void *)RTThreadUserWaitNoResume },
+#else 
+    /**  
+     * @todo: remove me, once above code enabled.  
+     * We need RTThreadCreate/RTThreadWait in the PCI driver. 
+     */ 
+    { "RTThreadCreate",                         (void *)RTThreadCreate }, 
+    { "RTThreadWait",                           (void *)RTThreadWait }, 
 #endif
     { "RTThreadPreemptIsEnabled",               (void *)RTThreadPreemptIsEnabled },
@@ -5468 +5475 @@
     }
 }
-

trunk/src/VBox/HostDrivers/Support/linux/Makefile

@@ -119 +119 @@
         common/misc/handletable.o \
         common/misc/handletablectx.o \
+        common/misc/thread.o \
         common/string/strformat.o \
         common/string/strformatrt.o \
@@ -124 +125 @@
         common/string/strprintf.o \
         common/string/strtonum.o \
+        common/table/avlpv.o \
         common/time/time.o \
         r0drv/linux/RTLogWriteDebugger-r0drv-linux.o \

trunk/src/VBox/HostDrivers/Support/linux/files_vboxdrv

@@ -111 +111 @@
     ${PATH_ROOT}/src/VBox/Runtime/common/misc/handletable.h=>common/misc/handletable.h \
     ${PATH_ROOT}/src/VBox/Runtime/common/misc/handletablectx.cpp=>common/misc/handletablectx.c \
+    ${PATH_ROOT}/src/VBox/Runtime/common/misc/thread.cpp=>common/misc/thread.c \
     ${PATH_ROOT}/src/VBox/Runtime/common/string/strformat.cpp=>common/string/strformat.c \
     ${PATH_ROOT}/src/VBox/Runtime/common/string/strformatrt.cpp=>common/string/strformatrt.c \
@@ -116 +117 @@
     ${PATH_ROOT}/src/VBox/Runtime/common/string/strprintf.cpp=>common/string/strprintf.c \
     ${PATH_ROOT}/src/VBox/Runtime/common/string/strtonum.cpp=>common/string/strtonum.c \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avlpv.cpp=>common/table/avlpv.c \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_Base.cpp.h=>common/table/avl_Base.cpp.h \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_Get.cpp.h=>common/table/avl_Get.cpp.h \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_GetBestFit.cpp.h=>common/table/avl_GetBestFit.cpp.h \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_RemoveBestFit.cpp.h=>common/table/avl_RemoveBestFit.cpp.h \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_DoWithAll.cpp.h=>common/table/avl_DoWithAll.cpp.h \
+    ${PATH_ROOT}/src/VBox/Runtime/common/table/avl_Destroy.cpp.h=>common/table/avl_Destroy.cpp.h \
     ${PATH_ROOT}/src/VBox/Runtime/common/time/time.cpp=>common/time/time.c \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/assert.h=>include/internal/assert.h \
@@ -124 +132 @@
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/memobj.h=>include/internal/memobj.h \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/string.h=>include/internal/string.h \
+    ${PATH_ROOT}/src/VBox/Runtime/include/internal/sched.h=>include/internal/sched.h \
+    ${PATH_ROOT}/src/VBox/Runtime/include/internal/process.h=>include/internal/process.h \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/thread.h=>include/internal/thread.h \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/time.h=>include/internal/time.h \

trunk/src/VBox/Runtime/common/misc/thread.cpp

@@ -155 +155 @@
 
 #elif defined(IN_RING0)
-
+    int rc;
     /*
      * Create the spinlock and to native init.
      */
     Assert(g_ThreadSpinlock == NIL_RTSPINLOCK);
-    int rc = RTSpinlockCreate(&g_ThreadSpinlock);
+    rc = RTSpinlockCreate(&g_ThreadSpinlock);
     if (RT_SUCCESS(rc))
     {
@@ -238 +238 @@
 static int rtThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, uint32_t fIntFlags, const char *pszName)
 {
+    int rc;
+    PRTTHREADINT pThread;
     Assert(!(fFlags & RTTHREADFLAGS_WAITABLE));
     fFlags &= ~RTTHREADFLAGS_WAITABLE;
@@ -246 +248 @@
      * we try inserting the thread because of locking.)
      */
-    int rc = VERR_NO_MEMORY;
-    PRTTHREADINT pThread = rtThreadAlloc(enmType, fFlags, RTTHREADINT_FLAGS_ALIEN | fIntFlags, pszName);
+    rc = VERR_NO_MEMORY;
+    pThread = rtThreadAlloc(enmType, fFlags, RTTHREADINT_FLAGS_ALIEN | fIntFlags, pszName);
     if (pThread)
     {
@@ -274 +276 @@
 RTDECL(int) RTThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, const char *pszName, PRTTHREAD pThread)
 {
+    int      rc;
+    RTTHREAD Thread;
+
     AssertReturn(!(fFlags & RTTHREADFLAGS_WAITABLE), VERR_INVALID_PARAMETER);
     AssertReturn(!pszName || VALID_PTR(pszName), VERR_INVALID_POINTER);
     AssertReturn(!pThread || VALID_PTR(pThread), VERR_INVALID_POINTER);
 
-    int      rc = VINF_SUCCESS;
-    RTTHREAD Thread = RTThreadSelf();
+    rc = VINF_SUCCESS;
+    Thread = RTThreadSelf();
     if (Thread == NIL_RTTHREAD)
     {
@@ -341 +346 @@
     if (pThread)
     {
+        size_t cchName;
+        int rc;
+
         pThread->Core.Key   = (void*)NIL_RTTHREAD;
         pThread->u32Magic   = RTTHREADINT_MAGIC;
-        size_t cchName = strlen(pszName);
+        cchName = strlen(pszName);
         if (cchName >= RTTHREAD_NAME_LEN)
             cchName = RTTHREAD_NAME_LEN - 1;
@@ -361 +369 @@
         rtStrIconvCacheInit(pThread);
 #endif
-        int rc = RTSemEventMultiCreate(&pThread->EventUser);
+        rc = RTSemEventMultiCreate(&pThread->EventUser);
         if (RT_SUCCESS(rc))
         {
@@ -389 +397 @@
     Assert(pThread->u32Magic == RTTHREADINT_MAGIC);
 
-    RT_THREAD_LOCK_TMP(Tmp);
-    RT_THREAD_LOCK_RW(Tmp);
-
-    /*
-     * Do not insert a terminated thread.
-     *
-     * This may happen if the thread finishes before the RTThreadCreate call
-     * gets this far. Since the OS may quickly reuse the native thread ID
-     * it should not be reinserted at this point.
-     */
-    if (rtThreadGetState(pThread) != RTTHREADSTATE_TERMINATED)
-    {
+    {
+        RT_THREAD_LOCK_TMP(Tmp);
+        RT_THREAD_LOCK_RW(Tmp);
+
         /*
-         * Before inserting we must check if there is a thread with this id
-         * in the tree already. We're racing parent and child on insert here
-         * so that the handle is valid in both ends when they return / start.
+         * Do not insert a terminated thread.
          *
-         * If it's not ourself we find, it's a dead alien thread and we will
-         * unlink it from the tree. Alien threads will be released at this point.
+         * This may happen if the thread finishes before the RTThreadCreate call
+         * gets this far. Since the OS may quickly reuse the native thread ID
+         * it should not be reinserted at this point.
          */
-        PRTTHREADINT pThreadOther = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
-        if (pThreadOther != pThread)
+        if (rtThreadGetState(pThread) != RTTHREADSTATE_TERMINATED)
         {
-            /* remove dead alien if any */
-            if (pThreadOther)
+            /*
+             * Before inserting we must check if there is a thread with this id
+             * in the tree already. We're racing parent and child on insert here
+             * so that the handle is valid in both ends when they return / start.
+             *
+             * If it's not ourself we find, it's a dead alien thread and we will
+             * unlink it from the tree. Alien threads will be released at this point.
+             */
+            PRTTHREADINT pThreadOther = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
+            if (pThreadOther != pThread)
             {
-                AssertMsg(pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN, ("%p:%s; %p:%s\n", pThread, pThread->szName, pThreadOther, pThreadOther->szName));
-                ASMAtomicBitClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT);
-                rtThreadRemoveLocked(pThreadOther);
-                if (pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
+                bool fRc;
+                /* remove dead alien if any */
+                if (pThreadOther)
+                {
+                    AssertMsg(pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN, ("%p:%s; %p:%s\n", pThread, pThread->szName, pThreadOther, pThreadOther->szName));
+                    ASMAtomicBitClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT);
+                    rtThreadRemoveLocked(pThreadOther);
+                    if (pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
                     rtThreadRelease(pThreadOther);
+                }
+
+                /* insert the thread */
+                ASMAtomicWritePtr(&pThread->Core.Key, (void *)NativeThread);
+                fRc = RTAvlPVInsert(&g_ThreadTree, &pThread->Core);
+                ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE);
+
+                AssertReleaseMsg(fRc, ("Lock problem? %p (%RTnthrd) %s\n", pThread, NativeThread, pThread->szName));
+                NOREF(fRc);
             }
-
-            /* insert the thread */
-            ASMAtomicWritePtr(&pThread->Core.Key, (void *)NativeThread);
-            bool fRc = RTAvlPVInsert(&g_ThreadTree, &pThread->Core);
-            ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE);
-
-            AssertReleaseMsg(fRc, ("Lock problem? %p (%RTnthrd) %s\n", pThread, NativeThread, pThread->szName));
-            NOREF(fRc);
         }
-    }
-
-    RT_THREAD_UNLOCK_RW(Tmp);
+
+        RT_THREAD_UNLOCK_RW(Tmp);
+    }
 }
 
@@ -489 +500 @@
 PRTTHREADINT rtThreadGetByNative(RTNATIVETHREAD NativeThread)
 {
+    PRTTHREADINT pThread;
     /*
      * Simple tree lookup.
@@ -494 +506 @@
     RT_THREAD_LOCK_TMP(Tmp);
     RT_THREAD_LOCK_RD(Tmp);
-    PRTTHREADINT pThread = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
+    pThread = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
     RT_THREAD_UNLOCK_RD(Tmp);
     return pThread;
@@ -534 +546 @@
 uint32_t rtThreadRelease(PRTTHREADINT pThread)
 {
+    uint32_t cRefs;
+
     Assert(pThread);
-    uint32_t cRefs;
     if (pThread->cRefs >= 1)
     {
@@ -558 +571 @@
 static void rtThreadDestroy(PRTTHREADINT pThread)
 {
+    RTSEMEVENTMULTI hEvt1, hEvt2;
     /*
      * Remove it from the tree and mark it as dead.
@@ -588 +602 @@
     ASMAtomicWritePtr(&pThread->Core.Key, (void *)NIL_RTTHREAD);
     pThread->enmType         = RTTHREADTYPE_INVALID;
-    RTSEMEVENTMULTI hEvt1    = pThread->EventUser;
+    hEvt1    = pThread->EventUser;
     pThread->EventUser       = NIL_RTSEMEVENTMULTI;
-    RTSEMEVENTMULTI hEvt2    = pThread->EventTerminated;
+    hEvt2    = pThread->EventTerminated;
     pThread->EventTerminated = NIL_RTSEMEVENTMULTI;
 
@@ -657 +671 @@
 int rtThreadMain(PRTTHREADINT pThread, RTNATIVETHREAD NativeThread, const char *pszThreadName)
 {
+    int rc;
     NOREF(pszThreadName);
     rtThreadInsert(pThread, NativeThread);
@@ -665 +680 @@
      * Change the priority.
      */
-    int rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
+    rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
 #ifdef IN_RING3
     AssertMsgRC(rc, ("Failed to set priority of thread %p (%RTnthrd / %s) to enmType=%d enmPriority=%d rc=%Rrc\n",
@@ -714 +729 @@
                            RTTHREADTYPE enmType, unsigned fFlags, const char *pszName)
 {
+    int             rc;
+    PRTTHREADINT    pThreadInt;
+
     LogFlow(("RTThreadCreate: pThread=%p pfnThread=%p pvUser=%p cbStack=%#x enmType=%d fFlags=%#x pszName=%p:{%s}\n",
              pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszName, pszName));
@@ -744 +762 @@
      * Allocate thread argument.
      */
-    int             rc;
-    PRTTHREADINT    pThreadInt = rtThreadAlloc(enmType, fFlags, 0, pszName);
+    pThreadInt = rtThreadAlloc(enmType, fFlags, 0, pszName);
     if (pThreadInt)
     {
+        RTNATIVETHREAD NativeThread;
+
         pThreadInt->pfnThread = pfnThread;
         pThreadInt->pvUser    = pvUser;
         pThreadInt->cbStack   = cbStack;
 
-        RTNATIVETHREAD NativeThread;
         rc = rtThreadNativeCreate(pThreadInt, &NativeThread);
         if (RT_SUCCESS(rc))
@@ -820 +838 @@
 {
     va_list va;
+    int rc;
     va_start(va, pszNameFmt);
-    int rc = RTThreadCreateV(pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszNameFmt, va);
+    rc = RTThreadCreateV(pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszNameFmt, va);
     va_end(va);
     return rc;
@@ -898 +917 @@
 RTDECL(const char *) RTThreadGetName(RTTHREAD Thread)
 {
+    PRTTHREADINT pThread;
     if (Thread == NIL_RTTHREAD)
         return NULL;
-    PRTTHREADINT pThread = rtThreadGet(Thread);
+    pThread = rtThreadGet(Thread);
     if (pThread)
     {
@@ -924 +944 @@
      * Validate input.
      */
+    PRTTHREADINT pThread;
     size_t cchName = strlen(pszName);
     if (cchName >= RTTHREAD_NAME_LEN)
@@ -930 +951 @@
         return VERR_INVALID_PARAMETER;
     }
-    PRTTHREADINT pThread = rtThreadGet(Thread);
+    pThread = rtThreadGet(Thread);
     if (!pThread)
         return VERR_INVALID_HANDLE;
@@ -1462 +1483 @@
 
 #endif /* IPRT_WITH_GENERIC_TLS */
-

trunk/src/VBox/Runtime/common/table/avl_Base.cpp.h

@@ -295 +295 @@
     KAVLSTACK               AVLStack;
     PPKAVLNODECORE          ppCurNode = ppTree;
+    register PKAVLNODECORE  pCurNode;
     register KAVLKEY        Key = pNode->Key; NOREF(Key);
 #ifdef KAVL_RANGE
     register KAVLKEY        KeyLast = pNode->KeyLast; NOREF(KeyLast);
 #endif
-    register PKAVLNODECORE  pCurNode;
 
     AVLStack.cEntries = 0;

trunk/src/VBox/Runtime/r0drv/initterm-r0drv.cpp

@@ -79 +79 @@
     if (RT_SUCCESS(rc))
     {
-#if !defined(RT_OS_LINUX) /** @todo implement thread2-r0drv-linux.c */
         rc = rtThreadInit();
-#endif
         if (RT_SUCCESS(rc))
         {
@@ -97 +95 @@
                 return rc;
 #endif
-#if !defined(RT_OS_LINUX) /** @todo implement thread2-r0drv-linux.c */
             rtThreadTerm();
-#endif
         }
         rtR0TermNative();
@@ -110 +106 @@
 static void rtR0Term(void)
 {
-#if !defined(RT_OS_LINUX) /** @todo implement thread2-r0drv-linux.c */
     rtThreadTerm();
-#endif
 #ifndef IN_GUEST /* play safe for now */
     rtR0PowerNotificationTerm();

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

@@ -119 +119 @@
 #include <asm/div64.h>
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
+# include <linux/kthread.h>
+#endif
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
 # ifndef page_to_pfn
@@ -364 +368 @@
 #endif
 
-
-#endif
-
+#endif

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

@@ -38 +38 @@
 
 
-/** @todo Later.
 RTDECL(RTTHREAD) RTThreadSelf(void)
 {
     return rtThreadGetByNative((RTNATIVETHREAD)current);
 }
-*/
 
+int rtThreadNativeInit(void)
+{
+    return VINF_SUCCESS;
+}
+
+int rtThreadNativeSetPriority(PRTTHREADINT pThread, RTTHREADTYPE enmType)
+{
+    int Priority = 0;
+    switch (enmType)
+    {
+        case RTTHREADTYPE_INFREQUENT_POLLER:    Priority = 9; break;
+        case RTTHREADTYPE_EMULATION:            Priority = 7; break;
+        case RTTHREADTYPE_DEFAULT:              Priority = 8; break;
+        case RTTHREADTYPE_MSG_PUMP:             Priority = 9; break;
+        case RTTHREADTYPE_IO:                   Priority = 10; break;
+        case RTTHREADTYPE_TIMER:                Priority = 11; break;
+
+        default:
+            AssertMsgFailed(("enmType=%d\n", enmType));
+            return VERR_INVALID_PARAMETER;
+    }
+    return VINF_SUCCESS;
+}
+
+int rtThreadNativeAdopt(PRTTHREADINT pThread)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+void rtThreadNativeDestroy(PRTTHREADINT pThread)
+{
+    NOREF(pThread);
+}
+
+/**
+ * Native kernel thread wrapper function.
+ *
+ * This will forward to rtThreadMain and do termination upon return.
+ *
+ * @param pvArg         Pointer to the argument package.
+ */
+static int rtThreadNativeMain(void *pvArg)
+{
+    PRTTHREADINT pThread = (PRTTHREADINT)pvArg;
+
+    rtThreadMain(pThread, (RTNATIVETHREAD)current, &pThread->szName[0]);
+    return 0;
+}
+
+
+int rtThreadNativeCreate(PRTTHREADINT pThreadInt, PRTNATIVETHREAD pNativeThread)
+{
+    struct task_struct *NativeThread;
+
+    RT_ASSERT_PREEMPTIBLE();
+
+    NativeThread = kthread_run(rtThreadNativeMain, pThreadInt, "%s", pThreadInt->szName);
+
+    if (IS_ERR(NativeThread))
+        return VERR_GENERAL_FAILURE;
+
+    *pNativeThread = (RTNATIVETHREAD)NativeThread;
+    return VINF_SUCCESS;
+}