ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Common/PageFaultHandler: Support for unwind exceptions 

Needed for UWP.
This commit is contained in:
Connor McLaughlin 2021-07-10 18:01:17 +10:00
parent 6251894d3c
commit 0f911e9dbf
2 changed files with 168 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
src/common/page_fault_handler.cpp
View File

@ -24,8 +24,10 @@ namespace Common::PageFaultHandler {
struct RegisteredHandler
{
void* owner;
Callback callback;
const void* owner;
void* start_pc;
u32 code_size;
};
static std::vector<RegisteredHandler> m_handlers;
static std::mutex m_handler_lock;
@ -114,6 +116,145 @@ static LONG ExceptionHandler(PEXCEPTION_POINTERS exi)
return EXCEPTION_CONTINUE_SEARCH;
}
u32 GetHandlerCodeSize()
{
return 0;
}
#elif defined(_UWP)
// https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-160
struct UNWIND_INFO
{
BYTE version : 3;
BYTE flags : 5;
BYTE size_of_prologue;
BYTE count_of_unwind_codes;
BYTE frame_register : 4;
BYTE frame_offset_scaled : 4;
ULONG exception_handler_address;
};
struct UnwindHandler
{
RUNTIME_FUNCTION runtime_function;
UNWIND_INFO unwind_info;
uint8_t exception_handler_code[32];
};
static constexpr size_t UNWIND_HANDLER_ALLOC_SIZE = 4096;
static_assert(sizeof(UnwindHandler) <= UNWIND_HANDLER_ALLOC_SIZE);
static EXCEPTION_DISPOSITION UnwindExceptionHandler(PEXCEPTION_RECORD ExceptionRecord, ULONG64 EstablisherFrame,
PCONTEXT ContextRecord, PDISPATCHER_CONTEXT DispatcherContext)
{
if (s_in_handler)
return ExceptionContinueSearch;
s_in_handler = true;
void* const exception_pc = reinterpret_cast<void*>(DispatcherContext->ControlPc);
void* const exception_address = reinterpret_cast<void*>(ExceptionRecord->ExceptionInformation[1]);
bool const is_write = ExceptionRecord->ExceptionInformation[0] == 1;
std::lock_guard<std::mutex> guard(m_handler_lock);
for (const RegisteredHandler& rh : m_handlers)
{
if (static_cast<const u8*>(exception_pc) >= static_cast<const u8*>(rh.start_pc) &&
static_cast<const u8*>(exception_pc) <= (static_cast<const u8*>(rh.start_pc) + rh.code_size))
{
if (rh.callback(exception_pc, exception_address, is_write) == HandlerResult::ContinueExecution)
{
s_in_handler = false;
return ExceptionContinueExecution;
}
}
}
s_in_handler = false;
return ExceptionContinueSearch;
}
static PRUNTIME_FUNCTION GetRuntimeFunctionCallback(DWORD64 ControlPc, PVOID Context)
{
std::lock_guard<std::mutex> guard(m_handler_lock);
for (const RegisteredHandler& rh : m_handlers)
{
if (ControlPc >= reinterpret_cast<DWORD64>(rh.start_pc) &&
ControlPc <= (reinterpret_cast<DWORD64>(rh.start_pc) + rh.code_size))
{
return reinterpret_cast<PRUNTIME_FUNCTION>(rh.start_pc);
}
}
return nullptr;
}
static bool InstallFunctionTableCallback(const void* owner, void* start_pc, u32 code_size)
{
if (code_size < UNWIND_HANDLER_ALLOC_SIZE)
{
Log_ErrorPrintf("Invalid code size: %u @ %p", code_size, UNWIND_HANDLER_ALLOC_SIZE);
return false;
}
if (!RtlInstallFunctionTableCallback(reinterpret_cast<DWORD64>(owner) | 0x3, reinterpret_cast<DWORD64>(start_pc),
static_cast<DWORD>(code_size), &GetRuntimeFunctionCallback, nullptr, nullptr))
{
Log_ErrorPrintf("RtlInstallFunctionTableCallback() failed: %08X", GetLastError());
return false;
}
// This is only valid on x86 for now.
#ifndef CPU_X64
Log_ErrorPrint("Exception unwind codegen not implemented");
return false;
#else
UnwindHandler* uh = static_cast<UnwindHandler*>(start_pc);
ULONG old_protection;
if (!VirtualProtectFromApp(uh, UNWIND_HANDLER_ALLOC_SIZE, PAGE_READWRITE, &old_protection))
{
Log_ErrorPrintf("VirtualProtectFromApp(RW) for exception handler failed: %08X", GetLastError());
return false;
}
uh->runtime_function.BeginAddress = UNWIND_HANDLER_ALLOC_SIZE;
uh->runtime_function.EndAddress = code_size;
uh->runtime_function.UnwindInfoAddress = offsetof(UnwindHandler, unwind_info);
uh->unwind_info.version = 1;
uh->unwind_info.flags = UNW_FLAG_EHANDLER;
uh->unwind_info.size_of_prologue = 0;
uh->unwind_info.count_of_unwind_codes = 0;
uh->unwind_info.frame_register = 0;
uh->unwind_info.frame_offset_scaled = 0;
uh->unwind_info.exception_handler_address = offsetof(UnwindHandler, exception_handler_code);
// mov rax, handler
const void* handler = UnwindExceptionHandler;
uh->exception_handler_code[0] = 0x48;
uh->exception_handler_code[1] = 0xb8;
std::memcpy(&uh->exception_handler_code[2], &handler, sizeof(handler));
// jmp rax
uh->exception_handler_code[10] = 0xff;
uh->exception_handler_code[11] = 0xe0;
if (!VirtualProtectFromApp(uh, UNWIND_HANDLER_ALLOC_SIZE, PAGE_EXECUTE_READ, &old_protection))
{
Log_ErrorPrintf("VirtualProtectFromApp(RX) for exception handler failed: %08X", GetLastError());
return false;
}
return true;
#endif
}
u32 GetHandlerCodeSize()
{
return UNWIND_HANDLER_ALLOC_SIZE;
}
#elif defined(USE_SIGSEGV)
static struct sigaction s_old_sigsegv_action;
@ -204,9 +345,21 @@ static void SIGSEGVHandler(int sig, siginfo_t* info, void* ctx)
sa.sa_handler(sig);
}
u32 GetHandlerCodeSize()
{
return 0;
}
#else
u32 GetHandlerCodeSize()
{
return 0;
}
#endif
bool InstallHandler(void* owner, Callback callback)
bool InstallHandler(const void* owner, void* start_pc, u32 code_size, Callback callback)
{
bool was_empty;
{
@ -218,7 +371,6 @@ bool InstallHandler(void* owner, Callback callback)
}
was_empty = m_handlers.empty();
m_handlers.push_back(RegisteredHandler{owner, std::move(callback)});
}
if (was_empty)
@ -230,19 +382,13 @@ bool InstallHandler(void* owner, Callback callback)
Log_ErrorPrint("Failed to add vectored exception handler");
return false;
}
#elif defined(USE_SIGSEGV)
#if 0
// Alternative stack - we'll need this is we ever use the host stack for branches.
stack_t signal_stack = {};
signal_stack.ss_sp = malloc(SIGSTKSZ);
signal_stack.ss_size = SIGSTKSZ;
if (sigaltstack(&signal_stack, nullptr))
#elif defined(_UWP)
if (!InstallFunctionTableCallback(owner, start_pc, code_size))
{
Log_ErrorPrintf("signaltstack() failed: %d", errno);
Log_ErrorPrint("Failed to install function table callback");
return false;
}
#endif
#elif defined(USE_SIGSEGV)
struct sigaction sa = {};
sa.sa_sigaction = SIGSEGVHandler;
sa.sa_flags = SA_SIGINFO;
@ -265,10 +411,11 @@ bool InstallHandler(void* owner, Callback callback)
#endif
}
m_handlers.push_back(RegisteredHandler{callback, owner, start_pc, code_size});
return true;
}
bool RemoveHandler(void* owner)
bool RemoveHandler(const void* owner)
{
std::lock_guard<std::mutex> guard(m_handler_lock);
auto it = std::find_if(m_handlers.begin(), m_handlers.end(),
@ -283,6 +430,8 @@ bool RemoveHandler(void* owner)
#if defined(_WIN32) && !defined(_UWP) && (defined(CPU_X64) || defined(CPU_AARCH64))
RemoveVectoredExceptionHandler(s_veh_handle);
s_veh_handle = nullptr;
#elif defined(_UWP)
// nothing to do here, any unregistered regions will be ignored
#elif defined(USE_SIGSEGV)
// restore old signal handler
#if defined(__APPLE__) || defined(__aarch64__)

8
src/common/page_fault_handler.h
View File

@ -8,10 +8,12 @@ enum class HandlerResult
ExecuteNextHandler,
};
using Callback = HandlerResult(*)(void* exception_pc, void* fault_address, bool is_write);
using Callback = HandlerResult (*)(void* exception_pc, void* fault_address, bool is_write);
using Handle = void*;
bool InstallHandler(void* owner, Callback callback);
bool RemoveHandler(void* owner);
u32 GetHandlerCodeSize();
bool InstallHandler(const void* owner, void* start_pc, u32 code_size, Callback callback);
bool RemoveHandler(const void* owner);
} // namespace Common::PageFaultHandler