use RPC handle marshalling when running on win8.1+

Author: MikeHolman

lib/Common/Core/SysInfo.cpp

@@ -85,6 +85,7 @@ AutoSystemInfo::Initialize()
     allocationGranularityPageCount = dwAllocationGranularity / dwPageSize;
 
     isWindows8OrGreater = IsWindows8OrGreater();
+    isWindows8Point1OrGreater = IsWindows8Point1OrGreater();
 
     binaryName[0] = _u('\0');
 
@@ -363,14 +364,28 @@ AutoSystemInfo::CheckForAtom() const
 bool
 AutoSystemInfo::IsWin8OrLater()
 {
+#if defined(WINVER) && WINVER >= _WIN32_WINNT_WIN8
+    return true;
+#else
     return isWindows8OrGreater;
+#endif
+}
+
+bool
+AutoSystemInfo::IsWin8Point1OrLater()
+{
+#if defined(WINVER) && WINVER >= _WIN32_WINNT_WINBLUE
+    return true;
+#else
+    return isWindows8Point1OrGreater;
+#endif
 }
 
 #if defined(_CONTROL_FLOW_GUARD)
 bool
 AutoSystemInfo::IsWinThresholdOrLater()
 {
-#if defined(_M_ARM64)
+#if defined(_M_ARM64) || (defined(WINVER) && WINVER >= _WIN32_WINNT_WIN10)
     return true;
 #else
     return IsWindowsThresholdOrGreater();

lib/Common/Core/SysInfo.h

@@ -16,6 +16,7 @@ class AutoSystemInfo : public SYSTEM_INFO
 
     bool DisableDebugScopeCapture() const { return this->disableDebugScopeCapture; }
     bool IsWin8OrLater();
+    bool IsWin8Point1OrLater();
 #if defined(_CONTROL_FLOW_GUARD)
     bool IsWinThresholdOrLater();
 #endif
@@ -88,6 +89,7 @@ class AutoSystemInfo : public SYSTEM_INFO
     AutoSystemInfo() : majorVersion(0), minorVersion(0), buildDateHash(0), buildTimeHash(0), crtSize(0) { Initialize(); }
     void Initialize();
     bool isWindows8OrGreater;
+    bool isWindows8Point1OrGreater;
     uint allocationGranularityPageCount;
     HANDLE processHandle;
     DWORD crtSize;

lib/JITClient/JITClientStub.c

@@ -8,6 +8,16 @@
 #pragma warning(disable: 28252)
 #pragma warning(disable: 28253)
 
+// HACK HACK HACK
+// MIDL gives compile error if using [system_handle] with stub targetting win8 or below,
+// but there is no issue unless the function using [system_handle] is actually called.
+// We have runtime check that prevents that function from being used on old OS,
+// so change #define here to bypass the error
+#if !(0x603 <= _WIN32_WINNT)
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x603
+#endif
+
 #include "ChakraJIT_c.c"
 
 #pragma warning(pop)

lib/JITClient/JITManager.cpp

@@ -302,35 +302,55 @@ HRESULT
 JITManager::ConnectProcess(RPC_BINDING_HANDLE rpcBindingHandle)
 {
     Assert(IsOOPJITEnabled());
+    HRESULT hr = E_FAIL;
 
-#ifdef USE_RPC_HANDLE_MARSHALLING
-    HANDLE processHandle;
-    if (!DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(), &processHandle, 0, false, DUPLICATE_SAME_ACCESS))
+    if (AutoSystemInfo::Data.IsWin8Point1OrLater())
     {
-        return HRESULT_FROM_WIN32(GetLastError());
-    }
-#endif
+        HANDLE processHandle = nullptr;
+        // RPC handle marshalling is only available on 8.1+
+        if (!DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(), &processHandle, 0, false, DUPLICATE_SAME_ACCESS))
+        {
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
 
-    HRESULT hr = E_FAIL;
-    RpcTryExcept
-    {
-        hr = ClientConnectProcess(
-            rpcBindingHandle,
-#ifdef USE_RPC_HANDLE_MARSHALLING
-            processHandle,
-#endif
-            (intptr_t)AutoSystemInfo::Data.GetChakraBaseAddr(),
-            (intptr_t)AutoSystemInfo::Data.GetCRTHandle());
+        RpcTryExcept
+        {
+            hr = ClientConnectProcessWithProcessHandle(
+                rpcBindingHandle,
+                processHandle,
+                (intptr_t)AutoSystemInfo::Data.GetChakraBaseAddr(),
+                (intptr_t)AutoSystemInfo::Data.GetCRTHandle());
+        }
+            RpcExcept(RpcExceptionFilter(RpcExceptionCode()))
+        {
+            hr = HRESULT_FROM_WIN32(RpcExceptionCode());
+        }
+        RpcEndExcept;
+
+        if (processHandle)
+        {
+            CloseHandle(processHandle);
+        }
     }
-        RpcExcept(RpcExceptionFilter(RpcExceptionCode()))
+    else
     {
-        hr = HRESULT_FROM_WIN32(RpcExceptionCode());
-    }
-    RpcEndExcept;
-
-#ifdef USE_RPC_HANDLE_MARSHALLING
-    CloseHandle(processHandle);
+#if (WINVER >= _WIN32_WINNT_WINBLUE)
+        AssertOrFailFast(UNREACHED);
+#else
+        RpcTryExcept
+        {
+            hr = ClientConnectProcess(
+                rpcBindingHandle,
+                (intptr_t)AutoSystemInfo::Data.GetChakraBaseAddr(),
+                (intptr_t)AutoSystemInfo::Data.GetCRTHandle());
+        }
+            RpcExcept(RpcExceptionFilter(RpcExceptionCode()))
+        {
+            hr = HRESULT_FROM_WIN32(RpcExceptionCode());
+        }
+        RpcEndExcept;
 #endif
+    }
 
     return hr;
 }

