Changeset 53669 in vbox for trunk/src/VBox/ExtPacks/VBoxDTrace

Timestamp:

Jan 2, 2015 12:33:32 PM (10 years ago)

Author:

vboxsync

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

97446

Message:

VBoxDTrace: Implemented all the fake solaris stuff. (r46)

Location:

trunk/src/VBox/ExtPacks/VBoxDTrace

Files:

• VBoxDTraceR0/VBoxDTraceR0.cpp (modified) (5 diffs)
• include/VBoxDTraceTypes.h (modified) (2 diffs)
• onnv/uts/common/dtrace/dtrace.c (modified) (6 diffs)

trunk/src/VBox/ExtPacks/VBoxDTrace/VBoxDTraceR0/VBoxDTraceR0.cpp

@@ -42 +42 @@
 #include <iprt/mem.h>
 #include <iprt/mp.h>
+#include <iprt/process.h>
 #include <iprt/semaphore.h>
 #include <iprt/spinlock.h>
@@ -108 +109 @@
     /** Credentials allocated by VBoxDtGetCurrentCreds. */
     struct VBoxDtCred      *pCred;
+    /** Thread structure currently being held by this thread. */
+    struct VBoxDtThread    *pThread;
     /** Pointer to this structure.
      * This is the final bit of integrity checking. */
@@ -145 +148 @@
         if (pStackData->pCred) \
             crfree(pStackData->pCred); \
+        if (pStackData->pThread) \
+            VBoxDtReleaseThread(pStackData->pThread); \
     } while (0)
 
@@ -677 +682 @@
         RTMemFree(pCred);
 }
