Changeset 3195 for trunk/src/kmk/w32/imagecache.c

Timestamp:

Mar 27, 2018, 8:09:23 PM (7 years ago)

Author:

bird

Message:

kmk/win: Catch output from processes spawned by kmk_redirect. Made imagecase threadsafe and made winchildren use it.

File:

• trunk/src/kmk/w32/imagecache.c (modified) (6 diffs)

trunk/src/kmk/w32/imagecache.c

@@ -26 +26 @@
 /* No GNU coding style here! */
 
-/*******************************************************************************
-*   Header Files                                                               *
-*******************************************************************************/
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
 #include "makeint.h"
 
@@ -34 +34 @@
 
 
-/*******************************************************************************
-*   Structures and Typedefs                                                    *
-*******************************************************************************/
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
 typedef struct EXECCACHEENTRY
 {
@@ -42 +42 @@
     unsigned                uHash;
     /** The name length. */
-    unsigned                cchName;
+    unsigned                cwcName;
     /** Pointer to the next name with the same hash. */
     struct EXECCACHEENTRY  *pNext;
     /** When it was last referenced. */
     unsigned                uLastRef;
-    /** The module handle. */
+    /** The module handle, LOAD_LIBRARY_AS_DATAFILE. */
     HMODULE                 hmod1;
-    /** The module handle. */
+    /** The module handle, DONT_RESOLVE_DLL_REFERENCES. */
     HMODULE                 hmod2;
     /** The executable path. */
-    char                    szName[1];
+    wchar_t                 wszName[1];
 } EXECCACHEENTRY;
 typedef EXECCACHEENTRY *PEXECCACHEENTRY;
 
-/*******************************************************************************
-*   Global Variables                                                           *
-*******************************************************************************/
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Critical section serializing all access. */
+static CRITICAL_SECTION g_CritSect;
+/** Set if initialized. */
+static int volatile     g_fInitialized = 0;
 /** The number of cached images. */
 static unsigned         g_cCached;
@@ -69 +74 @@
 /** The hash table. */
 static PEXECCACHEENTRY  g_apHashTab[EXECCACHE_HASHTAB_SIZE];
+
+
+/** A sleepy approach to do-once. */
+static void kmk_cache_lazy_init(void)
+{
+    if (_InterlockedCompareExchange(&g_fInitialized, -1, 0) == 0)
+    {
+        InitializeCriticalSection(&g_CritSect);
+        _InterlockedExchange(&g_fInitialized, 1);
+    }
+    else
+        while (g_fInitialized != 1)
+            Sleep(1);
+}
 
 
@@ -83 +102 @@
    elsewhere. */
 
