Works on X64

Author: davidwrighton

src/coreclr/inc/executableallocator.h

@@ -183,7 +183,7 @@ class ExecutableAllocator
     static bool IsDoubleMappingEnabled();
 
     // Release memory allocated via DoubleMapping for either templates or normal double mapped data
-    void Release(void* pRX, bool releaseTemplate);
+    void ReleaseWorker(void* pRX, bool releaseTemplate);
 
     // Initialize the allocator instance
     bool Initialize();

src/coreclr/inc/loaderheap.h

@@ -501,13 +501,13 @@ class UnlockedInterleavedLoaderHeap : public UnlockedLoaderHeapBase
 
     InterleavedStubFreeListNode  *m_pFreeListHead;
 
-    InterleavedLoaderHeapConfig *m_pConfig;
+    const InterleavedLoaderHeapConfig *m_pConfig;
 
 #ifndef DACCESS_COMPILE
 protected:
     UnlockedInterleavedLoaderHeap(
         RangeList *pRangeList,
-        InterleavedLoaderHeapConfig *pConfig);
+        const InterleavedLoaderHeapConfig *pConfig);
 
     virtual ~UnlockedInterleavedLoaderHeap();
 #endif
@@ -1045,7 +1045,7 @@ class InterleavedLoaderHeap : public UnlockedInterleavedLoaderHeap
 public:
     InterleavedLoaderHeap(RangeList *pRangeList,
                BOOL fUnlocked,
-               InterleavedLoaderHeapConfig *pConfig,
+               const InterleavedLoaderHeapConfig *pConfig
                )
       : UnlockedInterleavedLoaderHeap(
                            pRangeList,

src/coreclr/minipal/Unix/doublemapping.cpp

@@ -9,6 +9,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <inttypes.h>
+#include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
@@ -25,6 +26,11 @@
 #include "minipal.h"
 #include "minipal/cpufeatures.h"
 
+#ifndef TARGET_APPLE
+#include <link.h>
+#include <dlfcn.h>
+#endif // TARGET_APPLE
+
 #ifdef TARGET_APPLE
 
 #include <mach/mach.h>
@@ -275,26 +281,32 @@ struct InitializeTemplateThunkLocals
 
 static TemplateThunkMappingData *s_pThunkData = NULL;
 
+static Elf32_Word Elf32_WordMin(Elf32_Word left, Elf32_Word  right)
+{
+    return left < right ? left : right;
+}
+
 static int InitializeTemplateThunkMappingDataPhdrCallback(struct dl_phdr_info *info, size_t size, void *dataPtr)
 {
     InitializeTemplateThunkLocals *locals = (InitializeTemplateThunkLocals*)dataPtr;
 
-    if (info->dlpi_addr == locals->info.dli_fbase)
+    if ((void*)info->dlpi_addr == locals->info.dli_fbase)
     {
         for (size_t j = 0; j < info->dlpi_phnum; j++)
         {
-            if (locals.pTemplate < info->dlpi_phdr[j].p_vaddr)
+            uint8_t* baseSectionAddr = (uint8_t*)locals->info.dli_fbase + info->dlpi_phdr[j].p_vaddr;
+            if (locals->pTemplate < baseSectionAddr)
             {
                 // Address is before the virtual address of this section begins
                 continue;
             }
 
             // Since this is all in support of mapping code from the file, we need to ensure that the region we find
             // is actually present in the file.
-            Elf32_Word sizeOfSectionWhichCanBeMapped = min(info->dlpi_phdr[j].p_filesz, info->dlpi_phdr[j].p_memsz;
+            Elf32_Word sizeOfSectionWhichCanBeMapped = Elf32_WordMin(info->dlpi_phdr[j].p_filesz, info->dlpi_phdr[j].p_memsz);
 
-            Elf32_Addr endAddressAllowedForTemplate = info->dlpi_phdr[j].p_vaddr + sizeOfSectionWhichCanBeMapped);
-            if (locals.pTemplate >= endAddressAllowedForTemplate)
+            uint8_t* endAddressAllowedForTemplate = baseSectionAddr + sizeOfSectionWhichCanBeMapped;
+            if (locals->pTemplate >= endAddressAllowedForTemplate)
             {
                 // Template is after the virtual address of this section ends (or the mappable region of the file)
                 continue;
@@ -316,8 +328,8 @@ static int InitializeTemplateThunkMappingDataPhdrCallback(struct dl_phdr_info *i
 
             locals->data.fdImage = fdImage;
             locals->data.offsetInFileOfStartOfSection = info->dlpi_phdr[j].p_offset;
-            locals->data.addrOfStartOfSection = info->dlpi_phdr[j].p_vaddr;
-            locals->data.addrOfEndOfSection = info->dlpi_phdr[j].p_vaddr + sizeOfSectionWhichCanBeMapped;
+            locals->data.addrOfStartOfSection = baseSectionAddr;
+            locals->data.addrOfEndOfSection = baseSectionAddr + sizeOfSectionWhichCanBeMapped;
             locals->data.imageTemplates = true;
             return 1; // We have found the result. Abort further processing.
         }
@@ -343,7 +355,7 @@ TemplateThunkMappingData *InitializeTemplateThunkMappingData(void* pTemplate)
         dl_iterate_phdr(InitializeTemplateThunkMappingDataPhdrCallback, &locals);
     }
 
-    if (locals.data->addrOfStartOfSection == NULL)
+    if (locals.data.addrOfStartOfSection == NULL)
     {
         // This is the detail of thunk data which indicates if we were able to compute the template mapping data from the image.
 
@@ -378,10 +390,10 @@ TemplateThunkMappingData *InitializeTemplateThunkMappingData(void* pTemplate)
             else
             {
                 locals.data.fdImage = fd;
-                locals->data.offsetInFileOfStartOfSection = 0;
-                locals->data.addrOfStartOfSection = (void*)0x10000;
-                locals->data.addrOfEndOfSection = ((uint8_t*)locals->data.addrOfStartOfSection) + maxFileSize;
-                locals->data.imageTemplates = false;
+                locals.data.offsetInFileOfStartOfSection = 0;
+                locals.data.addrOfStartOfSection = (void*)0x10000;
+                locals.data.addrOfEndOfSection = ((uint8_t*)locals.data.addrOfStartOfSection) + maxFileSize;
+                locals.data.imageTemplates = false;
             }
         }
     }
@@ -440,8 +452,8 @@ void* VMToOSInterface::CreateTemplate(void* pImageTemplate, size_t templateSize,
         void* mappedMemory = mmap(NULL, templateSize, PROT_READ | PROT_WRITE, MAP_SHARED, pThunkData->fdImage, locationInFileToStoreGeneratedCode);
         if (mappedMemory != MAP_FAILED)
         {
-            codePageGenerator(mappedMemory, mappedMemory, templateSize);
-            munmap(mappedMemory);
+            codePageGenerator((uint8_t*)mappedMemory, (uint8_t*)mappedMemory, templateSize);
+            munmap(mappedMemory, templateSize);
             return ((uint8_t*)pThunkData->addrOfStartOfSection) + locationInFileToStoreGeneratedCode;
         }
         else
@@ -511,13 +523,13 @@ void* VMToOSInterface::AllocateThunksFromTemplate(void* pTemplate, size_t templa
     }
 
     uint8_t* endOfTemplate = ((uint8_t*)pTemplate + templateSize);
-    if (endOfTemplate > addrOfEndOfSection)
+    if (endOfTemplate > pThunkData->addrOfEndOfSection)
         return NULL;
 
-    size_t sectionOffset = fileOffset = (uint8_t*)pTemplate - (uint8_t*)pThunkData->addrOfStartOfSection;
+    size_t sectionOffset = (uint8_t*)pTemplate - (uint8_t*)pThunkData->addrOfStartOfSection;
     off_t fileOffset = pThunkData->offsetInFileOfStartOfSection + sectionOffset;
 
-    void *pStart = mmap(pStartHint, templateSize * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE | (pStartSpecification != NULL ? MAP_FIXED : 0), 0, 0);
+    void *pStart = mmap(pStartSpecification, templateSize * 2, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | (pStartSpecification != NULL ? MAP_FIXED : 0), -1, 0);
     if (pStart == MAP_FAILED)
     {
         return NULL;

src/coreclr/minipal/minipal.h

@@ -85,7 +85,7 @@ class VMToOSInterface
     // Return:
     //  NULL if creating the template fails
     //  Non-NULL, a pointer to the template
-    void* CreateTemplate(void* pImageTemplate, size_t templateSize, void (*codePageGenerator)(uint8_t* pageBase, uint8_t* pageBaseRX, size_t size))
+    static void* CreateTemplate(void* pImageTemplate, size_t templateSize, void (*codePageGenerator)(uint8_t* pageBase, uint8_t* pageBaseRX, size_t size));
 
     // Indicate if the AllocateThunksFromTemplate function respects the pStart address on this platform
     // Return:

src/coreclr/utilcode/executableallocator.cpp

@@ -555,7 +555,7 @@ void ExecutableAllocator::ReleaseWorker(void* pRX, bool releaseTemplate)
 
             if (releaseTemplate)
             {
-                if (!VMToOSInterface::FreeThunksFromTemplate(pThunks, pBlock->size / 2))
+                if (!VMToOSInterface::FreeThunksFromTemplate(pRX, pBlock->size / 2))
                 {
                     g_fatalErrorHandler(COR_E_EXECUTIONENGINE, W("Releasing the template mapped memory failed"));
                 }
@@ -991,18 +991,25 @@ void* ExecutableAllocator::AllocateThunksFromTemplate(void *pTemplate, size_t te
             return NULL;
         }
 
-        void *pTemplateAddressAllocated = VMToOSInterface::AllocateThunksFromTemplate(pTemplate, templateSize, pTemplateAddress);
+        void* result = VMToOSInterface::ReserveDoubleMappedMemory(m_doubleMemoryMapperHandle, block->offset, templateSize * 2, 0, 0);
 
-        if (pTemplateAddressAllocated != NULL)
+        if (result != NULL)
         {
-            block->baseRX = pTemplateAddressAllocated;
+            block->baseRX = result;
             AddRXBlock(block);
         }
         else
         {
             BackoutBlock(block, isFreeBlock);
         }
 
+        void *pTemplateAddressAllocated = VMToOSInterface::AllocateThunksFromTemplate(pTemplate, templateSize, block->baseRX);
+
+        if (pTemplateAddressAllocated == NULL)
+        {
+            ReleaseWorker(block->baseRX, false);
+        }
+
         return pTemplateAddressAllocated;
     }
     else
@@ -1023,3 +1030,8 @@ void ExecutableAllocator::FreeThunksFromTemplate(void *pThunks, size_t templateS
         VMToOSInterface::FreeThunksFromTemplate(pThunks, templateSize);
     }
 }
+
+void* ExecutableAllocator::CreateTemplate(void* templateInImage, size_t templateSize, void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size))
+{
+    return VMToOSInterface::CreateTemplate(templateInImage, templateSize, codePageGenerator);
+}

src/coreclr/utilcode/interleavedloaderheap.cpp

@@ -33,10 +33,13 @@ namespace
 
 UnlockedInterleavedLoaderHeap::UnlockedInterleavedLoaderHeap(
                                        RangeList *pRangeList,
-                                       void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),
-                                       DWORD dwGranularity) :
+                                       const InterleavedLoaderHeapConfig *pConfig) :
     UnlockedLoaderHeapBase(LoaderHeapImplementationKind::Interleaved),
-    m_pFreeListHead(NULL)
+    m_pEndReservedRegion(NULL),
+    m_dwGranularity(pConfig->StubSize),
+    m_pRangeList(pRangeList),
+    m_pFreeListHead(NULL),
+    m_pConfig(pConfig)
 {
     CONTRACTL
     {
@@ -46,15 +49,7 @@ UnlockedInterleavedLoaderHeap::UnlockedInterleavedLoaderHeap(
     }
     CONTRACTL_END;
 
-    m_pEndReservedRegion         = NULL;
-
-    m_pRangeList                 = pRangeList;
-
     _ASSERTE((GetStubCodePageSize() % GetOsPageSize()) == 0); // Stub code page size MUST be in increments of the page size. (Really it must be a power of 2 as well, but this is good enough)
-    m_dwGranularity = dwGranularity;
-
-    _ASSERTE(codePageGenerator != NULL);
-    m_codePageGenerator = codePageGenerator;
 }
 
 // ~LoaderHeap is not synchronised (obviously)
@@ -134,7 +129,7 @@ BOOL UnlockedInterleavedLoaderHeap::CommitPages(void* pData, size_t dwSizeToComm
     }
 
     ExecutableWriterHolder<BYTE> codePageWriterHolder((BYTE*)pData, dwSizeToCommitPart, ExecutableAllocator::DoNotAddToCache);
-    m_codePageGenerator(codePageWriterHolder.GetRW(), (BYTE*)pData, dwSizeToCommitPart);
+    m_pConfig->CodePageGenerator(codePageWriterHolder.GetRW(), (BYTE*)pData, dwSizeToCommitPart);
     FlushInstructionCache(GetCurrentProcess(), pData, dwSizeToCommitPart);
 
     return TRUE;
@@ -288,7 +283,7 @@ BOOL UnlockedInterleavedLoaderHeap::GetMoreCommittedPages(size_t dwMinSize)
             }
         }
 
-        m_dwTotalAlloc += dwSizeToCommit;
+        m_dwTotalAlloc += dwSizeToReserve;
 
         pNewBlock.SuppressRelease();
         newAllocatedThunks.SuppressRelease();
@@ -551,7 +546,9 @@ void *UnlockedInterleavedLoaderHeap::UnlockedAllocStub(
 
 void InitializeLoaderHeapConfig(InterleavedLoaderHeapConfig *pConfig, size_t stubSize, void* templateInImage, void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size))
 {
-    
+    pConfig->StubSize = stubSize;
+    pConfig->Template = ExecutableAllocator::Instance()->CreateTemplate(templateInImage, GetStubCodePageSize(), codePageGenerator);
+    pConfig->CodePageGenerator = codePageGenerator;
 }
 
 #endif // #ifndef DACCESS_COMPILE