Changeset 2874 in kBuild

Timestamp:

Sep 4, 2016 7:45:29 PM (9 years ago)

Author:

bird

Message:

Deal with FlSAlloc leak.

File:

• trunk/src/kWorker/kWorker.c (modified) (7 diffs)

trunk/src/kWorker/kWorker.c

@@ -331 +331 @@
 } KWVIRTALLOC;
 
+
+/** Pointer to a FlsAlloc/TlsAlloc tracker entry. */
+typedef struct KWLOCALSTORAGE *PKWLOCALSTORAGE;
+/**
+ * Tracking an FlsAlloc/TlsAlloc index.
+ */
+typedef struct KWLOCALSTORAGE
+{
+    PKWLOCALSTORAGE     pNext;
+    KU32                idx;
+} KWLOCALSTORAGE;
+
+
 typedef enum KWTOOLTYPE
 {
@@ -440 +453 @@
     /** Head of the virtual alloc allocations. */
     PKWVIRTALLOC    pVirtualAllocHead;
+    /** Head of the FlsAlloc indexes. */
+    PKWLOCALSTORAGE pFlsAllocHead;
+    /** Head of the TlsAlloc indexes. */
+    PKWLOCALSTORAGE pTlsAllocHead;
 
     UNICODE_STRING  SavedCommandLine;
@@ -4361 +4378 @@
 
 
+
 /*
  *
- * Virtual memory management.
- * Virtual memory management.
- * Virtual memory management.
- *
- */
-
+ * Virtual memory leak prevension.
+ * Virtual memory leak prevension.
+ * Virtual memory leak prevension.
+ *
+ */
 
 /** Kernel32 - VirtualAlloc - for c1[xx].dll 78GB leaks.   */
@@ -4440 +4457 @@
 /*
  *
+ * Thread/Fiber local storage leak prevention.
+ * Thread/Fiber local storage leak prevention.
+ * Thread/Fiber local storage leak prevention.
+ *
+ * Note! The FlsAlloc/Free causes problems for statically linked VS2010
+ *       code like VBoxBs3ObjConverter.exe.  One thing is that we're
+ *       leaking these indexes, but more importantely we crash during
+ *       worker exit since the callback is triggered multiple times.
+ */
+
+
+/** Kernel32 - FlsAlloc  */
+DWORD WINAPI kwSandbox_Kernel32_FlsAlloc(PFLS_CALLBACK_FUNCTION pfnCallback)
+{
+    DWORD idxFls = FlsAlloc(pfnCallback);
+    KW_LOG(("FlsAlloc(%p) -> %#x\n", pfnCallback, idxFls));
+    if (idxFls != FLS_OUT_OF_INDEXES)
+    {
+        PKWLOCALSTORAGE pTracker = (PKWLOCALSTORAGE)kHlpAlloc(sizeof(*pTracker));
+        if (pTracker)
+        {
+            pTracker->idx = idxFls;
+            pTracker->pNext = g_Sandbox.pFlsAllocHead;
+            g_Sandbox.pFlsAllocHead = pTracker;
+        }
+    }
+
+    return idxFls;
+}
+
+/** Kernel32 - FlsFree */
+BOOL WINAPI kwSandbox_Kernel32_FlsFree(DWORD idxFls)
+{
+    BOOL fRc = FlsFree(idxFls);
+    KW_LOG(("FlsFree(%#x) -> %d\n", idxFls, fRc));
+    if (fRc)
+    {
+        PKWLOCALSTORAGE pTracker = g_Sandbox.pFlsAllocHead;
+        if (pTracker)
+        {
+            if (pTracker->idx == idxFls)
+                g_Sandbox.pFlsAllocHead = pTracker->pNext;
+            else
+            {
+                PKWLOCALSTORAGE pPrev;
+                do
+                {
+                    pPrev = pTracker;
+                    pTracker = pTracker->pNext;
+                } while (pTracker && pTracker->idx != idxFls);
+                if (pTracker)
+                    pPrev->pNext = pTracker->pNext;
+            }
+            if (pTracker)
+            {
+                pTracker->idx   = FLS_OUT_OF_INDEXES;
+                pTracker->pNext = NULL;
+                kHlpFree(pTracker);
+            }
+        }
+    }
+    return fRc;
+}
+
+
+
+/*
+ *
  * Misc function only intercepted while debugging.
  * Misc function only intercepted while debugging.
@@ -4523 +4608 @@
     { TUPLE("VirtualAlloc"),                NULL,       (KUPTR)kwSandbox_Kernel32_VirtualAlloc },
     { TUPLE("VirtualFree"),                 NULL,       (KUPTR)kwSandbox_Kernel32_VirtualFree },
+
+    { TUPLE("FlsAlloc"),                    NULL,       (KUPTR)kwSandbox_Kernel32_FlsAlloc },
+    { TUPLE("FlsFree"),                     NULL,       (KUPTR)kwSandbox_Kernel32_FlsFree },
 
     /*
@@ -4926 +5014 @@
 {
     PKWVIRTALLOC pTracker;
+    PKWLOCALSTORAGE pLocalStorage;
 #ifdef WITH_TEMP_MEMORY_FILES
     PKWFSTEMPFILE pTempFile;
@@ -4961 +5050 @@
         pTracker = pNext;
     }
+
+    /* Free left behind FlsAlloc leaks. */
+    pLocalStorage = g_Sandbox.pFlsAllocHead;
+    g_Sandbox.pFlsAllocHead = NULL;
+    while (pLocalStorage)
+    {
+        PKWLOCALSTORAGE pNext = pLocalStorage->pNext;
+        KW_LOG(("Freeing leaded FlsAlloc index %#x\n", pLocalStorage->idx));
+        FlsFree(pLocalStorage->idx);
+        kHlpFree(pLocalStorage);
+        pLocalStorage = pNext;
+    }
+
+    /* Free left behind TlsAlloc leaks. */
+    pLocalStorage = g_Sandbox.pTlsAllocHead;
+    g_Sandbox.pTlsAllocHead = NULL;
+    while (pLocalStorage)
+    {
+        PKWLOCALSTORAGE pNext = pLocalStorage->pNext;
+        KW_LOG(("Freeing leaded TlsAlloc index %#x\n", pLocalStorage->idx));
+        TlsFree(pLocalStorage->idx);
+        kHlpFree(pLocalStorage);
+        pLocalStorage = pNext;
+    }
+
 }