lib/JITIDL/Chakra.JITIDL.vcxproj

@@ -50,4 +50,4 @@
   </ItemGroup>
   <Import Project="$(BuildConfigPropsPath)Chakra.Build.targets" Condition="exists('$(BuildConfigPropsPath)Chakra.Build.targets')" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>
+</Project>

lib/JITIDL/ChakraJIT.idl

@@ -26,15 +26,21 @@ interface IChakraJIT
     typedef CodeGenWorkItemIDL* pCodeGenWorkItemIDL;
     HRESULT Shutdown([in] handle_t binding);
 
-    HRESULT ConnectProcess(
+    HRESULT ConnectProcessWithProcessHandle(
         [in] handle_t binding,
-#ifdef USE_RPC_HANDLE_MARSHALLING
         [in, system_handle(sh_process, PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION)] HANDLE processHandle,
-#endif
         [in] CHAKRA_PTR chakraBaseAddress,
         [in] CHAKRA_PTR crtBaseAddress
     );
 
+#if !(WINVER >= _WIN32_WINNT_WINBLUE)
+    HRESULT ConnectProcess(
+        [in] handle_t binding,
+        [in] CHAKRA_PTR chakraBaseAddress,
+        [in] CHAKRA_PTR crtBaseAddress
+    );
+#endif
+
     HRESULT InitializeThreadContext(
         [in] handle_t binding,
         [in] ThreadContextDataIDL * threadData,

lib/JITIDL/JITTypes.h

@@ -12,14 +12,6 @@ import "wtypes.idl";
 #include "sdkddkver.h"
 #endif
 
-
-#if defined(WINVER) && WINVER >= _WIN32_WINNT_WINBLUE // on 8.1+, RPC can marshal process handle for us
-#ifdef __midl
-cpp_quote("#define USE_RPC_HANDLE_MARSHALLING 1")
-#endif
-#define USE_RPC_HANDLE_MARSHALLING 1
-#endif
-
 #if defined(TARGET_32)
 #ifdef __midl
 #define CHAKRA_WB_PTR int

lib/JITServer/JITServer.cpp

@@ -123,11 +123,9 @@ __RPC_USER PSCRIPTCONTEXT_HANDLE_rundown(__RPC__in PSCRIPTCONTEXT_HANDLE phConte
 }
 
 HRESULT
-ServerConnectProcess(
+ServerConnectProcessWithProcessHandle(
     handle_t binding,
-#ifdef USE_RPC_HANDLE_MARSHALLING
     HANDLE processHandle,
-#endif
     intptr_t chakraBaseAddress,
     intptr_t crtBaseAddress
 )
@@ -138,23 +136,47 @@ ServerConnectProcess(
     {
         return hr;
     }
-#ifdef USE_RPC_HANDLE_MARSHALLING
-    HANDLE targetHandle;
+    HANDLE targetHandle = nullptr;
+    // RPC handle marshalling is only available on 8.1+
     if (!DuplicateHandle(GetCurrentProcess(), processHandle, GetCurrentProcess(), &targetHandle, 0, false, DUPLICATE_SAME_ACCESS))
     {
         Assert(UNREACHED);
         return E_ACCESSDENIED;
     }
-#else
-    HANDLE targetHandle = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION, false, clientPid);
+    return ProcessContextManager::RegisterNewProcess(clientPid, targetHandle, chakraBaseAddress, crtBaseAddress);
+}
+
+#if !(WINVER >= _WIN32_WINNT_WINBLUE)
+HRESULT
+ServerConnectProcess(
+    handle_t binding,
+    intptr_t chakraBaseAddress,
+    intptr_t crtBaseAddress
+)
+{
+    // Should use ServerConnectProcessWithProcessHandle on 8.1+
+    if (AutoSystemInfo::Data.IsWin8Point1OrLater())
+    {
+        Assert(UNREACHED);
+        return E_ACCESSDENIED;
+    }
+
+    DWORD clientPid;
+    HRESULT hr = HRESULT_FROM_WIN32(I_RpcBindingInqLocalClientPID(binding, &clientPid));
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+    HANDLE targetHandle = nullptr;
+    targetHandle = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, false, clientPid);
     if (!targetHandle)
     {
         Assert(UNREACHED);
         return E_ACCESSDENIED;
     }
-#endif
     return ProcessContextManager::RegisterNewProcess(clientPid, targetHandle, chakraBaseAddress, crtBaseAddress);
 }
+#endif
 
 #pragma warning(push)
 #pragma warning(disable:6387 28196) // PREFast does not understand the out context can be null here

lib/JITServer/JITServerStub.c

@@ -8,6 +8,16 @@
 #pragma warning(disable: 28252)
 #pragma warning(disable: 28253)
 
+// HACK HACK HACK
+// MIDL gives compile error if using [system_handle] with stub targetting win8 or below,
+// but there is no issue unless the function using [system_handle] is actually called.
+// We have runtime check that prevents that function from being used on old OS,
+// so change #define here to bypass the error
+#if !(0x603 <= _WIN32_WINNT)
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x603
+#endif
+
 #include "ChakraJIT_s.c"
 
 #pragma warning(pop)