Class Mem replaced to VirtualMemory.

src/crypto/common/VirtualMemory.h

@@ -51,9 +51,11 @@ public:
     static void *allocateLargePagesMemory(size_t size);
     static void flushInstructionCache(void *p, size_t size);
     static void freeLargePagesMemory(void *p, size_t size);
+    static void init(bool hugePages);
     static void protectExecutableMemory(void *p, size_t size);
     static void unprotectExecutableMemory(void *p, size_t size);
 
+    static inline bool isHugepagesAvailable()                                { return (m_globalFlags & HUGEPAGES_AVAILABLE) != 0; }
     static inline constexpr size_t align(size_t pos, size_t align = 2097152) { return ((pos - 1) / align + 1) * align; }
 
 private:
@@ -63,6 +65,8 @@ private:
         LOCK                = 4
     };
 
+    static int m_globalFlags;
+
     int m_flags             = 0;
     size_t m_size           = 0;
     uint8_t *m_scratchpad   = nullptr;

src/crypto/common/VirtualMemory_unix.cpp

@@ -38,6 +38,9 @@
 #endif
 
 
+int xmrig::VirtualMemory::m_globalFlags = 0;
+
+
 xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) :
     m_size(VirtualMemory::align(size))
 {
@@ -120,6 +123,14 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t size)
 }
 
 
+void xmrig::VirtualMemory::init(bool hugePages)
+{
+    if (hugePages) {
+        m_globalFlags = HUGEPAGES | HUGEPAGES_AVAILABLE;
+    }
+}
+
+
 void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size)
 {
     mprotect(p, size, PROT_READ | PROT_EXEC);

src/crypto/common/VirtualMemory_win.cpp

@@ -27,11 +27,123 @@
 
 #include <winsock2.h>
 #include <windows.h>
+#include <ntsecapi.h>
+#include <tchar.h>
 
 
+#include "base/io/log/Log.h"
+#include "crypto/common/portable/mm_malloc.h"
 #include "crypto/common/VirtualMemory.h"
 
 
+/*****************************************************************
+SetLockPagesPrivilege: a function to obtain or
+release the privilege of locking physical pages.
+
+Inputs:
+
+HANDLE hProcess: Handle for the process for which the
+privilege is needed
+
+BOOL bEnable: Enable (TRUE) or disable?
+
+Return value: TRUE indicates success, FALSE failure.
+
+*****************************************************************/
+/**
+ * AWE Example: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366531(v=vs.85).aspx
+ * Creating a File Mapping Using Large Pages: https://msdn.microsoft.com/en-us/library/aa366543(VS.85).aspx
+ */
+static BOOL SetLockPagesPrivilege() {
+    HANDLE token;
+
+    if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) != TRUE) {
+        return FALSE;
+    }
+
+    TOKEN_PRIVILEGES tp;
+    tp.PrivilegeCount = 1;
+    tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+    if (LookupPrivilegeValue(nullptr, SE_LOCK_MEMORY_NAME, &(tp.Privileges[0].Luid)) != TRUE) {
+        return FALSE;
+    }
+
+    BOOL rc = AdjustTokenPrivileges(token, FALSE, (PTOKEN_PRIVILEGES) &tp, 0, nullptr, nullptr);
+    if (rc != TRUE || GetLastError() != ERROR_SUCCESS) {
+        return FALSE;
+    }
+
+    CloseHandle(token);
+
+    return TRUE;
+}
+
+
+static LSA_UNICODE_STRING StringToLsaUnicodeString(LPCTSTR string) {
+    LSA_UNICODE_STRING lsaString;
+
+    DWORD dwLen = (DWORD) wcslen(string);
+    lsaString.Buffer = (LPWSTR) string;
+    lsaString.Length = (USHORT)((dwLen) * sizeof(WCHAR));
+    lsaString.MaximumLength = (USHORT)((dwLen + 1) * sizeof(WCHAR));
+    return lsaString;
+}
+
+
+static BOOL ObtainLockPagesPrivilege() {
+    HANDLE token;
+    PTOKEN_USER user = nullptr;
+
+    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token) == TRUE) {
+        DWORD size = 0;
+
+        GetTokenInformation(token, TokenUser, nullptr, 0, &size);
+        if (size) {
+            user = (PTOKEN_USER) LocalAlloc(LPTR, size);
+        }
+
+        GetTokenInformation(token, TokenUser, user, size, &size);
+        CloseHandle(token);
+    }
+
+    if (!user) {
+        return FALSE;
+    }
+
+    LSA_HANDLE handle;
+    LSA_OBJECT_ATTRIBUTES attributes;
+    ZeroMemory(&attributes, sizeof(attributes));
+
+    BOOL result = FALSE;
+    if (LsaOpenPolicy(nullptr, &attributes, POLICY_ALL_ACCESS, &handle) == 0) {
+        LSA_UNICODE_STRING str = StringToLsaUnicodeString(_T(SE_LOCK_MEMORY_NAME));
+
+        if (LsaAddAccountRights(handle, user->User.Sid, &str, 1) == 0) {
+            LOG_NOTICE("Huge pages support was successfully enabled, but reboot required to use it");
+            result = TRUE;
+        }
+
+        LsaClose(handle);
+    }
+
+    LocalFree(user);
+    return result;
+}
+
+
+static BOOL TrySetLockPagesPrivilege() {
+    if (SetLockPagesPrivilege()) {
+        return TRUE;
+    }
+
+    return ObtainLockPagesPrivilege() && SetLockPagesPrivilege();
+}
+
+
+int xmrig::VirtualMemory::m_globalFlags = 0;
+
+
 xmrig::VirtualMemory::VirtualMemory(size_t size, bool hugePages, size_t align) :
     m_size(VirtualMemory::align(size))
 {
@@ -94,6 +206,20 @@ void xmrig::VirtualMemory::freeLargePagesMemory(void *p, size_t)
 }
 
 
+void xmrig::VirtualMemory::init(bool hugePages)
+{
+    if (!hugePages) {
+        return;
+    }
+
+    m_globalFlags = HUGEPAGES;
+
+    if (TrySetLockPagesPrivilege()) {
+        m_globalFlags |= HUGEPAGES_AVAILABLE;
+    }
+}
+
+
 void xmrig::VirtualMemory::protectExecutableMemory(void *p, size_t size)
 {
     DWORD oldProtect;