[1.10>master] [MERGE #5525 @leirocks] Use seperate error for xdata registration failures

leirocks · leirocks · commit 1db67fb02d2d · 2018-07-26T14:58:16.000-07:00
Merge pull request #5525 from leirocks:xdata
diff --git a/lib/Backend/PDataManager.cpp b/lib/Backend/PDataManager.cpp
@@ -15,6 +15,7 @@
 void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_PTR functionStart, _In_ const ULONG_PTR functionEnd, _Out_ PVOID* pdataTable, ULONG entryCount, ULONG maxEntryCount)
 {
     BOOLEAN success = FALSE;
+    HRESULT hr = S_OK;
     if (AutoSystemInfo::Data.IsWin8OrLater())
     {
         Assert(pdataTable != NULL);
@@ -28,17 +29,22 @@ void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_
             /*RangeBase*/ functionStart,
             /*RangeEnd*/ functionEnd);
         success = NT_SUCCESS(status);
-        if (success)
-        {
-            Assert(pdataTable);
-        }
+        Assert(!success || pdataTable);
+        hr = status;
     }
     else
     {
         *pdataTable = pdataStart;
         success = RtlAddFunctionTable(pdataStart, entryCount, functionStart);
+        if (!success) 
+        {
+            hr = E_OUTOFMEMORY; // only OOM error can happen for RtlAddFunctionTable
+        }
+    }
+    if (!success)
+    {
+        Js::Throw::XDataRegistrationError(hr, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 }
 
 void PDataManager::UnregisterPdata(RUNTIME_FUNCTION* pdata)
diff --git a/lib/Common/Core/DelayLoadLibrary.cpp b/lib/Common/Core/DelayLoadLibrary.cpp
@@ -112,6 +112,13 @@ NtdllLibrary::NTSTATUS NtdllLibrary::AddGrowableFunctionTable( _Out_ PVOID * Dyn
             }
         }
 
+#if DBG
+        // Validate the PDATA was not registered or already unregistered
+        ULONG_PTR            imageBase = 0;
+        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry((DWORD64)RangeBase, &imageBase, nullptr);
+        Assert(runtimeFunction == NULL);
+#endif
+
         *DynamicTable = nullptr;
         NTSTATUS status = addGrowableFunctionTable(DynamicTable,
             FunctionTable,
diff --git a/lib/Common/Exceptions/ReportError.cpp b/lib/Common/Exceptions/ReportError.cpp
@@ -10,7 +10,7 @@ void ReportFatalException(
     __in ULONG_PTR context,
     __in HRESULT exceptionCode,
     __in ErrorReason reasonCode,
-    __in ULONG scenario)
+    __in ULONG_PTR scenario)
 {
     // avoid the error text methods to be optimized out.
     UNREFERENCED_PARAMETER(scenario);
@@ -181,6 +181,11 @@ _NOINLINE void OutOfMemoryAllocationPolicy_unrecoverable_error()
     ReportFatalException(NULL, E_OUTOFMEMORY, Fatal_OutOfMemory, scenario);
 }
 
+_NOINLINE void XDataRegistration_unrecoverable_error(HRESULT hr, ULONG_PTR scenario)
+{
+    ReportFatalException(NULL, hr, Fatal_XDataRegistration, scenario);
+}
+
 ///////
 //
 // The following variety of OOM unrecoverable errors are similar to the ones above 
diff --git a/lib/Common/Exceptions/ReportError.h b/lib/Common/Exceptions/ReportError.h
@@ -30,13 +30,14 @@ enum ErrorReason
     Fatal_OutOfMemory = 22,
     // Unused = 23,
     Fatal_JsBuiltIn_Error = 24,
+    Fatal_XDataRegistration = 25,
 };
 
 extern "C" void ReportFatalException(
     __in ULONG_PTR context,
     __in HRESULT exceptionCode,
     __in ErrorReason reasonCode,
-    __in ULONG scenario);
+    __in ULONG_PTR scenario);
 
 // We can have other error handle code path with
 // unique call stack so we can collect data in Dr. Watson.
@@ -89,6 +90,8 @@ void OutOfMemoryTooManyPinnedObjects_unrecoverable_error_notvisible();
 void OutOfMemoryTooManyClosedContexts_unrecoverable_error_notvisible();
 void OutOfMemoryAllocationPolicy_unrecoverable_error_notvisible();
 