-static unsigned execcache_calc_hash(const char *psz, unsigned *pcch)
-{
-    unsigned char  *puch = (unsigned char *)psz;
-    unsigned        hash = 0;
-    int             ch;
-
-    while ((ch = *puch++))
+static unsigned execcache_calc_hash(const wchar_t *pwsz, size_t *pcch)
+{
+    wchar_t const  * const pwszStart = pwsz;
+    unsigned               hash = 0;
+    int                    ch;
+
+    while ((ch = *pwsz++) != L'\0')
         hash = ch + (hash << 6) + (hash << 16) - hash;
 
-    *pcch = (unsigned)(puch - psz - 1);
+    *pcch = (size_t)(pwsz - pwszStart - 1);
     return hash;
 }
 
-
-extern void kmk_cache_exec_image(const char *pszExec)
-{
-    /*
-     * Lookup the name.
-     */
-    unsigned            cchName;
-    const unsigned      uHash = execcache_calc_hash(pszExec, &cchName);
+/**
+ * Caches two memory mappings of the specified image so that it isn't flushed
+ * from the kernel's cache mananger.
+ *
+ * Not sure exactly how much this actually helps, but whatever...
+ *
+ * @param   pwszExec    The executable.
+ */
+extern void kmk_cache_exec_image_w(const wchar_t *pwszExec)
+{
+    /*
+     * Prepare name lookup and to lazy init.
+     */
+    size_t              cwcName;
+    const unsigned      uHash = execcache_calc_hash(pwszExec, &cwcName);
     PEXECCACHEENTRY    *ppCur = &g_apHashTab[uHash % EXECCACHE_HASHTAB_SIZE];
-    PEXECCACHEENTRY     pCur  = *ppCur;
+    PEXECCACHEENTRY     pCur;
+
+    if (g_fInitialized != 1)
+        kmk_cache_lazy_init();
+
+    /*
+     * Do the lookup.
+     */
+    EnterCriticalSection(&g_CritSect);
+    pCur = *ppCur;
     while (pCur)
     {
         if (   pCur->uHash   == uHash
-            && pCur->cchName == cchName
-            && !memcmp(pCur->szName, pszExec, cchName))
+            && pCur->cwcName == cwcName
+            && !memcmp(pCur->wszName, pwszExec, cwcName * sizeof(wchar_t)))
         {
             pCur->uLastRef = ++g_uNow;
+            LeaveCriticalSection(&g_CritSect);
             return;
         }
@@ -118 +154 @@
         pCur = pCur->pNext;
     }
+    LeaveCriticalSection(&g_CritSect);
 
     /*
      * Not found, create a new entry.
      */
-    pCur = xmalloc(sizeof(*pCur) + cchName);
+    pCur = xmalloc(sizeof(*pCur) + cwcName * sizeof(wchar_t));
     pCur->uHash    = uHash;
-    pCur->cchName  = cchName;
+    pCur->cwcName  = (unsigned)cwcName;
     pCur->pNext    = NULL;
     pCur->uLastRef = ++g_uNow;
-    memcpy(pCur->szName, pszExec, cchName + 1);
-    pCur->hmod1 = LoadLibraryEx(pszExec, NULL, LOAD_LIBRARY_AS_DATAFILE);
+    memcpy(pCur->wszName, pwszExec, (cwcName + 1) * sizeof(wchar_t));
+    pCur->hmod1 = LoadLibraryExW(pwszExec, NULL, LOAD_LIBRARY_AS_DATAFILE);
     if (pCur->hmod1 != NULL)
-        pCur->hmod2 = LoadLibraryEx(pszExec, NULL, DONT_RESOLVE_DLL_REFERENCES);
+        pCur->hmod2 = LoadLibraryExW(pwszExec, NULL, DONT_RESOLVE_DLL_REFERENCES);
     else
         pCur->hmod2 = NULL;
 
-    *ppCur = pCur;
-    g_cCached++;
-}
-
+    /*
+     * Insert it.
+     * Take into account that we might've been racing other threads,
+     * fortunately we don't evict anything from the cache.
+     */
+    EnterCriticalSection(&g_CritSect);
+    if (*ppCur != NULL)
+    {
+        /* Find new end of chain and check for duplicate. */
+        PEXECCACHEENTRY pCur2 = *ppCur;
+        while (pCur2)
+        {
+            if (   pCur->uHash   == uHash
+                && pCur->cwcName == cwcName
+                && !memcmp(pCur->wszName, pwszExec, cwcName * sizeof(wchar_t)))
+                break;
+            ppCur = &pCur->pNext;
+            pCur = pCur->pNext;
+        }
+
+    }
+    if (*ppCur == NULL)
+    {
+        *ppCur = pCur;
+        g_cCached++;
+        LeaveCriticalSection(&g_CritSect);
+    }
+    else
+    {
+        LeaveCriticalSection(&g_CritSect);
+
+        if (pCur->hmod1 != NULL)
+            FreeLibrary(pCur->hmod1);
+        if (pCur->hmod2 != NULL)
+            FreeLibrary(pCur->hmod2);
+        free(pCur);
+    }
+}
+
+extern void kmk_cache_exec_image_a(const char *pszExec)
+{
+    wchar_t wszExec[260];
+    int cwc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, pszExec, strlen(pszExec) + 1, wszExec, 260);
+    if (cwc > 0)
+        kmk_cache_exec_image_w(wszExec);
+}
+