Run native Windows DLSS K and M through an explicit OptiScaler source backend
This commit is contained in:
Codex committed
1 parent
27d6a1230a
commit
e14b4cb54c
9 files changed
+633
-8
No files matched your search
@@ -147,6 +147,10 @@ endif()
|
||||
install(TARGETS d4r_nvapi_compat RUNTIME DESTINATION nvapi-compat)
|
||||
target_link_libraries(d4r_d3d12_hip_interop_probe PRIVATE d3d12 dxgi dxguid)
|
||||
target_link_libraries(d4r_d3d12_dlss_probe PRIVATE d3d12 dxgi dxguid)
|
||||
add_executable(d4r_debug_launcher tools/windows/debug_launcher.cpp)
|
||||
target_include_directories(d4r_debug_launcher PRIVATE tools/windows)
|
||||
target_link_libraries(d4r_debug_launcher PRIVATE version dbghelp)
|
||||
install(TARGETS d4r_debug_launcher RUNTIME DESTINATION bin)
|
||||
target_link_libraries(d4r_d3d12_command_probe PRIVATE d3d12 dxgi dxguid)
|
||||
target_link_libraries(d4r_d3d12_pixel_probe PRIVATE d3d12 dxgi dxguid)
|
||||
add_dependencies(d4r_d3d12_pixel_probe d4r_pixel_code_object)
|
||||
|
||||
@@ -14,8 +14,10 @@ submission, and returns output in the same frame without CPU image copies.
|
||||
RGBA16/32F, R11G11B10, RGBA/BGRA8, depth, exposure and motion formats have
|
||||
independent D3D12 typed SRV/UAV conversion tests. Four-frame K/M runs with packed
|
||||
output match the FP16 baseline exactly after resource-format quantisation.
|
||||
The build incorporates upstream RDNA4 commit `dbef4b2`. OptiScaler/game
|
||||
integration and performance profiling remain in progress; no game support is
|
||||
The build incorporates upstream RDNA4 commit `dbef4b2`. Patched OptiScaler now
|
||||
passes standalone K/M native-network tests with exact RGB agreement against
|
||||
the direct-d4r baseline; see [the source patch](patches/optiscaler/README.md).
|
||||
Game integration and performance profiling remain in progress; no game support is
|
||||
claimed yet. See [build instructions and hardware results](docs/windows-rdna4-port.md).
|
||||
|
||||
See [supported games](SUPPORTED_GAMES.md) for the tested games and DLSS models.
|
||||
|
||||
@@ -3,7 +3,8 @@
|
||||
Branch: `windows-rdna4`. Target: Windows 11 x64, RX 9070 XT, **gfx1201**.
|
||||
Priority: correct K, correct M, native Windows, same-frame output, then speed.
|
||||
This is a work log for an implementation in progress. Standalone DLSS K/M
|
||||
works on the real Windows GPU; OptiScaler/game support remains unverified.
|
||||
works on the real Windows GPU, including the patched OptiScaler frontend.
|
||||
An actual game session remains unverified.
|
||||
|
||||
## Milestone and gates
|
||||
|
||||
@@ -36,7 +37,7 @@ Do not integrate NGX until the integer PTX workload is stable on the real GPU.
|
||||
| M6: K layers, full transformer and image validation | PASS: 11 real-weight layers, 44 native launches, four D3D12 frames bit-exact against native CUDA, 81.85–92.91 dB versus translated K |
|
||||
| M7: M FP16-equivalent baseline and full transformer | PASS: all blocks of 40 native launches exactly match NumPy; targeted independent PTX regression matches; four D3D12 frames bit-exact against corrected translated M |
|
||||
| M8: standalone Windows D3D12 NGX harness | PASS for ordinary recorded EvaluateFeature and explicit boundaries: K/M, four frames each, no shim CPU image copies; both bit-exact against explicit boundary baselines |
|
||||
| M9: OptiScaler integration, profiling, installation | Pending |
|
||||
| M9: OptiScaler integration, profiling, installation | Patched frontend K/M PASS; game, profiling and final package pending |
|
||||
|
||||
## Public NGX identity and OptiScaler gate (2026-10-01)
|
||||
|
||||
@@ -70,13 +71,43 @@ A local OptiScaler source fork starts from
|
||||
`45a2001303ddff632e279f77aef85ceede5832cb`. Its explicit
|
||||
`[DLSS] AllowExternalBackend=true` option requires an absolute NvngxPath with
|
||||
the `d4r_WindowsBackendVersion` ABI-1 marker; it does not spoof HIP architecture.
|
||||
The marker is GPU-free and safe during discovery. The pending patch also lets
|
||||
the external backend load its own NVAPI provider through the original loader.
|
||||
This source integration has not yet passed the frontend harness.
|
||||
The marker is GPU-free and safe during discovery. The patch lets the external
|
||||
backend load its own NVAPI provider through the original loader and preserves
|
||||
the exact locally supplied CUDA NGX core path from frontend redirection.
|
||||
Physical adapter capability is queried outside DLL startup instead of using
|
||||
NVIDIA architecture as a proxy. GetFeatureRequirements spoofing is bypassed.
|
||||
Explicit external DLSS selection returns errors instead of silently using FSR.
|
||||
Microsoft Build Tools 17.14 / MSVC 14.44.35207 and SDK 10.0.26100 were installed
|
||||
from the signature-verified official bootstrapper without restarting Windows.
|
||||
No game files have been modified.
|
||||
|
||||
The OptiScaler fork commit is `33bbac2` on `windows-rdna4-d4r`. Its reproducible
|
||||
source patch and build instructions are in [patches/optiscaler](../patches/optiscaler/README.md).
|
||||
`build-optiscaler-windows.ps1` produces a DLL, PDB, GPL license and dependency
|
||||
metadata from pinned source/submodules; it disables upstream's unrelated
|
||||
packaging post-build commands. The public D3D12 probe now supplies and submits
|
||||
a real open creation command list, as required by OptiScaler's API.
|
||||
|
||||
`optiscaler-k-final.zip` and `optiscaler-m-final.zip` pass four complete
|
||||
OptiScaler -> Windows d4r -> CUDA NGX -> ZLUDA/HIP evaluations on RX 9070 XT.
|
||||
They contain 44 K and 40 M native transformer launches, respectively. Every
|
||||
RGB value exactly matches the independently quantised direct-d4r baseline;
|
||||
max absolute/relative error is 0. No FSR evaluation, NaN/Inf, shim CPU image copy
|
||||
or previous-frame output is observed. The invalid-core regression intentionally
|
||||
passes the shim as the CUDA core: it fails with an explicit frontend
|
||||
`refusing FSR fallback` message and zero FSR evaluations, as required.
|
||||
|
||||
The loader crash was localized with a PDB to Util::IsSubpath calling
|
||||
filesystem::relative/weakly_canonical from LdrLoadDll interception. The patched
|
||||
check is lexical, case-insensitive and handles empty relative paths without
|
||||
filesystem I/O. The separate `d4r_debug_launcher.exe`, enabled by
|
||||
`-CaptureExceptions`, captures minidumps, first/second-chance exception codes,
|
||||
module load/unload addresses and raw stack slots outside the hooked process.
|
||||
It propagates the child's exit code and terminates its child on runner timeout
|
||||
via a process lifetime job. `optiscaler-m-source-debug2.zip` contains the
|
||||
successful dump capture and `optiscaler-source-stack-symbols.log` the source
|
||||
attribution. The ordinary in-process crash filter remains available too.
|
||||
|
||||
## Initial PSO and enhanced texture layouts (2026-10-01)
|
||||
|
||||
The backend now captures the initial PSO supplied to public CreateCommandList,
|
||||
|
||||
@@ -0,0 +1,328 @@
|
||||
From 33bbac250ac7e2ca4eff67e8817ada9dad578208 Mon Sep 17 00:00:00 2001
|
||||
From: Codex <codex@localhost>
|
||||
Date: Thu, 1 Oct 2026 16:10:08 +0300
|
||||
Subject: [PATCH] Support explicitly selected Windows d4r DLSS backend on
|
||||
physical AMD adapters
|
||||
|
||||
---
|
||||
OptiScaler/Config.cpp | 3 ++
|
||||
OptiScaler/Config.h | 1 +
|
||||
OptiScaler/OptiScaler.vcxproj | 4 +--
|
||||
OptiScaler/State.h | 1 +
|
||||
OptiScaler/Util.cpp | 12 +++++--
|
||||
OptiScaler/dllmain.cpp | 33 +++++++++++++++++--
|
||||
OptiScaler/hooks/LibraryLoad_Hooks.cpp | 17 ++++++++++
|
||||
OptiScaler/inputs/NVNGX_DLSS_Dx12.cpp | 17 ++++++++++
|
||||
OptiScaler/misc/IdentifyGpu.cpp | 20 +++++++++++
|
||||
OptiScaler/proxies/NVNGX_Proxy.h | 5 ++-
|
||||
OptiScaler/upscalers/FeatureProvider_Dx12.cpp | 10 ++++++
|
||||
11 files changed, 115 insertions(+), 8 deletions(-)
|
||||
|
||||
diff --git a/OptiScaler/Config.cpp b/OptiScaler/Config.cpp
|
||||
index d8c62d3..f444387 100644
|
||||
--- a/OptiScaler/Config.cpp
|
||||
+++ b/OptiScaler/Config.cpp
|
||||
@@ -323,6 +323,7 @@ bool Config::Reload(std::filesystem::path iniPath)
|
||||
{
|
||||
// Don't enable again if set false because of no nvngx found
|
||||
DLSSEnabled.set_from_config(readBool("DLSS", "Enabled"));
|
||||
+ DLSSAllowExternalBackend.set_from_config(readBool("DLSS", "AllowExternalBackend"));
|
||||
UseGenericAppIdWithDlss.set_from_config(readBool("DLSS", "UseGenericAppIdWithDlss"));
|
||||
|
||||
RenderPresetOverride.set_from_config(readBool("DLSS", "RenderPresetOverride"));
|
||||
@@ -1168,6 +1169,8 @@ bool Config::SaveIni()
|
||||
// DLSS
|
||||
{
|
||||
ini.SetValue("DLSS", "Enabled", GetBoolValue(Instance()->DLSSEnabled.value_for_config()).c_str());
|
||||
+ ini.SetValue("DLSS", "AllowExternalBackend",
|
||||
+ GetBoolValue(Instance()->DLSSAllowExternalBackend.value_for_config()).c_str());
|
||||
ini.SetValue("DLSS", "RenderPresetOverride",
|
||||
GetBoolValue(Instance()->RenderPresetOverride.value_for_config()).c_str());
|
||||
ini.SetValue("DLSS", "RenderPresetForAll",
|
||||
diff --git a/OptiScaler/Config.h b/OptiScaler/Config.h
|
||||
index 4ab62a4..0caf8c8 100644
|
||||
--- a/OptiScaler/Config.h
|
||||
+++ b/OptiScaler/Config.h
|
||||
@@ -275,6 +275,7 @@ class Config
|
||||
|
||||
// DLSS
|
||||
CustomOptional<bool> DLSSEnabled { true };
|
||||
+ CustomOptional<bool> DLSSAllowExternalBackend { false };
|
||||
CustomOptional<bool> RenderPresetOverride { false };
|
||||
CustomOptional<uint32_t> RenderPresetForAll { 0 };
|
||||
CustomOptional<uint32_t> RenderPresetDLAA { 0 };
|
||||
diff --git a/OptiScaler/OptiScaler.vcxproj b/OptiScaler/OptiScaler.vcxproj
|
||||
index 24ca80b..dfbfc97 100644
|
||||
--- a/OptiScaler/OptiScaler.vcxproj
|
||||
+++ b/OptiScaler/OptiScaler.vcxproj
|
||||
@@ -236,7 +236,7 @@
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
- <GenerateDebugInformation>false</GenerateDebugInformation>
|
||||
+ <GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableUAC>false</EnableUAC>
|
||||
<AdditionalDependencies>winhttp.lib;WindowsApp.lib;Dbghelp.lib;dxgi.lib;d3d11.lib;d3d12.lib;vulkan-1.lib;dxguid.lib;freetype.lib;ffx_fsr2_api_x64.lib;ffx_fsr2_api_dx11_x64.lib;ffx_fsr2_api_dx12_x64.lib;ffx_fsr2_api_vk_x64.lib;ffx_fsr2_212_api_dx12_x64.lib;ffx_fsr2_212_api_vk_x64.lib;ffx_fsr2_212_api_x64.lib;d3dcompiler.lib;ffx_backend_dx11_x64.lib;ffx_fsr3_x64.lib;ffx_frameinterpolation_x64.lib;ffx_fsr3upscaler_x64.lib;ffx_opticalflow_x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<ModuleDefinitionFile>Source.def</ModuleDefinitionFile>
|
||||
@@ -873,4 +873,4 @@ copy NUL "$(SolutionDir)x64\Release\a\!! EXTRACT ALL FILES TO GAME FOLDER !!" /Y
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
-</Project>
|
||||
\ No newline at end of file
|
||||
+</Project>
|
||||
diff --git a/OptiScaler/State.h b/OptiScaler/State.h
|
||||
index 42164de..84f8263 100644
|
||||
--- a/OptiScaler/State.h
|
||||
+++ b/OptiScaler/State.h
|
||||
@@ -265,6 +265,7 @@ class State
|
||||
int dlssgDetectedInterpolationCount = 0;
|
||||
|
||||
// DLSS
|
||||
+ bool dlssExternalBackend = false;
|
||||
bool dlssPresetsOverriddenExternally = false;
|
||||
bool dlssPresetsOverridenByOpti = false;
|
||||
uint32_t dlssRenderPresetExternal = 0;
|
||||
diff --git a/OptiScaler/Util.cpp b/OptiScaler/Util.cpp
|
||||
index f7ac6fa..7367a91 100644
|
||||
--- a/OptiScaler/Util.cpp
|
||||
+++ b/OptiScaler/Util.cpp
|
||||
@@ -486,8 +486,16 @@ bool Util::GetFileVersion(std::wstring dllPath, version_t* fileVersionOut, versi
|
||||
|
||||
bool Util::IsSubpath(const std::filesystem::path& path, const std::filesystem::path& base)
|
||||
{
|
||||
- auto rel = std::filesystem::relative(path, base);
|
||||
- auto first = *rel.begin();
|
||||
+ // Called by LdrLoadDll hooks: relative()/weakly_canonical() perform file
|
||||
+ // queries, can re-enter the hooks, and throw when an optional directory or
|
||||
+ // a bare DLL search name cannot be resolved. This is a lexical routing
|
||||
+ // check, not a filesystem access control decision.
|
||||
+ auto normalizedPath = std::filesystem::path(ToLower(path.lexically_normal().wstring()));
|
||||
+ auto normalizedBase = std::filesystem::path(ToLower(base.lexically_normal().wstring()));
|
||||
+ auto rel = normalizedPath.lexically_relative(normalizedBase);
|
||||
+ if (rel.empty())
|
||||
+ return false;
|
||||
+ const auto first = *rel.begin();
|
||||
return first != "." && first != "..";
|
||||
}
|
||||
|
||||
diff --git a/OptiScaler/dllmain.cpp b/OptiScaler/dllmain.cpp
|
||||
index cba14b1..b4b786e 100644
|
||||
--- a/OptiScaler/dllmain.cpp
|
||||
+++ b/OptiScaler/dllmain.cpp
|
||||
@@ -948,7 +948,7 @@ static void CheckWorkingMode()
|
||||
|
||||
// NVAPI
|
||||
// Doesn't seem to like GetModuleHandle for some reason, so call our load to make sure
|
||||
- if (GetDllNameWModule(&nvapiNamesW) != nullptr)
|
||||
+ if (!State::Instance().dlssExternalBackend && GetDllNameWModule(&nvapiNamesW) != nullptr)
|
||||
{
|
||||
// This hooks nvapi as well when possible
|
||||
auto nvapi64 = LibraryLoadHooks::LoadNvApi();
|
||||
@@ -1958,7 +1958,33 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
|
||||
return nvidiaDetected;
|
||||
};
|
||||
|
||||
- bool possibleNvidia = isNvidiaViaNvapi();
|
||||
+ // Opt in only to a configured, versioned Windows d4r backend. The
|
||||
+ // marker performs no HIP/NGX initialization under DLL_PROCESS_ATTACH.
|
||||
+ // GPU support is still checked by its public NGX requirements API.
|
||||
+ if (Config::Instance()->DLSSEnabled.value_or_default() &&
|
||||
+ Config::Instance()->DLSSAllowExternalBackend.value_or_default() &&
|
||||
+ Config::Instance()->NvngxPath.has_value())
|
||||
+ {
|
||||
+ auto backendPath = std::filesystem::path(Config::Instance()->NvngxPath.value()) / L"_nvngx.dll";
|
||||
+ if (backendPath.is_absolute())
|
||||
+ {
|
||||
+ auto module = NtdllProxy::LoadLibraryExW_Ldr(backendPath.c_str(), nullptr,
|
||||
+ LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
|
||||
+ if (module)
|
||||
+ {
|
||||
+ using BackendVersion = unsigned (*)();
|
||||
+ auto version = reinterpret_cast<BackendVersion>(
|
||||
+ KernelBaseProxy::GetProcAddress_()(module, "d4r_WindowsBackendVersion"));
|
||||
+ State::Instance().dlssExternalBackend = version && version() == 1;
|
||||
+ NtdllProxy::FreeLibrary_Ldr(module);
|
||||
+ }
|
||||
+ }
|
||||
+ if (State::Instance().dlssExternalBackend)
|
||||
+ spdlog::info("Validated external Windows d4r DLSS backend; retaining physical GPU identity");
|
||||
+ else
|
||||
+ spdlog::error("AllowExternalBackend requires an absolute NvngxPath containing Windows d4r ABI 1");
|
||||
+ }
|
||||
+ bool possibleNvidia = !State::Instance().dlssExternalBackend && isNvidiaViaNvapi();
|
||||
|
||||
spdlog::info("");
|
||||
spdlog::info("Check for DLSS files");
|
||||
@@ -1992,7 +2018,8 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserv
|
||||
State::Instance().NVNGX_DLSSG_Path = Util::FindFilePath(exePath, "nvngx_dlssg.dll");
|
||||
|
||||
// Not 100% accurate for Nvidia cards without DLSS
|
||||
- if (Config::Instance()->DLSSEnabled.value_or_default() && possibleNvidia)
|
||||
+ if (Config::Instance()->DLSSEnabled.value_or_default() &&
|
||||
+ (possibleNvidia || State::Instance().dlssExternalBackend))
|
||||
{
|
||||
if (State::Instance().NVNGX_DLSS_Path.has_value())
|
||||
{
|
||||
diff --git a/OptiScaler/hooks/LibraryLoad_Hooks.cpp b/OptiScaler/hooks/LibraryLoad_Hooks.cpp
|
||||
index 90bdb89..108ea5b 100644
|
||||
--- a/OptiScaler/hooks/LibraryLoad_Hooks.cpp
|
||||
+++ b/OptiScaler/hooks/LibraryLoad_Hooks.cpp
|
||||
@@ -46,6 +46,18 @@ HMODULE LibraryLoadHooks::LoadLibraryCheckW(std::wstring libName, LPCWSTR lpLibF
|
||||
{
|
||||
auto libNameA = wstring_to_string(libName);
|
||||
|
||||
+ // The external D3D12 shim itself uses a locally supplied CUDA NGX core.
|
||||
+ // Keep that exact absolute path distinct from game-facing NGX interception.
|
||||
+ if (State::Instance().dlssExternalBackend)
|
||||
+ {
|
||||
+ wchar_t corePath[32768] {};
|
||||
+ const auto length = GetEnvironmentVariableW(L"D4R_NGX_CORE", corePath, 32768);
|
||||
+ if (length && length < 32768 &&
|
||||
+ Util::ToLower(std::filesystem::path(libName).lexically_normal().wstring()) ==
|
||||
+ Util::ToLower(std::filesystem::path(corePath).lexically_normal().wstring()))
|
||||
+ return nullptr;
|
||||
+ }
|
||||
+
|
||||
#ifdef LOG_LIB_OPERATIONS
|
||||
LOG_TRACE("{}", libNameA);
|
||||
#endif
|
||||
@@ -132,6 +144,11 @@ HMODULE LibraryLoadHooks::LoadLibraryCheckW(std::wstring libName, LPCWSTR lpLibF
|
||||
// NvApi64.dll
|
||||
if (CheckDllNameW(&libName, &nvapiNamesW))
|
||||
{
|
||||
+ // An explicit external CUDA backend owns its NVAPI topology provider.
|
||||
+ // Returning OptiScaler's fake-NVAPI would replace that provider and can
|
||||
+ // recurse into DXGI while the NGX loader holds the loader lock.
|
||||
+ if (State::Instance().dlssExternalBackend)
|
||||
+ return nullptr; // Continue through the original loader.
|
||||
LOG_INFO("{} call!", libNameA);
|
||||
|
||||
return LibraryLoadHooks::LoadNvApi();
|
||||
diff --git a/OptiScaler/inputs/NVNGX_DLSS_Dx12.cpp b/OptiScaler/inputs/NVNGX_DLSS_Dx12.cpp
|
||||
index 68e1b42..89c9ba8 100644
|
||||
--- a/OptiScaler/inputs/NVNGX_DLSS_Dx12.cpp
|
||||
+++ b/OptiScaler/inputs/NVNGX_DLSS_Dx12.cpp
|
||||
@@ -687,6 +687,7 @@ static NVSDK_NGX_Result TryCreateOptiFeature(ID3D12GraphicsCommandList* InCmdLis
|
||||
}
|
||||
|
||||
// Assign handle
|
||||
+ const bool allocatedHandle = *OutHandle == nullptr;
|
||||
if (*OutHandle == nullptr)
|
||||
*OutHandle = new NVSDK_NGX_Handle { handleId };
|
||||
else
|
||||
@@ -705,6 +706,16 @@ static NVSDK_NGX_Result TryCreateOptiFeature(ID3D12GraphicsCommandList* InCmdLis
|
||||
}
|
||||
else
|
||||
{
|
||||
+ if (state.dlssExternalBackend && upscalerBackend == Upscaler::DLSS)
|
||||
+ {
|
||||
+ LOG_ERROR("External DLSS initialization failed; refusing FSR fallback");
|
||||
+ if (shouldRestoreSigs)
|
||||
+ D3D12Hooks::RestoreRoot(InCmdList);
|
||||
+ D3D12Hooks::SetRootSignatureTracking(true);
|
||||
+ Dx12Contexts.erase(handleId);
|
||||
+ if (allocatedHandle) { delete *OutHandle; *OutHandle = nullptr; }
|
||||
+ return NVSDK_NGX_Result_Fail;
|
||||
+ }
|
||||
LOG_ERROR("Feature '{}' initialization failed falling back to FSR 2.1.2", UpscalerDisplayName(upscalerBackend));
|
||||
state.newBackend = Upscaler::FSR21;
|
||||
state.changeBackend[handleId] = true;
|
||||
@@ -1027,6 +1038,12 @@ static NVSDK_NGX_Result TryEvaluateOptiFeature(ID3D12GraphicsCommandList* InCmdL
|
||||
// Fallback to FSR 2.1.2 if feature failed to initialize and user didn't explicitly request it
|
||||
if (!feature->IsInited() && cfg.Dx12Upscaler.value_or_default() != Upscaler::FSR21)
|
||||
{
|
||||
+ if (state.dlssExternalBackend && cfg.Dx12Upscaler.value_or_default() == Upscaler::DLSS)
|
||||
+ {
|
||||
+ LOG_ERROR("External DLSS feature is not initialized; refusing FSR fallback");
|
||||
+ D3D12Hooks::SetRootSignatureTracking(true);
|
||||
+ return NVSDK_NGX_Result_Fail;
|
||||
+ }
|
||||
LOG_WARN("Feature '{}' failed to initialize. Falling back to FSR 2.1.2", feature->Name());
|
||||
ImGui::InsertNotification({ ImGuiToastType::Warning, 10000, "Falling back to FSR 2.1.2" });
|
||||
|
||||
diff --git a/OptiScaler/misc/IdentifyGpu.cpp b/OptiScaler/misc/IdentifyGpu.cpp
|
||||
index 3877f9f..6c05904 100644
|
||||
--- a/OptiScaler/misc/IdentifyGpu.cpp
|
||||
+++ b/OptiScaler/misc/IdentifyGpu.cpp
|
||||
@@ -8,6 +8,7 @@
|
||||
#include <proxies/D3d12_Proxy.h>
|
||||
#include "nvapi/NvApiTypes.h"
|
||||
#include <hooks/Amdxc64_Hooks.h>
|
||||
+#include <proxies/NVNGX_Proxy.h>
|
||||
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
@@ -187,6 +188,25 @@ std::vector<GpuInformation> IdentifyGpu::checkGpuInfo()
|
||||
|
||||
for (auto& gpuInfo : localCachedInfo)
|
||||
{
|
||||
+ if (State::Instance().dlssExternalBackend && !gpuInfo.softwareAdapter)
|
||||
+ {
|
||||
+ // Query the configured D3D12 backend outside DLL_PROCESS_ATTACH.
|
||||
+ // Preserve vendor/device/architecture data obtained from DXGI.
|
||||
+ auto requirements = NVNGXProxy::D3D12_GetFeatureRequirements();
|
||||
+ ComPtr<IDXGIAdapter1> physicalAdapter;
|
||||
+ if (requirements && SUCCEEDED(factory->EnumAdapterByLuid(gpuInfo.luid, IID_PPV_ARGS(&physicalAdapter))))
|
||||
+ {
|
||||
+ NVSDK_NGX_FeatureDiscoveryInfo discovery {};
|
||||
+ discovery.SDKVersion = NVSDK_NGX_Version_API;
|
||||
+ discovery.FeatureID = NVSDK_NGX_Feature_SuperSampling;
|
||||
+ NVSDK_NGX_FeatureRequirement supported {};
|
||||
+ const auto result = requirements(physicalAdapter.Get(), &discovery, &supported);
|
||||
+ gpuInfo.dlssCapable = result == NVSDK_NGX_Result_Success &&
|
||||
+ supported.FeatureSupported == NVSDK_NGX_FeatureSupportResult_Supported;
|
||||
+ LOG_INFO("External D3D12 DLSS backend: {} support={} result={:X}",
|
||||
+ gpuInfo.name, gpuInfo.dlssCapable, (unsigned) result);
|
||||
+ }
|
||||
+ }
|
||||
if (gpuInfo.vendorId == VendorId::Nvidia)
|
||||
{
|
||||
queryNvapi(gpuInfo);
|
||||
diff --git a/OptiScaler/proxies/NVNGX_Proxy.h b/OptiScaler/proxies/NVNGX_Proxy.h
|
||||
index f6c08e5..7892009 100644
|
||||
--- a/OptiScaler/proxies/NVNGX_Proxy.h
|
||||
+++ b/OptiScaler/proxies/NVNGX_Proxy.h
|
||||
@@ -500,7 +500,10 @@ class NVNGXProxy
|
||||
{
|
||||
LOG_INFO("Getting nvngx method addresses");
|
||||
|
||||
- HookNgxApi(_module.dll);
|
||||
+ // The external bridge reports physical adapter support itself.
|
||||
+ // Do not overwrite its unsupported result with NVIDIA spoofing.
|
||||
+ if (!State::Instance().dlssExternalBackend)
|
||||
+ HookNgxApi(_module.dll);
|
||||
|
||||
_module.D3D11_Init =
|
||||
(PFN_D3D11_Init) KernelBaseProxy::GetProcAddress_()(_module.dll, "NVSDK_NGX_D3D11_Init");
|
||||
diff --git a/OptiScaler/upscalers/FeatureProvider_Dx12.cpp b/OptiScaler/upscalers/FeatureProvider_Dx12.cpp
|
||||
index d738498..1191b29 100644
|
||||
--- a/OptiScaler/upscalers/FeatureProvider_Dx12.cpp
|
||||
+++ b/OptiScaler/upscalers/FeatureProvider_Dx12.cpp
|
||||
@@ -42,6 +42,11 @@ bool FeatureProvider_Dx12::GetFeature(Upscaler upscaler, UINT handleId, NVSDK_NG
|
||||
break;
|
||||
|
||||
case Upscaler::DLSS:
|
||||
+ if (state.dlssExternalBackend && (!primaryGpu.dlssCapable || !state.NVNGX_DLSS_Path.has_value()))
|
||||
+ {
|
||||
+ LOG_ERROR("Configured external D3D12 DLSS backend is unavailable; refusing FSR fallback");
|
||||
+ return false;
|
||||
+ }
|
||||
if (primaryGpu.dlssCapable && state.NVNGX_DLSS_Path.has_value())
|
||||
{
|
||||
*feature = std::make_unique<DLSSFeatureDx12>(handleId, parameters);
|
||||
@@ -77,6 +82,11 @@ bool FeatureProvider_Dx12::GetFeature(Upscaler upscaler, UINT handleId, NVSDK_NG
|
||||
|
||||
if (!loaded)
|
||||
{
|
||||
+ if (state.dlssExternalBackend && upscaler == Upscaler::DLSS)
|
||||
+ {
|
||||
+ LOG_ERROR("External D3D12 DLSS module failed to load; refusing FSR fallback");
|
||||
+ return false;
|
||||
+ }
|
||||
// Fail after the constructor
|
||||
ImGui::InsertNotification({ ImGuiToastType::Warning, 10000, "Falling back to FSR 2.1.2" });
|
||||
*feature = std::make_unique<FSR2FeatureDx12_212>(handleId, parameters);
|
||||
--
|
||||
2.55.0.windows.5
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
# Explicit Windows d4r backend
|
||||
|
||||
Base: OptiScaler `45a2001303ddff632e279f77aef85ceede5832cb` (2026-09-30).
|
||||
The modifications to OptiScaler are GPL-3.0, matching its upstream license.
|
||||
No NVIDIA DLL is supplied or patched.
|
||||
|
||||
`0001` introduces `[DLSS] AllowExternalBackend=true`, default false. Set
|
||||
`[Libraries] NvngxPath` to the absolute directory containing the Windows d4r
|
||||
shim as `_nvngx.dll`. Discovery requires its GPU-free ABI-1 marker. Physical
|
||||
adapter support is queried through the bridge's D3D12 requirements API after
|
||||
DLL startup; vendor, LUID and HIP architecture are retained.
|
||||
|
||||
The configured `D4R_NGX_CORE` absolute path bypasses game-facing NGX DLL
|
||||
redirection. The external backend loads its own NVAPI provider. An explicitly
|
||||
selected external DLSS backend reports initialization/load errors instead of
|
||||
silently switching to FSR. The patch fixes the upstream loader's filesystem
|
||||
exception by making IsSubpath a lexical check, and retains a PDB for diagnosis.
|
||||
|
||||
Build with Microsoft Build Tools 2022, v143 and Windows SDK 10.0.26100:
|
||||
|
||||
```powershell
|
||||
.\scripts\windows\build-optiscaler-windows.ps1
|
||||
```
|
||||
|
||||
The script clones the pinned source if absent, checks/applies the patch,
|
||||
initializes pinned submodules, invokes MSBuild and writes the DLL, PDB, license
|
||||
and build metadata into `dist/optiscaler-windows-d4r`. Existing source is not
|
||||
reset. The upstream packaging post-build event is disabled for this build.
|
||||
The official bootstrapper is https://aka.ms/vs/17/release/vs_buildtools.exe;
|
||||
install the `Microsoft.VisualStudio.Workload.VCTools`,
|
||||
`Microsoft.VisualStudio.Component.VC.Tools.x86.x64` and
|
||||
`Microsoft.VisualStudio.Component.Windows11SDK.26100` components. The audited
|
||||
local build uses MSVC 14.44.35207 / Build Tools 17.14.
|
||||
|
||||
For standalone verification add
|
||||
`-OptiScalerDll <absolute-dist-path>/OptiScaler.dll -CaptureExceptions`
|
||||
to the documented K/M runner. Its private INI selects DLSS, disables frame
|
||||
generation and keeps RestoreComputeSignature, RestoreGraphicSignature and
|
||||
ExtendedStateRestore false. Use `-RequireNativeNetwork`; finite output alone
|
||||
cannot distinguish DLSS from an unwanted FSR replacement.
|
||||
@@ -0,0 +1,75 @@
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[string]$SourceRoot,
|
||||
[string]$BuildToolsRoot,
|
||||
[string]$InstallRoot,
|
||||
[int]$Jobs = 6
|
||||
)
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$repo = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
|
||||
if (!$SourceRoot) { $SourceRoot = Join-Path $repo 'external/OptiScaler' }
|
||||
if (!$InstallRoot) { $InstallRoot = Join-Path $repo 'dist/optiscaler-windows-d4r' }
|
||||
$SourceRoot = [IO.Path]::GetFullPath($SourceRoot)
|
||||
$InstallRoot = [IO.Path]::GetFullPath($InstallRoot)
|
||||
$base = '45a2001303ddff632e279f77aef85ceede5832cb'
|
||||
$patch = Join-Path $repo 'patches/optiscaler/0001-windows-external-d4r-backend.patch'
|
||||
$previousPath = $env:PATH
|
||||
try {
|
||||
# Git for Windows' submodule helper needs its POSIX utility directory.
|
||||
$gitExe = (Get-Command git -ErrorAction Stop).Source
|
||||
$gitInstall = [IO.Path]::GetFullPath((Join-Path (Split-Path $gitExe) '..'))
|
||||
$gitUtilities = Join-Path $gitInstall 'usr/bin'
|
||||
if (Test-Path -LiteralPath $gitUtilities) { $env:PATH = "$gitUtilities;$env:PATH" }
|
||||
if (!(Test-Path -LiteralPath (Join-Path $SourceRoot '.git'))) {
|
||||
& git clone --filter=blob:none --no-checkout https://github.com/optiscaler/OptiScaler.git $SourceRoot
|
||||
if ($LASTEXITCODE) { throw 'OptiScaler clone failed.' }
|
||||
& git -C $SourceRoot checkout --detach $base
|
||||
if ($LASTEXITCODE) { throw 'Pinned OptiScaler checkout failed.' }
|
||||
}
|
||||
& git -C $SourceRoot merge-base --is-ancestor $base HEAD
|
||||
if ($LASTEXITCODE) { throw "OptiScaler must be based on audited commit $base" }
|
||||
$ErrorActionPreference = 'Continue'
|
||||
& git -C $SourceRoot apply --reverse --check $patch 2>$null
|
||||
$alreadyApplied = $LASTEXITCODE -eq 0
|
||||
$ErrorActionPreference = 'Stop'
|
||||
if (!$alreadyApplied) {
|
||||
& git -C $SourceRoot apply --check $patch
|
||||
if ($LASTEXITCODE) { throw 'External backend patch conflicts with the existing source; no files changed.' }
|
||||
& git -C $SourceRoot apply $patch
|
||||
if ($LASTEXITCODE) { throw 'External backend patch failed.' }
|
||||
}
|
||||
& git -C $SourceRoot submodule update --init --depth 1
|
||||
if ($LASTEXITCODE) { throw 'Pinned OptiScaler submodules failed.' }
|
||||
if (!$BuildToolsRoot -and (Test-Path -LiteralPath (Join-Path $repo '.tools/vs2022/MSBuild/Current/Bin/MSBuild.exe'))) {
|
||||
$BuildToolsRoot = Join-Path $repo '.tools/vs2022'
|
||||
}
|
||||
if (!$BuildToolsRoot) {
|
||||
$vswhere = Join-Path ${env:ProgramFiles(x86)} 'Microsoft Visual Studio/Installer/vswhere.exe'
|
||||
if (Test-Path -LiteralPath $vswhere) {
|
||||
$BuildToolsRoot = & $vswhere -latest -products '*' -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
|
||||
}
|
||||
}
|
||||
if (!$BuildToolsRoot) { throw 'MSVC v143 Build Tools and Windows SDK 10.0.26100 are required; see patches/optiscaler/README.md.' }
|
||||
$msbuild = Join-Path $BuildToolsRoot 'MSBuild/Current/Bin/MSBuild.exe'
|
||||
if (!(Test-Path -LiteralPath $msbuild)) { throw "MSBuild missing: $msbuild" }
|
||||
New-Item -ItemType Directory -Force $InstallRoot | Out-Null
|
||||
$log = Join-Path $InstallRoot 'build.log'
|
||||
$ErrorActionPreference = 'Continue'
|
||||
& $msbuild (Join-Path $SourceRoot 'OptiScaler.sln') "/m:$Jobs" /p:Configuration=Release /p:Platform=x64 `
|
||||
/p:PostBuildEventUseInBuild=false /verbosity:quiet "/flp:logfile=$log;verbosity=normal"
|
||||
$ErrorActionPreference = 'Stop'
|
||||
if ($LASTEXITCODE) { throw "OptiScaler build failed ($LASTEXITCODE); see $log" }
|
||||
foreach ($file in @('OptiScaler.dll', 'OptiScaler.pdb')) {
|
||||
Copy-Item -LiteralPath (Join-Path $SourceRoot "x64/Release/$file") -Destination $InstallRoot -Force
|
||||
}
|
||||
Copy-Item -LiteralPath (Join-Path $SourceRoot 'LICENSE') -Destination (Join-Path $InstallRoot 'GPL-3.0.txt') -Force
|
||||
Copy-Item -LiteralPath $patch -Destination $InstallRoot -Force
|
||||
$metadata = @{base=$base; sourceCommit=(& git -C $SourceRoot rev-parse HEAD).Trim();
|
||||
sourceDirty=[bool](& git -C $SourceRoot status --porcelain); backendAbi=1;
|
||||
buildTools=$BuildToolsRoot; msbuildVersion=(& $msbuild -version -nologo | Select-Object -Last 1);
|
||||
patchSha256=(Get-FileHash -LiteralPath $patch -Algorithm SHA256).Hash;
|
||||
dllSha256=(Get-FileHash -LiteralPath (Join-Path $InstallRoot 'OptiScaler.dll') -Algorithm SHA256).Hash;
|
||||
submodules=@(& git -C $SourceRoot submodule status)}
|
||||
$metadata | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath (Join-Path $InstallRoot 'build-info.json') -Encoding UTF8
|
||||
Write-Host "Built OptiScaler with external Windows d4r backend: $InstallRoot"
|
||||
} finally { $env:PATH = $previousPath }
|
||||
@@ -15,6 +15,7 @@ param(
|
||||
[switch]$Trace,
|
||||
[switch]$RequireNativeNetwork,
|
||||
[switch]$CommandListBackend,
|
||||
[switch]$CaptureExceptions,
|
||||
[ValidateSet('baseline','packed','unorm')][string]$PixelProfile = 'baseline',
|
||||
[ValidateSet('legacy','enhanced')][string]$BarrierMode = 'legacy',
|
||||
[int]$Iterations = 32,
|
||||
@@ -71,6 +72,11 @@ function Quote-Argument([string]$Value) {
|
||||
}
|
||||
function Invoke-Probe([string]$Name, [string]$Exe, [string[]]$Arguments) {
|
||||
if (!(Test-Path -LiteralPath $Exe)) { throw "Executable missing: $Exe" }
|
||||
if ($CaptureExceptions) {
|
||||
$Arguments = @('--output-directory', $OutputDirectory, '--', $Exe) + $Arguments
|
||||
$Exe = Join-Path $PackageRoot 'bin/d4r_debug_launcher.exe'
|
||||
if (!(Test-Path -LiteralPath $Exe)) { throw "Debugger launcher missing: $Exe" }
|
||||
}
|
||||
$stdout = Join-Path $OutputDirectory "$Name.stdout.log"
|
||||
$stderr = Join-Path $OutputDirectory "$Name.stderr.log"
|
||||
$argumentLine = ($Arguments | ForEach-Object { Quote-Argument $_ }) -join ' '
|
||||
|
||||
@@ -193,7 +193,16 @@ int main(int argc, char** argv) {
|
||||
for (const char* name : {"DLSS.Hint.Render.Preset.DLAA", "DLSS.Hint.Render.Preset.Quality", "DLSS.Hint.Render.Preset.Balanced",
|
||||
"DLSS.Hint.Render.Preset.Performance", "DLSS.Hint.Render.Preset.UltraPerformance", "DLSS.Hint.Render.Preset.UltraQuality"}) d4r_ngx_set_uint(parameters, name, args.preset);
|
||||
void* handle = nullptr;
|
||||
check(shim.symbol<Create>("NVSDK_NGX_D3D12_CreateFeature")(nullptr, 1, parameters, &handle), "D3D12 CreateFeature");
|
||||
// Public NGX and OptiScaler require an open creation command list.
|
||||
// Submit it independently from the pending synthetic input producer.
|
||||
ComPtr<ID3D12CommandAllocator> creationAllocator;
|
||||
ComPtr<ID3D12GraphicsCommandList> creationList;
|
||||
dx(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(creationAllocator.GetAddressOf())), "Create feature allocator");
|
||||
dx(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, creationAllocator.Get(), nullptr,
|
||||
IID_PPV_ARGS(creationList.GetAddressOf())), "Create feature command list");
|
||||
check(shim.symbol<Create>("NVSDK_NGX_D3D12_CreateFeature")(creationList.Get(), 1, parameters, &handle), "D3D12 CreateFeature");
|
||||
dx(creationList->Close(), "Close feature creation list");
|
||||
ID3D12CommandList* creationBatch[] = {creationList.Get()}; queue->ExecuteCommandLists(1, creationBatch); drain();
|
||||
auto release = shim.symbol<Release>("NVSDK_NGX_D3D12_ReleaseFeature");
|
||||
struct FeatureCleanup { Release fn; void* h; ~FeatureCleanup() { (void)fn(h); } } featureCleanup{release, handle};
|
||||
static const char* names[] = {"Color", "Depth", "MotionVectors", "Output", "ExposureTexture"};
|
||||
|
||||
@@ -0,0 +1,130 @@
|
||||
// Out-of-process crash capture: unaffected by the frontend's loader hooks.
|
||||
#include "diagnostic.h"
|
||||
#include <map>
|
||||
#include <fstream>
|
||||
|
||||
namespace {
|
||||
std::wstring quote(const std::wstring& value) {
|
||||
std::wstring result = L"\""; unsigned slashes = 0;
|
||||
for (wchar_t c : value) {
|
||||
if (c == L'\\') { ++slashes; continue; }
|
||||
result.append(slashes * (c == L'\"' ? 2 : 1), L'\\'); slashes = 0;
|
||||
if (c == L'\"') result += L'\\';
|
||||
result += c;
|
||||
}
|
||||
result.append(slashes * 2, L'\\'); return result + L'\"';
|
||||
}
|
||||
std::string file_path(HANDLE file) {
|
||||
wchar_t path[32768]{};
|
||||
const auto length = GetFinalPathNameByHandleW(file, path, 32768, FILE_NAME_NORMALIZED);
|
||||
return length && length < 32768 ? d4r::diag::utf8(path) : "unknown";
|
||||
}
|
||||
struct Module { std::string path; uint32_t size; };
|
||||
uint32_t module_size(HANDLE process, uintptr_t base) {
|
||||
IMAGE_DOS_HEADER dos{}; IMAGE_NT_HEADERS64 nt{}; SIZE_T read = 0;
|
||||
if (!ReadProcessMemory(process, reinterpret_cast<void*>(base), &dos, sizeof(dos), &read) ||
|
||||
dos.e_magic != IMAGE_DOS_SIGNATURE || dos.e_lfanew < 0 || dos.e_lfanew > 65536 ||
|
||||
!ReadProcessMemory(process, reinterpret_cast<void*>(base + dos.e_lfanew), &nt, sizeof(nt), &read) ||
|
||||
nt.Signature != IMAGE_NT_SIGNATURE) return 0;
|
||||
return nt.OptionalHeader.SizeOfImage;
|
||||
}
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
try {
|
||||
if (argc < 5 || std::strcmp(argv[1], "--output-directory") || std::strcmp(argv[3], "--"))
|
||||
throw std::runtime_error("Usage: d4r_debug_launcher --output-directory PATH -- EXE [arguments]");
|
||||
const std::filesystem::path directory(d4r::diag::wide(argv[2]));
|
||||
std::filesystem::create_directories(directory);
|
||||
std::ofstream log(directory / L"debugger.log", std::ios::app);
|
||||
const auto executable = d4r::diag::wide(argv[4]);
|
||||
std::wstring command;
|
||||
for (int i = 4; i < argc; ++i) { if (i > 4) command += L' '; command += quote(d4r::diag::wide(argv[i])); }
|
||||
STARTUPINFOW startup{sizeof(startup)}; PROCESS_INFORMATION child{};
|
||||
startup.dwFlags = STARTF_USESTDHANDLES;
|
||||
startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
|
||||
startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
startup.hStdError = GetStdHandle(STD_ERROR_HANDLE);
|
||||
HANDLE job = CreateJobObjectW(nullptr, nullptr);
|
||||
JOBOBJECT_EXTENDED_LIMIT_INFORMATION limits{};
|
||||
limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
|
||||
if (!job || !SetInformationJobObject(job, JobObjectExtendedLimitInformation, &limits, sizeof(limits)))
|
||||
throw std::runtime_error("Cannot create diagnostic process lifetime job");
|
||||
if (!CreateProcessW(executable.c_str(), command.data(), nullptr, nullptr, TRUE,
|
||||
DEBUG_ONLY_THIS_PROCESS | CREATE_NO_WINDOW, nullptr, nullptr, &startup, &child))
|
||||
throw std::runtime_error("CreateProcess debugger error=" + std::to_string(GetLastError()));
|
||||
if (!AssignProcessToJobObject(job, child.hProcess)) {
|
||||
TerminateProcess(child.hProcess, 1); CloseHandle(job);
|
||||
throw std::runtime_error("AssignProcessToJobObject debugger failed");
|
||||
}
|
||||
std::map<uintptr_t, Module> modules;
|
||||
bool initialBreakpoint = true, dumped = false; DWORD exitCode = 1;
|
||||
auto add_module = [&](void* base, HANDLE file) {
|
||||
const auto address = reinterpret_cast<uintptr_t>(base);
|
||||
modules[address] = {file_path(file), module_size(child.hProcess, address)};
|
||||
log << "LOAD base=0x" << std::hex << address << " size=0x" << modules[address].size << " path=" << modules[address].path << std::endl;
|
||||
if (file && file != INVALID_HANDLE_VALUE) CloseHandle(file);
|
||||
};
|
||||
auto address_info = [&](uintptr_t address) {
|
||||
auto it = modules.upper_bound(address);
|
||||
if (it != modules.begin()) {
|
||||
--it;
|
||||
if (address - it->first < it->second.size)
|
||||
log << " module=" << it->second.path << "+0x" << std::hex << address - it->first;
|
||||
}
|
||||
};
|
||||
DEBUG_EVENT event{};
|
||||
while (WaitForDebugEvent(&event, INFINITE)) {
|
||||
DWORD disposition = DBG_CONTINUE;
|
||||
if (event.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) {
|
||||
add_module(event.u.CreateProcessInfo.lpBaseOfImage, event.u.CreateProcessInfo.hFile);
|
||||
CloseHandle(event.u.CreateProcessInfo.hProcess); CloseHandle(event.u.CreateProcessInfo.hThread);
|
||||
} else if (event.dwDebugEventCode == CREATE_THREAD_DEBUG_EVENT) CloseHandle(event.u.CreateThread.hThread);
|
||||
else if (event.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) add_module(event.u.LoadDll.lpBaseOfDll, event.u.LoadDll.hFile);
|
||||
else if (event.dwDebugEventCode == UNLOAD_DLL_DEBUG_EVENT) {
|
||||
const auto base = reinterpret_cast<uintptr_t>(event.u.UnloadDll.lpBaseOfDll);
|
||||
log << "UNLOAD base=0x" << std::hex << base << std::endl; modules.erase(base);
|
||||
} else if (event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT) {
|
||||
const auto& exception = event.u.Exception;
|
||||
const DWORD code = exception.ExceptionRecord.ExceptionCode;
|
||||
log << "EXCEPTION code=0x" << std::hex << code << " firstChance=" << exception.dwFirstChance
|
||||
<< " address=0x" << reinterpret_cast<uintptr_t>(exception.ExceptionRecord.ExceptionAddress) << std::endl;
|
||||
disposition = DBG_EXCEPTION_NOT_HANDLED;
|
||||
if (initialBreakpoint && code == EXCEPTION_BREAKPOINT) { initialBreakpoint = false; disposition = DBG_CONTINUE; }
|
||||
if (!dumped && (!exception.dwFirstChance || code == EXCEPTION_ACCESS_VIOLATION || code == EXCEPTION_ILLEGAL_INSTRUCTION || code == EXCEPTION_STACK_OVERFLOW || code == EXCEPTION_IN_PAGE_ERROR)) {
|
||||
dumped = true;
|
||||
log << "FAULT code=0x" << std::hex << code << " address=0x" << reinterpret_cast<uintptr_t>(exception.ExceptionRecord.ExceptionAddress)
|
||||
<< " thread=" << std::dec << event.dwThreadId << " firstChance=" << exception.dwFirstChance;
|
||||
address_info(reinterpret_cast<uintptr_t>(exception.ExceptionRecord.ExceptionAddress)); log << std::endl;
|
||||
HANDLE thread = OpenThread(THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, event.dwThreadId);
|
||||
CONTEXT context{}; context.ContextFlags = CONTEXT_ALL;
|
||||
if (thread && GetThreadContext(thread, &context)) {
|
||||
log << "CONTEXT rip=0x" << std::hex << context.Rip << " rsp=0x" << context.Rsp << " rcx=0x" << context.Rcx << " rdx=0x" << context.Rdx << std::endl;
|
||||
EXCEPTION_RECORD record = exception.ExceptionRecord;
|
||||
EXCEPTION_POINTERS pointers{&record, &context};
|
||||
MINIDUMP_EXCEPTION_INFORMATION info{event.dwThreadId, &pointers, FALSE};
|
||||
const auto path = directory / (L"crash-" + std::to_wstring(child.dwProcessId) + L".dmp");
|
||||
HANDLE file = CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, 0, nullptr);
|
||||
if (file != INVALID_HANDLE_VALUE) {
|
||||
const BOOL ok = MiniDumpWriteDump(child.hProcess, child.dwProcessId, file,
|
||||
static_cast<MINIDUMP_TYPE>(MiniDumpNormal | MiniDumpWithThreadInfo), &info, nullptr, nullptr);
|
||||
log << "MINIDUMP success=" << ok << " error=" << (ok ? 0 : GetLastError()) << std::endl; CloseHandle(file);
|
||||
}
|
||||
uintptr_t stack[256]{}; SIZE_T read = 0;
|
||||
if (ReadProcessMemory(child.hProcess, reinterpret_cast<void*>(context.Rsp), stack, sizeof(stack), &read))
|
||||
for (unsigned i = 0; i < read / sizeof(uintptr_t); ++i) {
|
||||
log << "STACK slot=" << std::dec << i << " address=0x" << std::hex << stack[i]; address_info(stack[i]); log << '\n';
|
||||
}
|
||||
}
|
||||
if (thread) CloseHandle(thread); log.flush();
|
||||
}
|
||||
} else if (event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) {
|
||||
exitCode = event.u.ExitProcess.dwExitCode;
|
||||
log << "EXIT code=0x" << std::hex << exitCode << std::endl;
|
||||
ContinueDebugEvent(event.dwProcessId, event.dwThreadId, disposition); break;
|
||||
}
|
||||
ContinueDebugEvent(event.dwProcessId, event.dwThreadId, disposition);
|
||||
}
|
||||
CloseHandle(child.hThread); CloseHandle(child.hProcess); CloseHandle(job);
|
||||
return static_cast<int>(exitCode);
|
||||
} catch (const std::exception& error) { std::fprintf(stderr, "DEBUG_LAUNCH_FAILURE %s\n", error.what()); return 1; }
|
||||
}
|
||||
Reference in new issue
Block a user