+
+/** Spinlock protecting the thread structures. */
+static RTSPINLOCK           g_hThreadSpinlock = NIL_RTSPINLOCK;
+/** List of threads by usage age. */
+static RTLISTANCHOR         g_ThreadAgeList;
+/** Hash table for looking up thread structures.  */
+static struct VBoxDtThread *g_apThreadsHash[16384];
+/** Fake kthread_t structures.
+ * The size of this array is making horrible ASSUMPTIONS about the number of
+ * thread in the system that will be subjected to DTracing. */
+static struct VBoxDtThread  g_aThreads[8192];
+
+
+static int vboxDtInitThreadDb(void)
+{
+    int rc = RTSpinlockCreate(&g_hThreadSpinlock);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    RTListInit(&g_ThreadAgeList);
+    for (uint32_t i = 0; i < RT_ELEMENTS(g_aThreads); i++)
+    {
+        g_aThreads[i].hNative = NIL_RTNATIVETHREAD;
+        g_aThreads[i].uPid    = NIL_RTPROCESS;
+        RTListPrepend(&g_ThreadAgeList, &g_aThreads[i].AgeEntry);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static void vboxDtTermThreadDb(void)
+{
+    RTSpinlockDestroy(g_hThreadSpinlock);
+    g_hThreadSpinlock = NIL_RTSPINLOCK;
+    RTListInit(&g_ThreadAgeList);
+}
+
+
+/* curthread implementation, providing a fake kthread_t. */
+struct VBoxDtThread *VBoxDtGetCurrentThread(void)
+{
+    /*
+     * Once we've retrieved a thread, we hold on to it until the thread exits
+     * the VBoxDTrace module.
+     */
+    PVBDTSTACKDATA  pData       = vboxDtGetStackData();
+    if (pData->pThread)
+    {
+        AssertPtr(pData->pThread);
+        Assert(pData->pThread->hNative   == RTThreadNativeSelf());
+        Assert(pData->pThread->uPid      == RTProcSelf());
+        Assert(RTListIsEmpty(&pData->pThread->AgeEntry));
+        return pData->pThread;
+    }
+
+    /*
+     * Lookup the thread in the hash table.
+     */
+    RTNATIVETHREAD  hNativeSelf = RTThreadNativeSelf();
+    RTPROCESS       uPid        = RTProcSelf();
+    uintptr_t       iHash       = (hNativeSelf * 2654435761) % RT_ELEMENTS(g_apThreadsHash);
+    RTSPINLOCKTMP   Tmp         = RTSPINLOCKTMP_INITIALIZER;
+
+    RTSpinlockAcquireNoInts(g_hThreadSpinlock, &Tmp);
+
+    struct VBoxDtThread *pThread = g_apThreadsHash[iHash];
+    while (pThread)
+    {
+        if (pThread->hNative == hNativeSelf)
+        {
+            if (pThread->uPid != uPid)
+            {
+                /* Re-initialize the reused thread. */
+                pThread->uPid           = uPid;
+                pThread->t_dtrace_vtime = 0;
+                pThread->t_dtrace_start = 0;
+                pThread->t_dtrace_stop  = 0;
+                pThread->t_dtrace_scrpc = 0;
+                pThread->t_dtrace_astpc = 0;
+                pThread->t_predcache    = 0;
+            }
+
+            /* Hold the thread in the on-stack data, making sure it does not
+               get reused till the thread leaves VBoxDTrace. */
+            RTListNodeRemove(&pThread->AgeEntry);
+            pData->pThread = pThread;
+
+            RTSpinlockReleaseNoInts(g_hThreadSpinlock, &Tmp);
+            return pThread;
+        }
+
+        pThread = pThread->pNext;
+    }
+
+    /*
+     * Unknown thread.  Allocate a new entry, recycling unused or old ones.
+     */
+    pThread = RTListGetLast(&g_ThreadAgeList, struct VBoxDtThread, AgeEntry);
+    AssertFatal(pThread);
+    RTListNodeRemove(&pThread->AgeEntry);
+    if (pThread->hNative != NIL_RTNATIVETHREAD)
+    {
+        uintptr_t   iHash2 = (pThread->hNative * 2654435761) % RT_ELEMENTS(g_apThreadsHash);
+        if (g_apThreadsHash[iHash2] == pThread)
+            g_apThreadsHash[iHash2] = pThread->pNext;
+        else
+        {
+            for (struct VBoxDtThread *pPrev = g_apThreadsHash[iHash2]; ; pPrev = pPrev->pNext)
+            {
+                AssertPtr(pPrev);
+                if (pPrev->pNext == pThread)
+                {
+                    pPrev->pNext = pThread->pNext;
+                    break;
+                }
+            }
+        }
+    }
+
+    /*
+     * Initialize the data.
+     */
+    pThread->t_dtrace_vtime = 0;
+    pThread->t_dtrace_start = 0;
+    pThread->t_dtrace_stop  = 0;
+    pThread->t_dtrace_scrpc = 0;
+    pThread->t_dtrace_astpc = 0;
+    pThread->t_predcache    = 0;
+    pThread->hNative        = hNativeSelf;
+    pThread->uPid           = uPid;
+
+    /*
+     * Add it to the hash as well as the on-stack data.
+     */
+    pThread->pNext = g_apThreadsHash[iHash];
+    g_apThreadsHash[iHash] = pThread->pNext;
+
+    pData->pThread = pThread;
+
+    RTSpinlockReleaseNoInts(g_hThreadSpinlock, &Tmp);
+    return pThread;
+}
+
+
+/**
+ * Called by the stack data destructor.
+ *
+ * @param   pThread         The thread to release.
+ *
+ */
+static void VBoxDtReleaseThread(struct VBoxDtThread *pThread)
+{
+    RTSPINLOCKTMP   Tmp = RTSPINLOCKTMP_INITIALIZER;
+    RTSpinlockAcquireNoInts(g_hThreadSpinlock, &Tmp);
+
+    RTListAppend(&g_ThreadAgeList, &pThread->AgeEntry);
+
+    RTSpinlockReleaseNoInts(g_hThreadSpinlock, &Tmp);
+}
+
+
 
 
@@ -1062 +1229 @@
     RTMemFreeEx(pvMem, pThis->cbBuf);
 }
-
-
-#if 0
-VBoxDtGetKernelBase
-VBoxDtGetCurrentThread
-#endif
-
 
 

trunk/src/VBox/ExtPacks/VBoxDTrace/include/VBoxDTraceTypes.h

@@ -35 +35 @@
 #include <iprt/stdarg.h>
 #include <iprt/param.h>
+#ifdef IN_RING0
+# include <iprt/list.h>
+#endif
 #ifdef IN_RING3
 # include <sys/types.h>
@@ -218 +221 @@
 typedef struct VBoxDtThread
 {
+    /** The next thread with the same hash table entry.
+     * Or the next free thread.  */
+    struct VBoxDtThread    *pNext;
+    /** Age list node. */
+    RTLISTNODE              AgeEntry;
+    /** The native thread handle. */
+    RTNATIVETHREAD          hNative;
+    /** The process ID. */
+    RTPROCESS               uPid;
+
+    uint32_t                t_predcache;
+    uintptr_t               t_dtrace_scrpc;
+    uintptr_t               t_dtrace_astpc;
     hrtime_t                t_dtrace_vtime;
     hrtime_t                t_dtrace_start;
     uint8_t                 t_dtrace_stop;
-    uintptr_t               t_dtrace_scrpc;
-    uintptr_t               t_dtrace_astpc;
-    uint32_t                t_predcache;
-    struct VBoxDtProcess   *t_proc;
 } kthread_t;
 struct VBoxDtThread *VBoxDtGetCurrentThread(void);

trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/dtrace/dtrace.c

@@ -97 +97 @@
 # include <iprt/assert.h>
 # include <iprt/cpuset.h>
+# include <iprt/mem.h>
 # include <iprt/mp.h>
 # include <iprt/string.h>
@@ -138 +139 @@
 # define NULL (0)
 #endif /* VBOX */
+
+/** Check if the given address is a valid kernel address.
+ * The value can be uintptr_t or uint64_t.  */
+#ifndef VBOX
+# define VBDT_IS_VALID_KRNL_ADDR(a_uAddr)   ((a_uAddr) >= KERNELBASE)
+#else
+# define VBDT_IS_VALID_KRNL_ADDR(a_uAddr)   \
+    (   (sizeof(a_uAddr) == sizeof(uintptr_t) || (uintptr_t)(a_uAddr) == (a_uAddr)) \
+     && RTR0MemKernelIsValidAddr((void *)(uintptr_t)(a_uAddr)) )
+#endif
+
 
 /*
@@ -232 +244 @@
 static kmem_cache_t     *dtrace_state_cache;    /* cache for dynamic state */
 static uint64_t         dtrace_vtime_references; /* number of vtimestamp refs */
+#ifndef VBOX
 static kthread_t        *dtrace_panicked;       /* panicking thread */
+#endif
 static dtrace_ecb_t     *dtrace_ecb_create_cache; /* cached created ECB */
 static dtrace_genid_t   dtrace_probegen;        /* current probe generation */
@@ -9367 +9381 @@
 
         ASSERT(!DTRACEACT_ISPRINTFLIKE(kind) || (arg != NULL &&
-            arg >= KERNELBASE) || (arg == NULL && kind == DTRACEACT_PRINTA));
+            VBDT_IS_VALID_KRNL_ADDR(arg)) || (arg == NULL && kind == DTRACEACT_PRINTA));
 
         act = kmem_zalloc(sizeof (dtrace_actdesc_t), KM_SLEEP);
@@ -9403 +9417 @@
                 char *str = (char *)(uintptr_t)act->dtad_arg;
 
-                ASSERT((str != NULL && (uintptr_t)str >= KERNELBASE) ||
+                ASSERT((str != NULL && VBDT_IS_VALID_KRNL_ADDR((uintptr_t)str)) ||
                     (str == NULL && act->dtad_kind == DTRACEACT_PRINTA));
 
@@ -9878 +9892 @@
                         } else {
                                 ASSERT(arg != NULL);
-                                ASSERT(arg > KERNELBASE);
+                                ASSERT(VBDT_IS_VALID_KRNL_ADDR(arg));
                                 format = dtrace_format_add(state,
                                     (char *)(uintptr_t)arg);