+void XDataRegistration_unrecoverable_error(HRESULT hr, ULONG_PTR scenario);
+
 inline void OutOfMemoryTooManyPinnedObjects_unrecoverable_error(BYTE visibility)
 {
     switch (visibility)
diff --git a/lib/Common/Exceptions/Throw.cpp b/lib/Common/Exceptions/Throw.cpp
@@ -125,13 +125,21 @@ namespace Js {
         }
         throw OutOfMemoryException();
     }
-    void Throw::CheckAndThrowOutOfMemory(BOOLEAN status)
+
+#if !defined(_M_IX86) && defined(_WIN32)
+    void Throw::XDataRegistrationError(HRESULT hr, ULONG_PTR funcStart)
     {
-        if (!status)
+        ULONG_PTR            imageBase = 0;
+        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry(funcStart, &imageBase, nullptr);
+
+        if (JsUtil::ExternalApi::GetCurrentThreadContextId())
         {
-            OutOfMemory();
+            XDataRegistration_unrecoverable_error(hr, (ULONG_PTR)runtimeFunction);
         }
+        throw OutOfMemoryException();
     }
+#endif
+
     void Throw::StackOverflow(ScriptContext *scriptContext, PVOID returnAddress)
     {
 #ifdef ENABLE_DEBUG_CONFIG_OPTIONS
diff --git a/lib/Common/Exceptions/Throw.h b/lib/Common/Exceptions/Throw.h
@@ -30,7 +30,10 @@ namespace Js {
 #ifdef ENABLE_JS_BUILTINS
         static void __declspec(noreturn) FatalJsBuiltInError();
 #endif
-        static void CheckAndThrowOutOfMemory(BOOLEAN status);
+
+#if !defined(_M_IX86) && defined(_WIN32)
+        static void XDataRegistrationError(HRESULT hr, ULONG_PTR funcStart);
+#endif
 
         static bool ReportAssert(__in LPCSTR fileName, uint lineNumber, __in LPCSTR error, __in LPCSTR message);
         static void LogAssert();
diff --git a/lib/Common/Memory/amd64/XDataAllocator.cpp b/lib/Common/Memory/amd64/XDataAllocator.cpp
@@ -124,29 +124,33 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, ULONG_PTR functionSta
     xdataInfo->pdata.EndAddress = (DWORD)(xdataInfo->pdata.BeginAddress + functionSize);
     xdataInfo->pdata.UnwindInfoAddress = (DWORD)((intptr_t)xdataInfo->address - baseAddress);
 
+    HRESULT hr = S_OK;
     BOOLEAN success = FALSE;
     if (AutoSystemInfo::Data.IsWin8OrLater())
     {
-#if DBG
-        // Validate the PDATA was not registered or unregistered
-        ULONG64            imageBase = 0;
-        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry((DWORD64)functionStart, &imageBase, nullptr);
-        Assert(runtimeFunction == NULL);
-#endif
-
         NTSTATUS status = NtdllLibrary::Instance->AddGrowableFunctionTable(&xdataInfo->functionTable,
             &xdataInfo->pdata,
             /*MaxEntryCount*/ 1,
             /*Valid entry count*/ 1,
             /*RangeBase*/ functionStart,
             /*RangeEnd*/ functionStart + functionSize);
         success = NT_SUCCESS(status);
+        hr = status;
+        
     }
     else
     {
         success = RtlAddFunctionTable(&xdataInfo->pdata, 1, functionStart);
+        if (!success)
+        {
+            hr = E_OUTOFMEMORY; // only OOM error can happen for RtlAddFunctionTable
+        }
+    }
+
+    if (!success)
+    {
+        Js::Throw::XDataRegistrationError(hr, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 
 #if DBG
     // Validate that the PDATA registration succeeded
diff --git a/lib/Common/Memory/arm/XDataAllocator.cpp b/lib/Common/Memory/arm/XDataAllocator.cpp
@@ -88,7 +88,10 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, DWORD functionStart,
         /*RangeBase*/ functionStart,
         /*RangeEnd*/ functionStart + functionSize);
 
-    Js::Throw::CheckAndThrowOutOfMemory(NT_SUCCESS(status));
+    if (!NT_SUCCESS(status))
+    {
+        Js::Throw::XDataRegistrationError(status, functionStart);
+    }
 
 #else  // !_WIN32
     Assert(ReadHead(xdataInfo->address));  // should be non-empty .eh_frame
diff --git a/lib/Common/Memory/arm64/XDataAllocator.cpp b/lib/Common/Memory/arm64/XDataAllocator.cpp
@@ -132,11 +132,12 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, ULONG_PTR functionSta
         /*RangeBase*/ functionStart,
         /*RangeEnd*/ functionStart + functionSize);
     BOOLEAN success = NT_SUCCESS(status);
-    if (success)
+    Assert(!success || xdataInfo->functionTable != nullptr);
+
+    if (!success)
     {
-        Assert(xdataInfo->functionTable != nullptr);
+        Js::Throw::XDataRegistrationError(status, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 
 #if DBG
     // Validate that the PDATA registration succeeded

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_PTR functionStart, _In_ const ULONG_PTR functionEnd, _Out_ PVOID* pdataTable, ULONG entryCount, ULONG maxEntryCount)`
`16`	`16`	`{`
`17`	`17`	`BOOLEAN success = FALSE;`
	`18`	`+ HRESULT hr = S_OK;`
`18`	`19`	`if (AutoSystemInfo::Data.IsWin8OrLater())`
`19`	`20`	`{`
`20`	`21`	`Assert(pdataTable != NULL);`
`@@ -28,17 +29,22 @@ void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_`
`28`	`29`	`/RangeBase/ functionStart,`
`29`	`30`	`/RangeEnd/ functionEnd);`
`30`	`31`	`success = NT_SUCCESS(status);`
`31`		`- if (success)`
`32`		`- {`
`33`		`- Assert(pdataTable);`
`34`		`- }`
	`32`	`+ Assert(!success \|\| pdataTable);`
	`33`	`+ hr = status;`
`35`	`34`	`}`
`36`	`35`	`else`
`37`	`36`	`{`
`38`	`37`	`*pdataTable = pdataStart;`
`39`	`38`	`success = RtlAddFunctionTable(pdataStart, entryCount, functionStart);`
	`39`	`+ if (!success)`
	`40`	`+ {`
	`41`	`+ hr = E_OUTOFMEMORY; // only OOM error can happen for RtlAddFunctionTable`
	`42`	`+ }`
	`43`	`+ }`
	`44`	`+ if (!success)`
	`45`	`+ {`
	`46`	`+ Js::Throw::XDataRegistrationError(hr, functionStart);`
`40`	`47`	`}`
`41`		`- Js::Throw::CheckAndThrowOutOfMemory(success);`
`42`	`48`	`}`
`43`	`49`
`44`	`50`	`void PDataManager::UnregisterPdata(RUNTIME_FUNCTION* pdata)`
Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,13 @@ NtdllLibrary::NTSTATUS NtdllLibrary::AddGrowableFunctionTable( _Out_ PVOID * Dyn`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
	`115`	`+#if DBG`
	`116`	`+ // Validate the PDATA was not registered or already unregistered`
	`117`	`+ ULONG_PTR imageBase = 0;`
	`118`	`+ RUNTIME_FUNCTION *runtimeFunction = RtlLookupFunctionEntry((DWORD64)RangeBase, &imageBase, nullptr);`
	`119`	`+ Assert(runtimeFunction == NULL);`
	`120`	`+#endif`
	`121`	`+`
`115`	`122`	`*DynamicTable = nullptr;`
`116`	`123`	`NTSTATUS status = addGrowableFunctionTable(DynamicTable,`
`117`	`124`	`FunctionTable,`
Original file line number	Diff line number	Diff line change
`@@ -125,13 +125,21 @@ namespace Js {`
`125`	`125`	`}`
`126`	`126`	`throw OutOfMemoryException();`
`127`	`127`	`}`
`128`		`- void Throw::CheckAndThrowOutOfMemory(BOOLEAN status)`
	`128`	`+`
	`129`	`+#if !defined(_M_IX86) && defined(_WIN32)`
	`130`	`+ void Throw::XDataRegistrationError(HRESULT hr, ULONG_PTR funcStart)`
`129`	`131`	`{`
`130`		`- if (!status)`
	`132`	`+ ULONG_PTR imageBase = 0;`
	`133`	`+ RUNTIME_FUNCTION *runtimeFunction = RtlLookupFunctionEntry(funcStart, &imageBase, nullptr);`
	`134`	`+`
	`135`	`+ if (JsUtil::ExternalApi::GetCurrentThreadContextId())`
`131`	`136`	`{`
`132`		`- OutOfMemory();`
	`137`	`+ XDataRegistration_unrecoverable_error(hr, (ULONG_PTR)runtimeFunction);`
`133`	`138`	`}`
	`139`	`+ throw OutOfMemoryException();`
`134`	`140`	`}`
	`141`	`+#endif`
	`142`	`+`
`135`	`143`	`void Throw::StackOverflow(ScriptContext *scriptContext, PVOID returnAddress)`
`136`	`144`	`{`
`137`	`145`	`#ifdef ENABLE_DEBUG_CONFIG_OPTIONS`