feat: use dual mapping replace virtual protect

src/ll/api/memory/Closure.h

@@ -61,13 +61,12 @@ class NativeClosure<Ret(Args...)> {
         uintptr_t  data;
     } stored;
 
-    VirtualMemory closure{};
+    DualMapping closure{};
 
     NativeClosure(origin_fn* func, uintptr_t data) : stored({func, data}) {
         detail::initNativeClosure(this, (void*)closureImpl, implOffset);
     }
-
-    closure_fn* get() const { return closure.get<closure_fn>(); }
+    closure_fn* get() const { return reinterpret_cast<closure_fn*>(closure.executable()); }
 
     ~NativeClosure() { detail::releaseNativeClosure(this); }
 

src/ll/api/memory/Memory.cpp

@@ -9,6 +9,8 @@
 
 #include "mc/deps/core/memory/IMemoryAllocator.h"
 
+#include "pl/MemoryResource.h"
+
 namespace ll::memory {
 
 LLAPI FuncPtr resolveSymbol(char const* symbol) { // for link
@@ -31,4 +33,17 @@ size_t getUsableSize(void* ptr) { return getDefaultAllocator().getUsableSize(ptr
         throw std::bad_alloc();
     }
 }
+void DualMapping::alloc(size_t size) {
+    free();
+    memSize = size;
+    pointer = pl::DualMappingMemoryResource::getInstance().allocate(size);
+}
+void DualMapping::free() {
+    if (!pointer) return;
+    pl::DualMappingMemoryResource::getInstance().deallocate(std::exchange(pointer, nullptr), std::exchange(memSize, 0));
+}
+void* DualMapping::executable() const {
+    if (!pointer) return nullptr;
+    return pl::DualMappingMemoryResource::getInstance().executable(pointer, memSize);
+}
 } // namespace ll::memory

src/ll/api/memory/Memory.h

@@ -150,43 +150,23 @@ template <template <class> class P, class T>
 }
 #endif
 
-enum class AccessMode {
-    Read    = 1 << 0,
-    Write   = 1 << 1,
-    Execute = 1 << 2,
-};
-
-[[nodiscard]] constexpr AccessMode operator|(const AccessMode l, const AccessMode r) noexcept {
-    return static_cast<AccessMode>(
-        static_cast<std::underlying_type_t<AccessMode>>(l) | static_cast<std::underlying_type_t<AccessMode>>(r)
-    );
-}
-[[nodiscard]] constexpr AccessMode operator&(const AccessMode l, const AccessMode r) noexcept {
-    return static_cast<AccessMode>(
-        static_cast<std::underlying_type_t<AccessMode>>(l) & static_cast<std::underlying_type_t<AccessMode>>(r)
-    );
-}
-class VirtualMemory {
+class DualMapping {
     void*  pointer{};
     size_t memSize{};
 
 public:
-    LLAPI void alloc(size_t size, AccessMode mode);
+    LLAPI void alloc(size_t size);
     LLAPI void free();
 
-    VirtualMemory() = default;
+    DualMapping() = default;
 
-    VirtualMemory(size_t size, AccessMode mode) { alloc(size, mode); }
+    DualMapping(size_t size) { alloc(size); }
 
-    ~VirtualMemory() { free(); }
+    ~DualMapping() { free(); }
 
     size_t size() const { return memSize; }
 
-    void* get() const { return pointer; }
-
-    template <class T>
-    T* get() const {
-        return reinterpret_cast<T*>(pointer);
-    }
+    void*       writable() const { return pointer; }
+    LLAPI void* executable() const;
 };
 } // namespace ll::memory

src/ll/api/memory/linux/Memory.cpp

@@ -65,19 +65,4 @@ void modify(void* ptr, size_t len, std::function<void()> const& callback) {
     callback();
     mprotect(ptr, len, oldProtect);
 }
-void VirtualMemory::alloc(size_t size, AccessMode mode) {
-    free();
-    memSize = size;
-    int fProtect{};
-    if ((bool)(mode & AccessMode::Read)) fProtect |= PROT_READ;
-    if ((bool)(mode & AccessMode::Write)) fProtect |= PROT_WRITE;
-    if ((bool)(mode & AccessMode::Execute)) fProtect |= PROT_EXEC;
-
-    pointer = mmap(nullptr, memSize, fProtect, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-}
-void VirtualMemory::free() {
-    if (!pointer) return;
-    munmap(pointer, memSize);
-    pointer = nullptr;
-}
 } // namespace ll::memory

src/ll/api/memory/win/Memory.cpp

@@ -26,25 +26,4 @@ void modify(void* ptr, size_t len, std::function<void()> const& callback) {
     callback();
     VirtualProtect(ptr, len, oldProtect, &oldProtect);
 }
-void VirtualMemory::alloc(size_t size, AccessMode mode) {
-    free();
-    memSize = size;
-    DWORD fProtect{PAGE_NOACCESS};
-    if ((bool)(mode & AccessMode::Read) && (bool)(mode & AccessMode::Write)) {
-        fProtect = PAGE_READWRITE;
-    } else if ((bool)(mode & AccessMode::Read)) {
-        fProtect = PAGE_READONLY;
-    } else if ((bool)(mode & AccessMode::Write)) {
-        fProtect = PAGE_WRITECOPY;
-    }
-    if ((bool)(mode & AccessMode::Execute)) fProtect *= PAGE_EXECUTE;
-
-    pointer = VirtualAlloc(nullptr, memSize, MEM_COMMIT | MEM_RESERVE, fProtect);
-}
-void VirtualMemory::free() {
-    if (!pointer) return;
-    VirtualFree(pointer, 0, MEM_RELEASE);
-    pointer = nullptr;
-}
-
 } // namespace ll::memory

src/ll/api/memory/x64/Closure.cpp

@@ -40,19 +40,17 @@ void initNativeClosure(void* self, void* impl, size_t offset) {
     impl       = unwrapFuncAddress(impl);
     auto tSelf = (T*)self;
 
-    tSelf->closure.alloc(size, AccessMode::Execute | AccessMode::Read);
-
-    modify(tSelf->closure.get(), size, [&]() {
-        memcpy(tSelf->closure.get(), impl, offset);
-
-        new ((char*)(tSelf->closure.get()) + offset) NativeClosurePrologue{
-            .data     = (uintptr_t)&tSelf->stored,
-            .push_rax = 0x50,
-            .mov_rax  = {0x48, 0xB8},
-            .addr     = (uintptr_t)impl + offset + sizeof(uintptr_t) - 1, // -1 for 0x58 in magic
-            .jmp_rax  = {0xFF, 0xE0}
-        };
-    });
+    tSelf->closure.alloc(size);
+
+    memcpy(tSelf->closure.writable(), impl, offset);
+
+    new ((char*)(tSelf->closure.writable()) + offset) NativeClosurePrologue{
+        .data     = (uintptr_t)&tSelf->stored,
+        .push_rax = 0x50,
+        .mov_rax  = {0x48, 0xB8},
+        .addr     = (uintptr_t)impl + offset + sizeof(uintptr_t) - 1, // -1 for 0x58 in magic
+        .jmp_rax  = {0xFF, 0xE0}
+    };
 }
 void releaseNativeClosure(void* /*self*/) {}
 

xmake.lua

@@ -33,7 +33,7 @@ add_requires("pcg_cpp v1.0.0")
 add_requires("pfr 2.1.1")
 add_requires("demangler v17.0.7")
 add_requires("levibuildscript 0.2.0")
-add_requires("preloader v1.9.0")
+add_requires("preloader v1.12.0")
 add_requires("symbolprovider v1.2.0")
 
 if is_windows then