CTHULHU CRASH LAB · MISSION 04

RX 9060 XT on Linux: Hardlocks, GEM Handles and PCI Access Loss

A new Radeon that initially worked beautifully on Linux. Then games where both monitors suddenly went black and the GPU fan shot to full speed. No useful final error message. I did not return the card. I wanted to understand why.

Original box of the PowerColor RX 9060 XT Hellhound Spectral White
Original photograph: The box from my RX 9060 XT Hellhound Spectral White, not a manufacturer stock photo. Documented in my Computer Museum.

Why I tried AMD at all

I have no particular allegiance to NVIDIA, AMD or Intel. A graphics card should run my software, perform well and, one small aesthetic requirement, preferably be white. But my RTX 3060 Ti sometimes caused trouble on self-configured Linux systems: Gentoo would be running well until a game, driver update or OBS problem started another round of troubleshooting.

I found an old ASUS Strix Radeon R9 380 for €20 on a local classifieds site. I installed another M.2 SSD, put the card in and freshly tried Arch, Debian and Gentoo. OBS, Steam, Lutris and WoW Classic all worked beautifully. Debian was sometimes the awkward one when I wanted newer drivers, but the basic compatibility test passed.

Then I loaded Baldur's Gate 3. The aging R9 380 simply did not have the performance. I had already seen the white PowerColor RX 9060 XT Hellhound Spectral White 16 GB online and liked it. When the next paycheck arrived, the €20 experiment became an actual GPU upgrade.

Preserved ASUS Strix Radeon R9 380 with original packaging
Original photograph: My €20 Radeon R9 380 and its box. This is not the newer RX 9060 XT.

At first it all worked

With the Hellhound I mostly played Baldur's Gate 3 and WoW Classic. Both were excellent. The RX 9060 XT was not a failure from day one. I discovered the serious issues later, when I wanted to see some eye candy and started S.T.A.L.K.E.R. 2 and other titles that I had previously neglected.

System and graphics updates had happened in the meantime. I cannot prove that those updates caused the crashes: I had not performed comparable tests in those games before. Sequence in time is not proof of causality.

Four games, different failure modes

GameEarlier Linux behavior
S.T.A.L.K.E.R. 2Standing, looking around, shooting or reloading could work; walking into the world caused 1–2 second stalls or hardlocks, black monitors and 100% GPU fan.
Arma 3Immediate hard blackout when entering the game world, before actual play could begin.
Assassin's Creed IV: Black Flag – ResyncedHard crash after two or eight minutes; measured temperatures looked normal. Not Assassin's Creed Origins.
Quake RTXBoth displays entered standby but audio and game controls continued. Switching toward a virtual terminal silenced the game; switching back restored its audio. LocalSend even received a file from my phone. Video output never returned.
WoW Classic / Baldur's Gate 3Both remained stable. High GPU load alone cannot fully describe the failure.

In particular, Quake RTX was not the same as a whole-system hardlock. A game accepting inputs and a computer receiving a network file demonstrate that important parts of the operating system were still functioning. Black displays alone do not identify whether the failure lies in display output, rendering, a driver, PCIe or the entire machine.

My additional observation on 23 October: The problems are not limited to S.T.A.L.K.E.R. 2; Arma 3 was particularly troublesome in my earlier tests too. My impression is that more demanding graphics workloads fail more often. Quake II and Duke Nukem ran without issues. This is my personal test history, not a measured performance threshold. I keep the Quake RTX display failure described above separate; a title appearing in my Steam library does not establish a test or its result.

Cthulhu, at least say OUCH before you die

The frustrating part was how often there was no useful AMDGPU error in the journal immediately before the worst crash. I saw a previous Arch message resembling amdgpu: device lost from bus, but mostly got black monitors, a roaring GPU fan and a forced restart. I was not even demanding an instant fix; I wanted the machine to shout “Ow, my leg!” before going down.

During a violent GPU/PCIe failure, the kernel may not get a chance to generate or persist a meaningful message. Missing logs are not evidence of a healthy driver stack. I watched live journal output and tried to isolate hardware factors too.

EXAMPLE · Observe Linux kernel messages (not an original historic log)
journalctl -kf -o short-monotonic
This command follows new kernel messages. A severe lockup can still happen without a useful final line.

Riser out, NIC out, games moved between drives

I tested the GPU with the PCIe riser and directly in the motherboard. I varied BIOS/PCIe settings, even removed the 10 GbE network card connected to my NAS, and tested the PSU's original PCIe cables instead of the white sleeved extensions. None of those changes eliminated the crashes.

At one stage the observed PCIe topology was: 00:03.1 Root Port → 53:00.0 Switch Upstream → 54:00.0 Switch Downstream → 55:00.0 GPU, with a reported 8 GT/s ×8 link. Worth investigating, yes; proof of root cause, no – especially because direct-slot tests failed too.

My power supply is from Corsair, but I cannot currently verify its exact model or capacity. I remember one 6+2-pin and one 6-pin PCIe power connection. That already ruled out GPU choices requiring two full 8-pin leads. Toggling the Hellhound's OC/Silent dual BIOS produced no useful change. I considered firmware flashing strictly as a last resort; I never did it.

A second suspect: SATA CRC errors

Alongside game stalls, the kernel reported BadCRC, READ FPDMA QUEUED and hard SATA link resets around ata2 and a Samsung 860 EVO. Those were real findings, but they need their own cable/port investigation.

To keep the problems apart, I relocated games from the SATA SSD to my system NVMe and also tried the other NVMe drive. The GPU hardlocks persisted at the time. That weakens the SATA SSD as a sole explanation. It does not mean the SATA link is healthy; cable and port tests are still on the to-do list.

The same S.T.A.L.K.E.R. route, a different OS

I kept a separate Windows 11 NVMe around, primarily for Battlefield. That gave me a useful control: same S.T.A.L.K.E.R. 2 save, Continue, spawn point and a lap around the base, with graphics broadly maxed out and the same RX 9060 XT. Under Windows that route completed without issue. Battlefield also ran as usual.

That is much more informative than comparing to an unrelated benchmark, but still not a mathematical proof against hardware. Windows and Linux exercise different graphics and driver paths, and every setting need not be identical. It made the Linux-specific execution path a stronger suspect.

112 watts: a hypothesis, not a miracle cure

I have capped WoW Classic at 60 FPS for years, even on a 144 Hz monitor. Why burn extra power for a game that already runs beautifully? Earlier Windows undervolting experiments had shown me substantial power savings. So I wondered: Could the PSU, power cable or a transient load be involved?

I cut the GPU power limit from 160 to 112 W. It prevented some hard crashes initially, but not reliably: the short stalls remained and not every full crash disappeared. Changing a power cap changes clocks and operating states as well. The result could not establish a broken power supply. At 112 W, Arma 3 still hard-crashed; Quake RTX lost display output while the game and LocalSend continued running. Black Flag Resynced still suffered intermittent blackouts after roughly 3–10 minutes of gameplay.

Beta kernels, Mesa versions – and finally 26.2.4

Deep in forum discussions I found other Linux/RDNA4 users with somewhat similar issues. That made a known or actively investigated software problem plausible. I tried a newer beta kernel; no improvement, sometimes worse. Other Mesa candidates were unsuccessful too. Two promising suggestions caused faster blackouts on my machine. I no longer know their exact version numbers and will not invent them.

My principle was to change one factor where possible and observe its result. Eventually I tried Mesa 26.2.4. This was the first version I tested where Arma 3 no longer crashed immediately on world entry and S.T.A.L.K.E.R. 2 was playable for longer periods at normal power. The kernel and firmware remained standard NixOS packages; I explicitly overrode Mesa in configuration.nix at that time, including its 32-bit component.

HISTORICAL NIXOS CONFIGURATION EXCERPT · 11 OCTOBER 2026
boot.kernelPackages = pkgs.linuxPackages_latest;
# Within hardware.graphics:
mesaVersion = "26.2.4";
# Both 64-bit and 32-bit Mesa are overridden
Intentionally abbreviated illustration, not a full copy-and-paste Nix expression. Cthulhu configuration archive. No persistent extra AMDGPU kernel tuning is shown in the provided configuration.

With that Mesa stack I raised the limit in controlled steps: 112 → 120 → 130 → 140 → 150 → 160 W, using S.T.A.L.K.E.R. as the test. The previous immediate failure did not return. This is evidence that changing the graphics software stack mattered in my tests. It does not identify a proven upstream fix commit.

Original October 2026 NixOS Fastfetch from Cthulhu
Original system record: NixOS 26.05 / Plasma 6 on Cthulhu. The screenshot documents the system, not the cause of the GPU bug.

CTHULHU CRASH LAB: compare the evidence

This is a static browser-side presentation of my notes. It does not probe your hardware, change settings or perform live diagnosis. Pick a case and compare its historical symptoms, the reduced-power experiment and my documented Mesa 26.2.4 setup from 11 October. The later Arch/RADV 26.2.5 captures follow below.

CRASH LAB / CASE STUDY

One variable at a time

160 WThen-tested power cap
26.2.4Mesa on 11 October
~10 h / 1Gaming / hard crashes
2 h stable at 160 W

“Not confirmed” means no reliable observation for that exact combination was recorded.

My observations after about ten hours

GameMesa 26.2.4, 160 W observations
S.T.A.L.K.E.R. 22 hours, no issues on my usual route
Arma 3About 1 hour; tested weapons on dummies and flew a helicopter
Quake RTXRetested with no display loss
War ThunderAbout 1 hour without issues
Watch Dogs 2About 1 hour without issues
Assassin's Creed IV: Black Flag – ResyncedOne hard crash after roughly 2 hours
WoW Classic / Baldur's Gate 3Still stable

The individual times above belong within an approximately estimated total playtime; do not add them as independent extra hours. Mesa 26.2.4 was my first tested version with this level of improvement. The underlying bug has not been conclusively identified or fixed.

21 October 2026 update: My GPU black box captures a real crash

After the earlier tests, I wanted evidence more useful than a black screen and a GPU fan at full speed. Cthulhu is now running Arch Linux with dwm again. To catch the next reproducible failure, I built a Cthulhu GPU Blackbox: a Bash utility with a separate systemd logger, once-per-second AMDGPU telemetry, a live kernel journal and a udev-triggered Linux devcoredump collector. It writes to a separately mounted NVMe, independently of X11 and the game window.

Test setup on 21 October 2026Recorded configuration / result
GPUPowerColor Radeon RX 9060 XT 16 GB, Navi 44 / RDNA4
SystemArch Linux; kernel 7.2.11-arch1-1
Graphics stackMesa / RADV 26.2.5; firmware package baseline recorded then: 20260916-1, not a complete identification of loaded blobs; Proton 11 (Steam selection)
Game / triggerS.T.A.L.K.E.R. 2, freeze around reloading a save; TTY2 remained accessible
Evidence423,438-byte AMDGPU devcoredump; its metadata says complete=yes

20:11:47 CEST: The kernel logged a [gfxhub] page fault at GPU address 0x000080000e000000. It identified process GameThread, thread vkd3d_queue, SQC (data), PERMISSION_FAULTS: 0x3, and status 0x00701431. Two seconds later it created an AMDGPU devcoredump and reported a gfx_0.0.0 ring timeout, followed by a successful ring reset. The game remained stuck, but TTY2 worked, so I could inspect the evidence and later reboot normally.

20:11:47  gfxhub page fault, SQC (data), PERMISSION_FAULTS: 0x3
20:11:49  AMDGPU device coredump file has been created
20:11:49  ring gfx_0.0.0 timeout
20:11:49  Ring gfx_0.0.0 reset succeeded

The black box had saved the dump automatically before I ran a manual capture. Its .info sidecar records complete=yes and bytes=423438: the file copy completed without a reported read error, not proof that every register has been decoded or that the underlying bug is understood. The readable dump contains the matching process, GPU context (PASID 79 / VMID 7), gfx_0.0.0 ring and fault address. The journal and dump therefore describe the same event.

The six seconds around the failure

Time (CEST)GPU busyVRAM usedTemperatureGPU power
20:11:4565%5.69 GiB57 °C24 W
20:11:461%5.61 GiB57 °C23 W
20:11:470%5.68 GiB56 °C24 W
20:11:4895%5.95 GiB57 °C46 W
20:11:49100%5.95 GiB57 °C48 W
20:11:509%5.95 GiB56 °C24 W

These are one-second snapshots, not a high-resolution electrical trace. They show no obvious thermal runaway or exhaustion of available VRAM. A 95–100% busy reading during recovery is not necessarily ordinary rendering load. My earlier black-screen/full-fan hardlocks are not automatically the same failure mode as this recoverable ring timeout.

An unusually close upstream report

A separate VKD3D-Proton report (#3221) on an RX 9070 XT documents the same distinctive combination: SQC (data), PERMISSION_FAULTS: 0x3, 0x00701431, vkd3d_queue and the gfx_0.0.0 timeout. A matching signature does not prove an identical root cause. The trigger could still be in the game, VKD3D-Proton, RADV/Mesa, AMDGPU or hardware. In particular, the other reporter's FSR observations are not evidence about FSR in my S.T.A.L.K.E.R. test.

Conclusion of the 21 October capture: I have not resolved the cause of this failure. I now have a reproducible, timestamped crash with the first AMDGPU coredump automatically preserved by my own tool. For debugging, that is genuine progress.

22 October 2026: From Low to Epic – and my first actionable Unreal crash report

The GPU black-box capture from the previous day made a much more focused hypothesis possible. The additional RADV hang report contained a command stream of 9,376 DWORDs (37,504 bytes) that matched the AMDGPU devcoredump's main command stream word for word. The last reached trace marker was 0x37 (decimal 55), followed by a compute dispatch of 287 × 121 × 1 groups. A descriptor read in the shader was reconstructed at 0xffff80000e000100, on the exact GPU virtual-memory page reported by the fault. RADV's memory history recorded an earlier allocation and release for that region, and the tool warned of a potential use-after-free.

This is evidence for a specific hypothesis, not proof of its cause. Without the D3D12 Release/fence sequence and the precise GPU execution point, I cannot establish who released the buffer or conclusively assign blame to the game, VKD3D-Proton, RADV or a lower layer. I therefore tested one narrow change: hide the optional Vulkan VK_EXT_descriptor_buffer extension from VKD3D-Proton while retaining the existing RADV diagnostic options.

MY S.T.A.L.K.E.R. 2 STEAM LAUNCH OPTIONS · TEST ONLY, NOT A UNIVERSAL FIX
VKD3D_DISABLE_EXTENSIONS=VK_EXT_descriptor_buffer RADV_DEBUG=hang,noumr %command%
VKD3D_DISABLE_EXTENSIONS hides the named extension and is intended to select the alternative descriptor-set path. RADV_DEBUG=hang,noumr was already used for diagnostics. No Mesa or kernel packages were changed for this test. The later Proton logs from 23 October explicitly confirm filtering at runtime. For the two earlier comparison sessions I document the configured option without claiming an additional retrospective runtime verification.

What I actually tested: graphics presets, repeated reloads, and the firmware baseline

RunFirmware / settingsObserved result
1 · Newer October test firmwareArch Linux, kernel 7.2.11, Mesa/RADV 26.2.5; separately tested newer AMDGPU firmware; descriptor buffers disabled.First about 30 minutes on the minimum preset: moving through different areas, entering a building, deliberately jumping off a tower three times and reloading the latest save each time. No previous loading stalls. Then I raised graphics one preset at a time, all the way to Epic, played roughly ten minutes at each level and repeated the death/reload sequence. No system hardlock during this observed test.
2 · Saved September UKIManually selected the saved September UKI, intended firmware package baseline 20260916-1. Its name alone does not establish the loaded blobs. Kept the same descriptor-buffer-disabling Steam launch options and Epic graphics; no additional driver change.Gameplay again worked at Epic at first. After a deliberate death and save reload, S.T.A.L.K.E.R. 2 exited to an Unreal crash reporter – but I did not observe the previous full-system hardlock or the GPU fan running at maximum speed.
3 · Historical comparisonEarlier Arch/September setup without the new VKD3D switch.Raising the graphics preset had previously caused immediate black displays and the GPU fan at full speed on some runs. These are earlier observations, not a deliberately repeated same-day A/B hardlock.

The two sessions were intended to compare firmware states, using different UKIs. I did not independently test every firmware/descriptor-path combination. The October test build with descriptor buffers re-enabled was not tested in this series. Boot state, caches, allocation and timing can also influence the outcome. A surviving session does not establish permanent stability.

What the UKI and firmware comparison now establishes

I subsequently compared the two saved UKIs without installing another package. The reported PE sections, including .linux and .cmdline, were byte-identical; .initrd differed. Extracted contents differed in AMDGPU firmware files and alias paths, as well as hwdb.bin. Both images returned the same five properties for this GPU's hwdb query. That verifies this particular GPU query, not equality of the entire hardware database.

Separately recorded runtime snapshots show ME/PFP/MEC/MES versions 0x0c12 / 0x0c76 / 0x0d7a / 0x93 for the September boot and 0x0c26 / 0x0c94 / 0x0da2 / 0x97 for my regular Arch boot on 23 October. These values are more precise than a UKI filename or package version. They still do not provide full hashes of every loaded blob or retrospectively establish the complete firmware set for the stable session in run 1. Matching component versions alone do not make the regular 23 October boot identical to my earlier unpublished October test build.

What I can establish from the new crash

For the first time in this particular return-to-baseline test I got a Stalker2 Crash Reporter instead of only black displays. The attached CrashContext.runtime-xml identifies CrashType=GPUCrash and GPU Crash dump Triggered; it reports SecondsSinceStart=1019, just under 17 minutes. The game's Stalker2.log records:

LogD3D12RHI: Error: GPU crash detected:
  Device 0 Removed: DXGI_ERROR_DEVICE_REMOVED
DRED: could not find DRED data
Local Budget: 15419.25 MB
Local Used:    7202.28 MB

This establishes a D3D12 device loss as seen by the game. The Linux desktop remained responsive, allowing me to preserve the log, crash context and Unreal minidump. However, the reporter does not by itself prove that the kernel successfully reset the GPU, or that this was the identical fault seen on 21 October. The subsequent kernel-journal excerpt contained no matching new AMDGPU page-fault/reset messages; absence of such messages does not rule out a graphics-stack problem.

The captured figures also do not suggest straightforward VRAM exhaustion: local use was approximately 7.2 GB out of a 15.4 GB budget, and the crash context did not flag an out-of-memory event. DRED data was unavailable. The Windows version printed by Unreal is the Proton compatibility environment – the host was still Arch Linux.

I also inspected UEMinidump.dmp statically. It contains CPU process state, thread/module information and an exception/reporting path. It did not identify a failing GPU instruction or reconstruct the original D3D12 Release/fence sequence. Without DRED, matching internal symbols and additional driver telemetry, those questions remain open. Unreal's “GPUCrash” label does not supply the missing evidence.

My assessment on 22 October: Selecting the alternative descriptor-set path markedly changed the observed behavior. With the newer firmware test build, even the previously problematic higher presets and reloads were temporarily stable. On the saved September UKI, the game still suffered a GPU-related failure, but this time produced useful diagnostics rather than the complete blackout previously observed. This is a promising workaround candidate and material for an upstream report, not a proven fix or a definitive assignment of root cause.

23 October 2026: I trace where the submission fails

I could play normally, but dying and reloading still brought up the Stalker2 crash reporter. This time I wanted to find out what happened before DXGI_ERROR_DEVICE_REMOVED. I kept the graphics stack and disabled descriptor-buffer path unchanged and initially added only Proton logging:

MY LAUNCH OPTIONS FOR THIS CAPTURE
PROTON_LOG=1 VKD3D_DISABLE_EXTENSIONS=VK_EXT_descriptor_buffer RADV_DEBUG=hang,noumr %command%
The new log confirms Proton proton-11.0-2e-x86_64, VKD3D-Proton 212991fc2c266bc, RADV 26.2.5 and the disabled extension at runtime. The 464 repeated extension checks are not 464 crashes.

The first Proton capture already contained CS rejected (-2). To distinguish its possible origins, I then used my Python script cthulhu-cs-watch.py. Without installing additional packages, I set up three temporary kernel return probes: buffer-list creation, syncobj/fence lookup and the outer command-submission call. I recorded only returns of -2. On Linux that is ENOENT; its specific meaning depends on the function being observed.

I first ran the read-only prerequisite check, then armed the capture with --arm. The script stayed running in an open terminal while I played. After ordinary gameplay I repeated the known death/reload sequence once. The game exited again. I stopped the capture with Ctrl+C and preserved the accompanying Proton log.

MY KERNEL CAPTURE · MONO TRACE CLOCK · EXCERPT
vkd3d_queue-578000 [009] 18740.289707: amdgpu_bo_list_create ret=-2
vkd3d_queue-578000 [009] 18740.289708: amdgpu_cs_ioctl ret=-2
Probe groups and return addresses are abbreviated for readability. Both entries belong to the same native thread; task metadata records process 577862 and thread 578000.
ProbeHits, system-wideMissed callsRecorded ENOENT returns
amdgpu_bo_list_create2,849,85901
drm_syncobj_find_fence1,039,61800
amdgpu_cs_ioctl2,849,86401

Every CPU buffer also reported zero overruns, commit overruns and dropped events. The two error events were read on CPU 9. Cleanup reported no errors. The hit counts cover the entire system during the capture; they do not mean that the game alone issued several million submissions.

What I have actually established

In the inspected Linux 7.2.11 source, -ENOENT from amdgpu_bo_list_create identifies a failed drm_gem_object_lookup: at least one supplied buffer handle could not be resolved in the corresponding DRM file context. That submission was rejected while its buffer list was being constructed. This does not establish that earlier, already submitted GPU work was fault-free. The separately observed fence lookup did not return ENOENT in this capture.

The accompanying new Proton log contains exactly one CS rejected (-2) message. It is followed by Vulkan errors vr -4 and VK_ERROR_DEVICE_LOST; Unreal records D3D12 device removal at 11:35:01 CEST (09:35:01.271 UTC). The inspected RADV source explains how a rejected submission can subsequently be reported as device loss. This does not establish a kernel GPU reset. The raw Wine prefix 18740.037 and tracefs timestamp 18740.289707 cannot be subtracted directly without a common calibration; I infer no microsecond interval across those layers.

The new log reports 7,109.09 MB local memory use against a 15,189.84 MB budget and again no DRED data. It also contains 26 FSR-retention diagnostics, approximately 1,006.7 seconds before device loss on the Wine timeline. The final new FSR SetName/retention activations occur about seven milliseconds before the first submit error. Those are leads worth investigating. They neither associate the missing handle with a specific FSR resource nor establish an executed GPU access to freed memory.

After this initial capture, I still did not know: Which handle failed? Had it been closed, was an incorrect value supplied, or was there another bookkeeping error? Which D3D12 resource does it represent, and where are its Release and GPU-completion events? This first capture did not answer those questions; the following captures narrow them further. Descriptor lifetime remains the leading hypothesis for the old GPUVM fault; a connection to this newer submission rejected before GPU execution remains unproven. I also have not established an immediate hardlock after removing the extension filter in a controlled comparison.

Firmware, other games and my next lead at that stage

For this capture I identify my system as regular Arch on 23 October. The recorded runtime firmware reports ME/PFP/MEC/MES 0x0c26 / 0x0c94 / 0x0da2 / 0x97. I keep this separate from my earlier unpublished October firmware experiment and the saved September UKI. Matching component version numbers do not establish identical blobs or provenance. The two saved UKIs had identical kernel and command-line sections, but their initramfs contents also differed in a hwdb file. The GPU-specific hwdb queries returned identical properties. Firmware has not been isolated as the cause.

My next target was the missing GEM handle and any preceding close in the same DRM context. An Arma comparison would be a separate case with a verified rendering path; I am not scheduling another launch test for it now. This result narrows the failure location; it is not a repair announcement.

Later on 23 October: The missing handle had already been closed successfully

Over the course of the day, an error code became a concrete lifetime trail. I extended my capture step by step: first to GEM handle creation and closure, then to call stacks, and finally to targeted probes in Wine Vulkan. I retained the kernel, Mesa, Proton and launch options shown above. Instrumentation itself can affect timing, so these are captured cases rather than a controlled statistical test series.

My actual workflow: I always start the collector before the game because S.T.A.L.K.E.R. runs fullscreen. Each launch then requires roughly 10–15 minutes of shader compilation. In these captures I reached gameplay, and the familiar death/reload sequence ended at the crash reporter again. A later suggestion to activate capture only after reaching the main menu did not suit this workflow and was not performed as a separate control.

Four complete captures, four closed handles

With cthulhu-gem-watch.py, I recorded seven kernel probe points. Besides failed lookups, I captured successful handle creation, entry and return of handle deletion, and DRM file-context release. The crucial identity is the handle number within the same DRM file context: a number is not globally unique, and it can be reused even within one context. A successful close removes that identifier; it does not establish the end of every object/GPU reference or destruction of all backing GPU memory.

My captureMissing handleLatest successful close to NULL lookupAdditional attribution
GEM Watch v175583.643 msTwo recorded generations; allocation class unknown
GEM Stack Watch v262335.227 msLatest generation: RADV descriptor-pool BO; Wine call vkDestroyDescriptorPool
Pool Caller Watch v3, first run33175.517 msSix generations; both additional PE probes had zero hits
Pool Caller Watch v3, further run34985.806 msTwo generations; both additional PE probes again had zero hits

In all four complete captures, no successful reassignment of that number in the relevant context appears between its latest successful close and failed lookup. Each BO list had 21 entries; list construction and the outer submission ioctl returned -ENOENT. The recorded kernel probes reported zero misses and the buffers zero losses. These are the captures' reported coverage figures, not a guarantee against every possible instrumentation gap.

LATEST RUN · STRUCTURED SUMMARY OF MONO TIMESTAMPS
37551.368062  RenderThread: handle 3498 created successfully
37551.402929  RHIThread:    handle 3498 closed successfully
37551.408735  vkd3d_queue:  lookup of handle 3498 returns NULL
37551.408736  BO list:      21 entries, ret=-2
37551.408736  CS ioctl:     ret=-2
This is a readable summary, not an unchanged raw log. Intervals use only the kernel clock. I do not subtract Wine timestamp prefixes from this timeline without shared calibration.

The latest close of handle 3498 therefore completed 5.806 milliseconds before its failed lookup. The complete file contained 44,300 parsed kernel records, matching final counters and read-event totals. The accompanying fifth Proton log again confirms the disabled descriptor-buffer path, VKD3D 212991fc2c266bc and RADV 26.2.5. Exactly one CS rejected (-2) precedes the device-loss cascade. Unreal reports removal at 16:48:37.385 CEST (14:48:37.385 UTC). I count subsequent submission and wait errors as consequences, not independent GPU crashes.

What the handle-6233 stack actually establishes

The stack variant captured native return addresses during handle 6233's closure. I obtained RADV and Wine Vulkan GNU build IDs and checked matching symbols or the supplied library itself. The RADV stack reaches radv_destroy_descriptor_pool and release of its buffer object. In the matching winevulkan.so, the recorded frame is in thunk64_vkDestroyDescriptorPool, immediately after its host-driver call. This establishes pool destruction for that latest recorded generation.

The crucial limit: handle 6233 had previously represented other objects, including a command buffer and an upload buffer. I still do not know which generation the rejected BO list intended to reference. The latest pool closure alone therefore does not prove premature D3D12 heap release or the complete Release/fence sequence. My bounded stack capture also ends before a higher VKD3D caller. I do not assign the other three handles to descriptor pools based on this one stack.

Registration does not establish capture coverage

For the next step I prepared Pool Caller Watch v3, with seven kernel probes and two extra uprobes in the Windows Wine Vulkan wrapper. I checked exact file hashes and machine instructions; the disabled probes registered successfully on Cthulhu and were removed cleanly. Nevertheless, both later captures had zero hits at both PE probes. Kernel events were present, but a higher pool caller was not captured. Zero hits do not establish that the game never destroyed a pool.

Source inspection offers a testable lead: Wine initially maps PE code writable before applying final protections, while Linux excludes writable mappings during certain uprobe installation paths. I did not capture that actual sequence. Later protection changes also involve VMA-management details. This is a possible explanation for the instrumentation gap, not a proven Wine or kernel cause.

The mapping data also showed d3d12core.dll on a new inode between preflight and gameplay. During the next preflight, the previous replacement inode had the same file hash. An inode replacement is therefore not automatically a build change. V3 did not hash the currently mapped replacement's bytes at failure time, which remains an identity limit for these captures.

The native wrapper I instrumented next

The supplied Windows and ELF libraries now allowed a separate variant: cthulhu-native-pool-watch.py, v4. Its two uprobes target native winevulkan.so, at entry to the known wrapper and immediately after its host call. The argument pointer and two bounded return-address slots are derived from the exact machine code. A candidate becomes an immediate API-caller attribution only after matching mappings, module identities and a complete entry/exit span have been verified.

This preserves my workflow: start the collector before the fullscreen game, then wait for shaders. The default 30-minute total duration includes that wait. V4 also records fresh hashes for known mapped module files only when their device and inode still match on reopening. Such file hashes still do not hash private runtime pages.

From preparation to the validated control: v4 has passed 26 local simulation tests. At preparation time no real registration or active capture had been obtained. The subsequent normal-exit control has now confirmed registration and native hits; I document its limits in the next section.

How I interpret the day's results

For these reload failures, a CPU-side lifetime, reference or synchronization problem around the submitted BO list now leads: an already closed handle number is looked up again. Which component retained it too long or entered it incorrectly remains open. This is enough for a technically bounded upstream report, but does not establish VKD3D or RADV as the culprit. Newer resource-lifetime and retention work, such as VKD3D-Proton PR #3074, is relevant comparison material; I have not identified a confirmed fix for my captures.

For the older 21 October GPUVM fault, descriptor lifetime or stale binding state remains the leading hypothesis. The newer failure occurs even with VK_EXT_descriptor_buffer disabled and rejects the affected submission before it executes. That is compatible with a broader bookkeeping problem but does not automatically connect the incidents. The alternative binding path still needs descriptor storage.

The latest Unreal log records 7,256.52 MB local usage against a 15,169.93 MB budget, again without DRED. Its 26 early FSR retention diagnostics occur about 1,022 seconds before first submission failure; a fresh SetName batch ends eleven milliseconds before it. None identifies handle 3498. This log pair establishes neither a new GPUVM fault nor a kernel reset. My separate Unreal minidump mainly captures the reported device loss and reporter path, not an identified failing GPU instruction.

The original descriptor-buffer comparison consequently strengthens a path-dependent lifetime lead without proving a fault confined to that extension. Firmware comparisons also remain bounded: matching UKI kernel and command-line sections, differing initramfs contents and observed component versions are more precise than a filename, but do not isolate a firmware fix. My Arma 3 difficulties remain a separate observation. Lighter games working provides context, not a diagnosis that every failure has one cause.

23 October, 18:00 local time: The normal-exit control delivers native hits

Historical status on 23 October: This section records the completed normal-exit control. The actual failure captures from the following day are documented below.

I first checked v4 with disabled probes: all three module hashes matched, and seven kernel probes plus two native uprobes registered and were removed cleanly. I then started the collector before the fullscreen game as usual, waited for shaders and quit the game normally. I did not separately measure gameplay duration. I did not trigger a death/reload failure for this control. The capture lasted about 22 minutes 30 seconds, from 17:40 to 18:02 CEST.

Validated part of the captureResult
Native entries/exits90 entries, 90 exits; all 90 pairs independently checked using thread, arguments and stack delta
Handle closes inside complete pool calls36, each with a successful close return inside its call
Immediate API-caller addressAll 90 return addresses resolve to d3d12core.dll + 0x386ce4
ABI cross-checkAll verification slots resolve to the expected Wine wrapper at file offset 0x12a7a
Recorded lookup/BO/CS errorsNo NULL lookup or filtered BO/CS ENOENT in this run
Coverage and cleanupZero reported kernel-probe misses or buffer losses; no incomplete pool pairs or cleanup errors

The 90 calls come from four threads of one game process and span the control, including initialization and shutdown. The 79,229 raw records match buffer read-event totals; that larger figure includes system-wide kernel events from other programs too. The complete early mapping snapshot and matching file hashes now also confirm the observed replacement inode of d3d12core.dll: the same known file content. Some later process queries were unavailable when read because the process had already exited. This limits late metadata and does not establish buffer loss.

In the matching DLL, an indirect call at RVA 0x386cde immediately precedes the captured return address; the PE unwind table places it within 0x386c80–0x386d4c. The surrounding buffer/device-memory teardown matches d3d12_descriptor_heap_cleanup in the pinned source. This is a reasoned code/source attribution, not recovery of a missing debug-symbol name.

What this control establishes: I can capture native pool destruction and its immediate callsite with this workflow. The earlier PE probes did not deliver that coverage, and their zero hits are not retrospectively explained by this result. A successful control still does not identify which caller causes incorrect lifetime during reload, which handle generation the rejected list intended, or the Release/GPU-completion sequence. A valid v4 capture of an actual reload failure is still missing for that attribution. This is not a reason for another daily test series; my closing status follows below. The older GPUVM fault remains separate.

24 October: From a closed handle to the D3D12 heap-release caller

The normal-exit control on 23 October established that my native probes worked. On 24 October I captured actual failures with them. One launch failed immediately; a subsequent launch reached normal gameplay and failed after death and reload. The recorded Steam manifest still identifies game build 25382007, last updated on 21 October. My initial impression that a new game update had caused the startup failure is therefore unproven.

24 October captureMissing handle / BO-list sizeLast successful close → failed lookup
Native Pool Watch v4, startup failure299 / 20 entries3.377 ms
Native Pool Watch v4, death/reload8842 / 21 entries6.923 ms
Heap Release Watch v5, death/reload3229 / 21 entries6.887 ms

I extended the collector as Heap Release Watch v5. It keeps the seven kernel probes and two native Wine uprobes, adding bounded caller and heap candidates for the exact checked binaries. Registration succeeded. The completed failure capture contains 39 independently checked native call pairs; all additional slots were readable and consistent. Thirty-five calls form seven repetitions of the same five release sites. Kernel-probe statistics report no missed instances, the buffers report no lost events, and cleanup succeeded. Those counters do not provide a separate missed-instance count for the ordinary uprobes.

5779.728201  descriptor-pool destruction entered
5779.728427  GEM handle 3229 close entered
5779.728463  close returned 0
5779.728466  descriptor-pool destruction returned
5779.735350  same DRM file: lookup of handle 3229 returned NULL
5779.735352  BO-list creation and CS ioctl returned -ENOENT

These are monotonic trace times, not wall-clock times. The latest recorded generation of handle 3229 was closed within the observed descriptor-pool destruction. The native return chain reaches d3d12core.dll+0x386ce4, then +0x386afa, with a higher return at amd_fidelityfx_upscaler_dx12.dll+0x3bea. The supplied upscaler DLL matches AMD's official SDK 2.0.0 binary byte for byte. Comparing its machine code and the corresponding AMD backend source identifies the descRingBuffer->Release() call in DestroyBackendContextDX12. This is source/binary attribution, not recovered PDB symbols; v5 did not capture the upscaler's runtime inode/hash.

This identifies a release caller, not the component at fault. The relevant command-use and fence chronology is still missing. A caller may already have waited before entering that destructor. I also cannot prove which reused handle generation the rejected list intended. The game log records one CS rejected (-2), followed by device-loss warnings and Unreal's removal report. That submission failed while the CPU built its BO list; it never became GPU execution. The recorded local usage was 7,285.90 MB against a 15,331.73 MB budget, with no DRED data.

My saved settings selected TSR, with both frame-generation options off. A stored FSR4SwapchainProvider preference and the presence of this DLL do not prove active FSR4 rendering. The accompanying Unreal minidump describes the CPU crash-report path; it does not recover a failing GPU instruction. I preserve the complete capture identities, exact callsite offsets and limits in the derived evidence summary.

Validation adds evidence, and a failure inside the diagnostic layer

For one explicitly instrumented run I installed vulkan-validation-layers 1.4.363.0-1 and used the following Steam launch options. I record the full combination because it changes the experiment; it is not a proposed fix.

VKD3D_CONFIG=vk_debug VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation VKD3D_DISABLE_EXTENSIONS=VK_EXT_descriptor_buffer RADV_DEBUG=hang,noumr PROTON_LOG=1 %command%

The log confirms that the validation layer was active and descriptor buffers were disabled. Two activation messages belong to the same game process, not two independent tests. Gameplay worked, and the first death/reload succeeded. The second reload hung for minutes, after which I rebooted. This changed timing and behavior is not a stability result.

The preserved 26.6 MB log contains 368 VUID message headers covering 44 distinct VUIDs, plus 35 duplicate-suppression notices. These are not 368 proven independent game bugs. Messages include destroyed or pending buffers/image views, mutable-descriptor lists and texel-view ranges; the first lifetime messages appear shortly after startup, so I cannot label all of them reload errors. Bindless/partially-bound descriptors also complicate validation. GPU-assisted validation was not requested. This log contains no captured CS rejected, VK_ERROR_DEVICE_LOST or DXGI_ERROR_DEVICE_REMOVED.

There is a separate concrete finding: CPU access violations occur inside libVkLayer_khronos_validation.so. Matching build ID c4e432ae72694deb6e654d4af686c350a1064682, debug symbols and the actual Arch build source resolve the reporting path through CoreChecks::ReportInvalidCommandBuffer, LogObjectList::add and string_VulkanObjectType. Four bad-read addresses match an invalid signed object-type index into the diagnostic name table. That pinpoints those immediate CPU reads. It does not explain how that state became invalid, prove a validation-layer race/use-after-free, or establish the cause of the entire visible hang. I keep this instrumented failure separate from the original GPUVM fault and the host-side ENOENT sequence.

A real storage error that still needs its own explanation

A separate journal excerpt contains SATA ICRC/BadCRC transport errors, two link resets and four failed reads on ata2. Those errors are real. I had already tried S.T.A.L.K.E.R. 2 on the main M.2 and another M.2 without changing the problem. Moving the game again would not settle the GPU case. The SATA evidence alone identifies neither a failed SSD nor the cause of every graphics failure.

Arma 3: The hardlock also occurs with DXVK's legacy binding model

I then tested Arma 3 to check whether the problem was confined to the S.T.A.L.K.E.R./D3D12 path. The actual game uses D3D11 through DXVK, not VKD3D-Proton: both logs identify Arma3_x64.exe, feature level 11_0, DXVK v2.7.1-498-ga6764047e587178, RADV 26.2.5 and the same kernel/Proton versions. Launcher graphics initializations and imported VKD3D DLLs do not change the game's recorded renderer.

RunSteam launch optionsConfirmed game binding modelObserved outcome
APROTON_LOG=1 %command%Descriptor buffer; feature enabledBrief campaign gameplay, then black screens and full fan; forced reboot
BDXVK_CONFIG="dxvk.enableDescriptorBuffer = False" PROTON_LOG=1 %command%Legacy; descriptor-buffer feature disabledHardlock already in the menu; forced reboot

I checked the effective option and binding-model messages in the game process, not just the launch string. The configuration for this DXVK build and its binding-model logging support that interpretation. Descriptor buffers are therefore not necessary for this Arma hardlock. The VKD3D-only extension filter would not have been the corresponding DXVK control.

This rules out a descriptor-buffer-only explanation for all my failures. It does not invalidate the older Stalker descriptor-lifetime evidence or prove that Arma and Stalker share a cause. Neither Arma Proton log preserves the Stalker CS rejected (-2) sequence, a useful final device-loss diagnosis or an out-of-memory report. The decisive additional evidence came from the black box.

The black box saved it: PCI access fails before the first reset

My enabled cthulhu-gpu-blackbox.service had continued writing to the separate NVMe. The archived sessions connect both Arma runs to kernel messages, one-second telemetry and two complete devcoredump copies. Sparse persistent-journal output had not been the whole record. The published Blackbox source documents journal following, telemetry, dump collection and periodic data syncing. It improves the chance of preserving evidence through a forced reboot; it cannot guarantee the final sample survives.

24 October, CESTArma A: descriptor buffersArma B: legacy
Last readable telemetry17:17:55.38317:34:58.414
GPU edge / junction / memory58 / 72 / 68 °C55 / 70 / 62 °C
VRAM / reported GPU power3.35 GiB / 135 W2.93 GiB / 148 W
First device lost from bus!17:17:56.40435317:34:59.469720
First gfx_0.0.0 timeout17:17:57.43002117:35:00.733312
First ring-reset attempt17:17:57.43048517:35:00.733750
Recovery result in preserved fileGPU Recovery Failed: -19No completed recovery outcome preserved

The important order is established inside each kernel log: the first bus-access failure precedes the first ring-reset attempt by approximately 1.03 and 1.26 seconds. It is therefore not merely a message first produced by that reset. Both sessions also report SMU 0xffffffff responses and failed MES/ring recovery. In the second run the GPU's audio function had already reported an inaccessible D3hot-to-D0 transition shortly before the GPU message. That is another affected function, not proof that an audio wakeup caused the incident.

The source makes this more precise than generic Vulkan device loss. In Linux 7.2.11's amdgpu_device_bus_status_check, device lost from bus! follows a failed PCI configuration read or an all-ones error result. The raw PCI command word was not saved, so I cannot distinguish those two cases. The telemetry's simultaneous Unknown / x63 link reading is invalid access data, not a real 63-lane connection. Later NA readings mean unavailable, not zero temperature or zero power.

The two new dumps are 320,435 and 379,308 bytes; the accompanying two sidecars are metadata, not two extra crashes. Both identify rvMain/dxvk-submit. All 879 listed register values and both captured IB readbacks in each dump are 0xffffffff, while host-side ring copies still contain structure. This is consistent with failed device readback. A printed Page fault observed block containing address/status zero is not evidence of a real NULL-address GPUVM fault: the kernel dump formatter prints cached fault fields unconditionally. These files do not reproduce the 21 October fault address and status.

The last valid temperatures and VRAM figures show no obvious overheating or capacity exhaustion. One-second sensors cannot exclude brief electrical transients. A 184 W sample in the first session was about a minute before failure; it does not demonstrate a power spike at the failure or a faulty PSU. The fan runaway alone is not a root-cause diagnosis either.

Firmware and the PCI snapshot: what I actually verified

Both Arma dumps contain the same older firmware version fields: ME 0xc12, PFP 0xc76, MEC 0xd7a, ASD 0x21000118, MES 0x93, VCN 0x0910c01a and DMCUB 0x0a004b00. This is the older set, not the newer October ME/PFP/MEC/MES values recorded in the three Stalker v4/v5 captures above. Comparing those games is therefore not a firmware-only A/B test. These driver-reported fields do not hash every loaded blob or prove a UKI filename. My completed comparison established identical kernel and embedded command-line payloads. The reported initramfs tree comparison found 84 differing path entries: 81 compressed AMDGPU firmware files, two entries for a firmware alias moved between archives with a file/link change, and usr/lib/udev/hwdb.bin. No other differences in the checked file contents, link targets, types, permissions or UID/GID were reported; timestamps and complete PE headers were outside that comparison. Both hwdb copies return identical properties for this GPU. The compressed-file hashes do not by themselves identify every uncompressed blob or its runtime use.

A read-only PCI snapshot after reboot shows ASPM disabled on all five functions in the recorded path. The root-facing link reads 16 GT/s ×16, consistent with the root port's advertised maximum; the downstream GPU link reads 32 GT/s ×16. Calling the first link “downgraded” does not establish a fault. The GPU is D0 and its audio function is D3; supported idle D3 is not itself a defect. Correctable/unsupported-request status bits have no recorded event time, and no fatal AER sequence was preserved. This later snapshot does not recover crash-time registers or exclude runtime power management and firmware transitions. I have no evidence-based reason to claim that blindly disabling ASPM would fix this case.

My Windows counter-observation: the games run under Windows 11 in my experience. I have not supplied a new, matched Windows trace for these two Arma incidents. That makes the Linux software/firmware interaction important to investigate, but it does not logically exclude every hardware, link or power problem; the workloads and power transitions can differ. Similarly, reports from other users establish that a symptom is not unique, not that every affected machine has one proven cause.

Like working on my TS 250 X: change a jet, then test

My troubleshooting rule is the same as when I work on my motorcycle. Just last week I was working on my TS 250 X. If I change the main jet, air filter and needle position at the same time, I can no longer tell which change had which effect. So I change one thing and test it.

I used the same principle for the riser, PCIe, storage, power cables, kernels and Mesa. No, I never seriously wanted to return the Hellhound. I had my own NVIDIA problems, and switching brands does not answer the question.

This principle helps me interpret the results. My closing status distinguishes established failure sequences, working hypotheses and the questions still open.

My status on 24 October: Several established failure sequences, no confirmed fix

I can now explain substantially more than “the game crashed.” I cannot honestly turn that into one proven culprit. My evidence contains five distinct observations, with different levels of causal attribution:

Failure classEstablishedLeading explanation / limit
21 October: Stalker GPUVM faultMatching command stream, reconstructed descriptor read, allocation history, successful ring resetDescriptor lifetime or stale binding state remains the leading hypothesis for this incident; original Release/fence and exact execution point are missing
23–24 October: Stalker host submission rejectionClosed handle, later NULL lookup in the same DRM file, BO/CS ENOENT; v5 associates the latest generation with an identified heap-release callerHost-side lifetime/reference or stale BO-list state leads; responsibility between application/middleware, VKD3D-Proton and RADV is unresolved
24 October: Arma PCI access failureBoth DXVK binding models fail; PCI access fails before reset; first recovery fails with ENODEVDriver/firmware/power-state interaction and platform/link/card/power causes remain open; none is individually proven
Validation-instrumented Stalker runCPU bad reads in the validation reporting path; one successful reload, then a hangImmediate diagnostic failure localized; origin of invalid state and relationship to the hang unknown
SATA transport errorsICRC/BadCRC, resets and failed readsA separate real error; neither a failed SSD nor a general explanation of GPU crashes established

A descriptor-buffer use-after-free is no longer a defensible single explanation for everything. The original descriptor-lifetime suspicion remains important for the older fault. Disabling the extension changed the observed Stalker behavior and later logs confirm it was disabled. That switch also changes allocation, binding and timing, so it cannot by itself distinguish a defect specific to that extension from a broader lifetime/synchronization problem. Arma's confirmed legacy-path hardlock demonstrates the limit of treating the switch as a universal fix.

I have not identified a matching upstream fix. Similar signatures in issues and existing lifetime work are leads, not fixes proven against my files. The evidence supports precise developer reports with the Stalker handle sequence and Arma PCI sequence kept separate. No new upstream report has been published as part of this investigation.

I start each collector before the fullscreen game and then spend roughly 10–15 minutes waiting for shaders. I am pausing repeated game starts without a specific question. The saved UKI/initrd comparison is already complete within its recorded scope; it narrows the reported differences to firmware files/the alias and hwdb. Runtime blob use, historical external boot additions and game/cache/timing differences remain open. I will use that completed evidence, together with the exact platform BIOS and driver/firmware versions, to choose any further targeted check. Both saved boot images remain available.

Correction, 24 October: An earlier version of this update incorrectly described the completed initramfs comparison as still pending. I have corrected the comparison status and withdrawn the recommendation to repeat it. This does not establish a firmware fix or change the recorded failure sequences.

My result today is a more precise failure boundary and a reproducible record, with no confirmed permanent fix. The original scripts, failed probe attempts, successful coverage checks, hashes and limits all belong in that record.

CTHULHU CRASH LAB · 25 OCTOBER 2026 UPDATE

Seven graphics paths, one Radeon: My controlled GravityMark comparison

After the black screens, GPUVM faults, and PCI access failures, I did not want to launch another game and wait for the next crash. I wanted to run the same scene across different graphics APIs. I chose Tellusim GravityMark 1.89: 200,000 asteroids, identical resolution, one bounded pass, and several renderers in one application. Katharina thought the asteroids were pretty cool, by the way. Fair enough.

My machine was running Arch Linux, kernel 7.2.11-arch1-1, Mesa 26.2.5, and the Radeon RX 9060 XT (Navi44/GFX1200). For the Windows tests I used Proton 11.0-2e from my game library on /mnt/Games.Vol2, with a separate prefix at ~/.local/share/cthulhu-gravitymark-proton11. My existing game prefixes were left alone.

Graphics paths7 / 7completed normally
Per pass167 s1920 × 1080, Temporal AA
Scene200,000asteroids

My workflow: establish a native Linux baseline, then test Proton

I first inspected the Linux self-extracting archive using sh GravityMark_1.89.run --info and unpacked it with --noexec so no launcher ran automatically. The shell scripts exposed the actual switches: -vk for Vulkan, -raytracing 1 for RT, and -raster 1 for compute-shader rasterization. Every native run used -width 1920 -height 1080 -count 1 -close 1; I checked the API reported by GravityMark in each log.

Example: my native Vulkan run./run_windowed_vk.sh -width 1920 -height 1080 -count 1 -close 1

For Windows, I installed GravityMark_1.89.msi under Proton in the isolated prefix. I traced a warning about amdxcffx64.dll back to the Proton launcher, where that copy is explicitly marked optional=True. Then I launched the Windows executable with -vk, -d3d11, or -d3d12. Keeping -close 0 allowed the result window to stay on screen so I could capture the exact numbers. My first Windows Vulkan run auto-closed without a recorded score; I repeated it to capture the result.

The seven results

Platform / graphics pathScoreAvg. FPSTimeResult
Linux · Vulkan / RADV35,008209.6167 s✓ completed
Linux · OpenGL / radeonsi33,006197.6167 s✓ completed
Linux · Vulkan Ray Tracing26,192156.8167 s✓ completed
Linux · Vulkan Compute Shader33,521200.7167 s✓ completed
Windows · Vulkan / Proton35,031209.7167 s✓ completed
Windows · Direct3D 11 / Proton30,923185.1167 s✓ completed
Windows · Direct3D 12 / Proton34,016203.7167 s✓ completed

Seven configurations, seven full benchmark completions. There was also the initial auto-closing Windows Vulkan run without a saved score, making eight launches in total. Windows Vulkan under Proton performed almost identically to native Linux Vulkan in this one comparison (209.7 versus 209.6 FPS). D3D11 and D3D12 completed too. The result screens establish the APIs requested by the application; I have not yet separately traced the exact DXVK/VKD3D-Proton libraries loaded for these GravityMark runs. Different graphics APIs also do not necessarily execute identical GPU instructions, so these scores are neither a universal performance ranking nor proof of a driver fix.

My three faces of debugging

This whole process reminded me of David Kriesel's famous Xerox copier story. So I captured my reaction in one three-panel graphic: testing, wondering, and finally WTF. The 150.2 W figure is the average recorded in the RT test window; 200 W represents a threshold crossed repeatedly, while 242 W is the highest reported reading. The graphic illustrates my reaction, not a new set of measurements.

Three-panel comic about troubleshooting an RX 9060 XT: skeptical testing at a 150.2-watt average, surprised reaction to readings over 200 watts, and a raised-fist reaction to the reported 242-watt peak.

Blackbox review: the 242-watt question

My already-running cthulhu-gpu-blackbox.service captured the session in telemetry.tsv, kernel.log, and snapshot.txt. At the time of review, the session contained 11,706 samples from 08:53:55 to 12:13:17 UTC. Across that full period, GPU busy reached 100%, VRAM allocation peaked at 7.50 GiB, and the highest reading across three temperature sensors was 81 °C. A targeted search for common serious AMDGPU and PCIe kernel error patterns returned no matches during the benchmark interval. That is not a comprehensive proof that every possible fault was absent.

In the approximate Vulkan RT test window, 10:36:45–10:39:35 UTC, the mean reading was 150.2 W, the maximum 242 W, 49 of 166 samples exceeded the reported 175 W limit, and 17 exceeded 200 W. The maximum occurred with 100% GPU busy, temperatures of 60/77/72 °C, a 983 rpm fan speed, and a reported PCIe link of 32 GT/s ×16. Shortly afterward the load dropped to idle, consistent with a normal benchmark finish.

I checked both my logging script and the actual sysfs nodes. The logger reads power1_average and power1_cap; power1_input does not exist on this machine. The cap's label is PPT, the configured limit 175 W, and the permitted cap range 122–182 W. The 242 W reading therefore comes from an AMDGPU-reported averaged sensor, not an external power meter. I have not established its filter period or exact comparability to the PPT control limit. I explicitly do not call this proven electrical over-power.

Values above 200 W also appeared at other times in the session: 09:28, 09:29, 10:36–10:39, and 11:29 UTC. Without a complete timestamp-to-application mapping, I do not assign every spike to a particular rendering API. My new question is whether specific load transitions or GPU power states matter more than peak utilization. That is a testable hypothesis, not an established cause.

My interim conclusion: This successful series establishes that my RX 9060 XT does not crash under every Vulkan, DXVK-style, or VKD3D-style workload. It neither refutes S.T.A.L.K.E.R. 2's recorded GEM/GPUVM incidents nor explains Arma 3's separate PCI access loss. I still need targeted, comparable failure captures rather than another blind stress test.

CTHULHU CRASH LAB · CURRENT STATUS, 25 OCTOBER 2026

The raw evidence checks out – and I take my findings upstream

After testing seven graphics paths, I wanted to check one thing properly: Was the 242 W reading really present in my original data, and when exactly did it happen? Rather than starting another benchmark or deliberately provoking another hardlock, I copied the existing live Blackbox session and had its raw telemetry checked against the preserved GravityMark application logs. The result: 20,037 complete telemetry records from 25 October, all tied to GPU 0000:55:00.0, with a displayed power cap of 175 W throughout. The collector kept running while I copied the files; the audit used an unchanged snapshot of those files.

The 242 W reading is confirmed. At 10:39:31.494 UTC, the saved power column contained 242000000 µW while power1_cap showed 175000000 µW. Its timestamp falls within the successfully completed native Vulkan ray-tracing run. I am deliberately keeping the original 150.2 W in my three-panel meme: it is mathematically correct for my initial coarse RT window of 166 samples, which included some pre- and post-run points. The tighter window defined by the benchmark application's recorded seconds contains 163 samples, with a 151.3 W sample mean, 48 samples above 175 W and 16 above 200 W. The maximum is still 242 W in either selection. These figures describe software sensor samples, not independently measured electrical GPU power.

The already-existing GravityMark Proton 11 application log produced another surprise. I had not saved a result screenshot from my first Windows Vulkan run, but its application log still recorded a normal completion and a score of 35,000. This makes eight successfully completed runs across seven distinct graphics paths, all matched to the same Blackbox telemetry file without another test.

What my Blackbox recorded across all eight runs

Graphics pathMean sensor readingMaximumSamples > 175 W
Linux · Vulkan138.9 W180 W3
Linux · OpenGL / radeonsi141.6 W188 W4
Linux · Vulkan RT151.3 W242 W48
Linux · Vulkan Compute Shader145.1 W187 W8
Proton · Vulkan (extra run)138.2 W200 W6
Proton · Vulkan (reported result)140.9 W194 W4
Proton · Direct3D 11134.6 W224 W7
Proton · Direct3D 12136.4 W197 W3

These are arithmetic sample means within nominal application-log benchmark windows, not electrical power measurements. Notably, the successful Direct3D 11 run contained another unusually high single reading: 224 W against a displayed 175 W cap. The exact SMU telemetry domain and filtering interval remain unknown. I cannot infer 300–350 W electrical transients or diagnose a failing PSU from these numbers. But they are a useful control: high reported power values occurred without crashes, while one Arma 3 capture lost PCI access after the last valid reading of 148 W. A simple observed-wattage threshold cannot explain the pattern.

My next step on 25 October: upstream reports, not more hardlocks

With the raw-data audit complete, I reported the two distinct failure signatures separately. For Arma 3, I sent an English report to the public Linux/AMDGPU mailing list at amd-gfx@lists.freedesktop.org. Two captured failures, one with DXVK descriptor buffers and one using its legacy binding model, show the GPU becoming unreachable over PCI before the first logged graphics-ring reset attempt. I included the audio function's failed D3hot-to-D0 transition as an observation, not a proven cause.

For S.T.A.L.K.E.R. 2, I added a distinct Radeon/RADV investigation to Valve's existing Proton compatibility issue #8260 on GitHub. My trace shows a successful close of GEM handle 3229, followed 6.887 ms later by a failed lookup and amdgpu_bo_list_create = -ENOENT in the same DRM file context. That is a concrete host-side error, not proof of a use-after-free or of fault in one particular component. The original issue describes an NVIDIA setup; my comment explicitly distinguishes the AMD finding.

Where I stand on 25 October: Eight completed GravityMark runs are now tied to application logs and Blackbox telemetry. The 242 W and 224 W values are verified as reported sensor readings, not independently measured electrical peaks. I have sent separate upstream reports for Arma and Stalker, but have no confirmed root cause, permanent fix or developer response at this point. My original logs and traces are preserved for focused follow-up questions. No more deliberately triggered hardlocks just to collect more of the same evidence.

CTHULHU GPU BLACKBOX · FIELD REPORT 26 OCT 2026

26 October 2026: I gave my novel a voice – and my Radeon vanished again

I had not intended to test games today. I wanted to bring my completed mystery novel, The Lost Administrator, to life as a German-and-English audio drama: a narrator, distinct voices for the characters and proper sound design rather than a monotonous audiobook. I used my Source2Reel project and local Qwen3-TTS on Arch Linux. Michael Weber had already spoken his first line; the short WAV test worked. During a longer multi-voice generation with Chrome also open, both screens went black and the fan raced to full speed. Cthulhu had found another way to interrupt the story.

Unlike my earlier black-screen incidents, my own GPU Blackbox had logged the event approximately once per second and preserved a real AMDGPU device coredump. This time I could compare timestamps instead of guessing what happened.

Gaming · 24 Oct · 17:173.472 MHz135 W · 100 % GPU
Gaming · 24 Oct · 17:353.445 MHz148 W · 100 % GPU
AI voice · 26 Oct · 17:303.474 MHz124 W · 100 % GPU
GPU core clock: last readable seconds before PCI bus loss
24 Oct · 17:1724 Oct · 17:3526 Oct · Qwen (single sample)
Actual Blackbox samples before three PCIe bus lossesThe curves show the 24 October captures. Only the final exact Qwen value of 3474 MHz is plotted; no intervening Qwen samples are invented.2800300032003400−6s−5s−4s−3s−2s−1sTime relative to last sample

Source: archived one-second Blackbox samples. The lines connect real samples; Qwen is deliberately shown as a single point. Following the last readable values, sensors returned NA and PCIe state became Unknown. Clock speed is not identified as the cause.

What the three crashes share – and what they do not

Local timeWorkloadLast GPU clockLast power readingGPU busy
24.10. · 17:17DXVK3.472135100 %
24.10. · 17:35DXVK3.445148100 %
26.10. · 17:30Qwen3-TTS + Chrome3.474124100 %

The last readable clocks in these three PCI-bus-loss captures are strikingly close: 3,445–3,474 MHz. Reported power differs: 124, 135 and 148 W, all below the displayed 175 W cap. In the relevant kernel logs, loss of GPU accessibility is the first message of this sequence, followed by SMU communication failures (0xFFFFFFFF), GFX ring timeouts and unsuccessful recovery attempts in some cases. That is the logged order, not proof of the physical order of causation.

The AI-session coredump named a chrome:cs0 thread. That does not establish Chrome, YouTube or video decoding as the trigger. The same broad bus-loss sequence was observed during gaming without that particular browser context. The final clocks alone also do not diagnose a faulty PCIe link or power supply.

A real control: the GPU survived high clocks

Qwen observation283samples ≥ 3,400 MHz
Longest run58consecutive samples
25 Oct · comparison session939samples ≥ 3,400 MHz

The simple theory that a 3,400 MHz clock instantly kills the card does not survive the data. Between 17:25:40 and 17:30:47 on 26 October, I found 283 individual samples at or above 3,400 MHz. The longest sequence contained 58 consecutive samples over roughly 58 seconds. A separate 25 October Blackbox session had 939 high-clock samples, with no matches in a targeted search for four known GPU error signatures. These are not 939 uninterrupted seconds, nor does a narrow log search establish flawless stability. But there is no simple instant-failure threshold.

My naval counterexample: War Thunder and SMS Ostfriesland

On Sunday I played War Thunder's native Linux build, at maximum graphics settings, switching ray tracing on and off. No hard lock. And I was not driving a tank: I was aboard SMS Ostfriesland. Coming from Wiesmoor in East Frisia, I could hardly choose anything else. My long-term ambition is the Bismarck, of course. It felt like nearly an hour at sea. Steam's local console log corrected me: 28 minutes and 6 seconds between the game process appearing and closing. Apparently time runs differently on the North Sea.

The Steam launch command contains War Thunder/linux64/aces, confirming the native Linux executable rather than Proton. This Steam log has no explicit time-zone suffix. Assuming the timestamps are local CET on the day of the clock change, the 10:32:54–11:01:00 session aligns with 1,647 Blackbox samples at an average 77.2% GPU-busy reading. That same candidate window had zero samples at or above 3,400 MHz. The 939 high-clock samples occurred in later windows and must not be attributed to this naval session. Timestamp discipline matters as much as a striking graph.

Firmware, the distinct GPUVM fault and diagnostic limits

The system snapshots identify Arch Linux 7.2.11, Mesa/RADV 26.2.5, linux-firmware 20260916-1 and my PowerColor Hellhound Spectral White RX 9060 XT (subsystem 148c:2437). The driver reports SMU firmware 102.71.0; archived boot-time messages confirm that version for all three severe bus-loss sessions. A current pacman -Qkk linux-firmware-amdgpu check showed 708 package-managed files, none modified. That neither clears the firmware of bugs nor identifies it as the culprit. The manufacturer's rated OC boost is also not an absolute software-enforced ceiling.

I am keeping another error distinct: on 21 October at 20:11, a device coredump contained an actual GFXHUB/GPUVM page fault, GCVM_L2_PROTECTION_FAULT_STATUS=0x00701431 with PERMISSION_FAULTS=0x3. That ring reset succeeded and GPU telemetry remained available. It is not automatically the same root cause as the later three PCI-bus-loss incidents and their NA sensors. And previously documented successful GravityMark runs with software-reported readings up to 242 W are a further reminder: a high wattage sample alone does not define a crash threshold.

Where I stand on 26 October

My Blackbox has preserved three comparable bus-loss sequences and one distinct GPUVM fault well enough for a meaningful comparison. Native Linux graphics workloads can remain stable, and so can stretches of high GPU clocks. I have no confirmed trigger and no permanent fix. GPU/SMU stability, firmware or driver behavior, PCIe accessibility and power delivery remain hypotheses, not verdicts. Before deliberately risking another hard lock, I am preserving the original logs and designing a properly isolated next test. Meanwhile, my audio drama is still waiting for Michael Weber's next line.

Explore The Lost Administrator · GPU Blackbox source

CTHULHU GPU BLACKBOX · FIELD UPDATE · 27 OCTOBER 2026

My 5 a.m. experiment: −500 MHz, and suddenly Arma and S.T.A.L.K.E.R. 2 work

Last night I was thinking about a simple question: what if I stopped chasing application workarounds and instead reduced the GPU's boost clock? By breakfast, I had a surprisingly strong set of measurements. This morning I booted my PowerColor Radeon RX 9060 XT Hellhound Spectral White using a separate systemd-boot UKI with AMDGPU OverDrive enabled, applied a −500 MHz GFX clock offset, and deliberately revisited the workloads that had made Cthulhu unusable.

My Blackbox had previously recorded last readable GPU clock samples of 3,445–3,474 MHz ahead of three serious PCI bus losses. PowerColor publishes up to 3,310 MHz boost in OC mode and up to 3,230 MHz in Silent mode for this exact Hellhound Spectral White model. Manufacturer boost specifications are not an absolute hardware or driver-enforced ceiling, however, and exceeding the advertised figure is not by itself evidence of a defective GPU. I chose an offset as a controlled stability experiment, not as a universal safe-frequency prescription.

Earlier PCI bus-loss captures · last valid clocks3,445–3,474 MHzThree incidents, gaming and Qwen3-TTS; correlation, not a proved failure threshold
Highest observed clock in my measured offset runs3,016 MHz−500 MHz offset; later extended gameplay peaked above 3,000 MHz (Arma 3: 3,016; S.T.A.L.K.E.R. 2: 3,011 MHz)
A critical distinction: I did not configure a hard 3,000 MHz cap. This Navi44 driver exposes OD_SCLK_OFFSET; I set it to -500Mhz. About 3 GHz was the observed result across my test workloads, not a guaranteed ceiling in all circumstances.

Four measured loads, then the game that used to die after shader compilation

Workload, 27 OctoberObserved peak clockBlackbox / benchmark evidenceOutcome
GravityMark 1.89 · native Vulkan · 1600×9002,993 MHz163 samples at ≥90% busy; avg 2,935 MHz; score 36,354; 217.7 FPS; 167 sCompleted
GravityMark 1.89 · Vulkan RT · 1600×9002,989 MHz157 samples at ≥90% busy; avg 2,924 MHz; max sensor reading 151 W; score 27,647; 165.5 FPS; 167 sCompleted
Qwen3-TTS 1.7B · original three-voice A/B/C job2,998 MHz998 telemetry samples in the inspected window; 790 at ≥50% busy; max sensor reading 134 WAll three WAV files created
Arma campaign · no Steam launch options2,994 MHz996 samples in the inspected window; 399 at ≥50% busy; max sensor reading 143 W~15 minutes without hardlock, reported by me
Arma 3 · afternoon extended run · max graphics · no launch options3,016 MHzAbout 60 minutes; maximum observed power reading 151 W; no matching GPU error signatures in checked kernel log0 hardlocks
S.T.A.L.K.E.R. 2 · afternoon extended run · max (Epic) graphics · no launch options3,011 MHzAbout 60 minutes including reloads; maximum observed power reading 168 W; no matching GPU error signatures in checked kernel log0 hardlocks

The morning tests were only the beginning. On the afternoon of 27 October 2026, I played Arma 3 and S.T.A.L.K.E.R. 2 for roughly one hour each, both at maximum graphics settings with completely empty Steam launch options. Both sessions finished without a hardlock, and targeted kernel-log checks found none of the familiar GPU failure signatures. Blackbox readings peaked at 3,016 MHz / 151 W for Arma 3 and 3,011 MHz / 168 W for S.T.A.L.K.E.R. 2. These are sampled sensor maxima from the later extended sessions, not continuous physical limits or whole-system power figures. Thus the previously measured sub-3 GHz peaks were not a fixed clock cap. That matters because Arma had previously frozen at campaign start, while S.T.A.L.K.E.R. 2 had hardlocked after shader compilation without its old launch workarounds.

The S.T.A.L.K.E.R. comparison matters because my previous launch string was VKD3D_CONFIG=vk_debug VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation VKD3D_DISABLE_EXTENSIONS=VK_EXT_descriptor_buffer RADV_DEBUG=hang,noumr PROTON_LOG=1 %command%. The new run used an empty Steam launch-options field: neither the descriptor-buffer workaround nor diagnostic switches were active. Removing several switches together means this is not an isolated A/B experiment for any single Vulkan extension.

The voice test is similarly personal. On 26 October the longer three-voice The Lost Administrator generation lost the GPU bus. On 27 October I reran the original text and all three voice instructions using Qwen3-TTS VoiceDesign 1.7B, PyTorch 2.11.0+rocm7.2 and ROCm/HIP 7.2. This time A_Deutsch.wav, B_American.wav and C_Mystery.wav all finished. Kernel-log filtering after the run found no familiar bus-loss, GPU reset or ring-timeout patterns. An unrelated HDMI vendor-infoframe message at boot is not evidence of the crash signature.

Reproduce my exact approach: isolated OverDrive boot profile on Arch Linux

This is my documented setup, not a one-size-fits-all tuning recipe. It assumes an Arch Linux installation with systemd-boot, an existing mkinitcpio-generated UKI, and Fish shell. It modifies the boot setup and AMDGPU performance controls: back up your EFI files and configuration first, understand every command, and do not copy the PCI address, firmware mask or clock offset blindly. A GPU hardlock remains possible. Only use values accepted by your own OD_RANGE.

1. Identify the GPU and original AMDGPU feature mask

lspci -Dnn | grep -Ei 'VGA|3D|Display'
cat /sys/module/amdgpu/parameters/ppfeaturemask

My GPU is 0000:55:00.0. My original mask was 0xfff7bfff. The OverDrive feature bit is bit 14 (0x4000). Calculate the bitwise OR for your own current mask rather than replacing other feature bits:

python -c 'from pathlib import Path; m=int(Path("/sys/module/amdgpu/parameters/ppfeaturemask").read_text().strip(),0); print(hex(m | (1 << 14)))'

My result was 0xfff7ffff. Other systems may differ.

2. Build a separate UKI instead of altering the normal boot

My regular kernel command line lives in /etc/kernel/cmdline. I appended the new parameter to a temporary file, then built a separate UKI. The paths below are specific to my Arch layout; inspect /etc/mkinitcpio.d/linux.preset and the EFI mount before adapting them.

string join ' ' (cat /etc/kernel/cmdline) 'amdgpu.ppfeaturemask=0xfff7ffff' | tee /tmp/cthulhu-overdrive-cmdline
sudo mkinitcpio -k /boot/vmlinuz-linux -U /boot/EFI/Linux/arch-linux-overdrive.efi --cmdline /tmp/cthulhu-overdrive-cmdline --splash /usr/share/systemd/bootctl/splash-arch.bmp

My normal /boot/EFI/Linux/arch-linux.efi remained untouched; the experimental file is arch-linux-overdrive.efi. Rebuild the experimental UKI after kernel/initramfs updates: it is not automatically maintained by my ordinary preset.

3. Select the experimental profile for one boot

sudo bootctl list --no-pager
sudo bootctl set-oneshot arch-linux-overdrive.efi

Then reboot. The set-oneshot selection affects only the next boot; arch-linux.efi stays the default. The OverDrive UKI remains selectable in the boot menu. After boot, confirm /proc/cmdline contains your chosen mask.

4. Check supported range; apply and commit the clock offset

sudo cat /sys/bus/pci/devices/0000:55:00.0/pp_od_clk_voltage

My card exposed OD_SCLK_OFFSET: 0Mhz and OD_RANGE: SCLK_OFFSET -500Mhz ... 1000Mhz. At this point the GPU performance policy still read auto. Then, for my particular card and test only:

printf 's -500\n' | sudo tee /sys/bus/pci/devices/0000:55:00.0/pp_od_clk_voltage
printf 'c\n' | sudo tee /sys/bus/pci/devices/0000:55:00.0/pp_od_clk_voltage
sudo cat /sys/bus/pci/devices/0000:55:00.0/pp_od_clk_voltage

The final readback showed OD_SCLK_OFFSET: -500Mhz, OD_VDDGFX_OFFSET: 0mV and maximum listed memory clock 1259MHz. I did not change voltage or memory overclock settings; the power-cap readout remained 175 W. The offset is not persisted across reboot in this procedure: selecting the OverDrive UKI again enables the interface but does not reapply -500Mhz. Returning to the normal UKI and rebooting returns to my ordinary boot profile.

5. Measure actual clocks, not just the setting

Run a consistent, finite benchmark or previously problematic game with logging enabled and compare real GPU core clocks and symptoms. My GPU Blackbox captured gfx_clock_hz, utilization, watts, temperatures and PCIe state roughly once per second. Samples are not a continuous hardware-level frequency cap measurement. Keep ordinary gaming conditions as similar as possible and record exact session durations.

For other RX 9060 XT owners: measure first, choose your own offset

If you have comparable symptoms, first identify your exact model and BIOS mode, read the manufacturer's published game/boost specifications, and collect sustained/peak frequencies while the machine is still responsive. My Hellhound Spectral White is listed at 3,310 MHz OC boost or 3,230 MHz Silent boost. These are reference specifications, not an instruction to subtract an exact difference or an absolute crash threshold. Start with your own baseline, verify pp_od_clk_voltage support and its OD_RANGE, choose a conservative experiment appropriate to your system, and inspect the resulting clock and stability data. Do not assume my −500 MHz setting or the apparent ~3 GHz result is right for every card. A failed card, PSU, PCIe issue or driver bug may need a different remedy; underclocking can also mask an underlying fault.

27 October extended-session update — provisional conclusion: With the GPU clock offset active, Vulkan, ray tracing, local ROCm inference and the previously troublesome games completed the tested workloads. Morning samples were below 3 GHz, but the later extended game sessions briefly exceeded that level. The workaround is working in my tested scenarios. I have not proven a specific root cause, a permanent fix, a universally safe limit or long-term stability. The subsequent approximately one-hour Arma 3 and S.T.A.L.K.E.R. 2 sessions both ran at maximum graphics with no launch options and no hardlocks. Peaks above 3 GHz show that −500 MHz is an offset, not a hard 3 GHz ceiling. I'm pausing the active investigation for now while keeping Blackbox available for future play.

Hardware: PowerColor RX 9060 XT Hellhound Spectral White 16 GB · Ryzen 7 5800X3D · Arch Linux kernel 7.2.11-arch1-1 · Mesa/RADV 26.2.5 · AMDGPU OverDrive amdgpu.ppfeaturemask=0xfff7ffff · test-only OD_SCLK_OFFSET=-500Mhz. All successful test outcomes are firsthand observations from 27 October 2026, not promises for other hardware.

Sources, reproducibility and limitations

The original hardware photos, configurations and screenshots come from the Cthulhu Computer Museum record. The public Cthulhu configuration archive documents Linux setups but does not preserve every old test. Technical background: Linux kernel AMDGPU documentation, Mesa documentation and ArchWiki AMDGPU. Game durations, failure symptoms and choices are my own observations.

Still unknown: exact power-supply model, failed Mesa version numbers, the particular upstream fix (if any), and the SATA cable/port tests yet to be carried out. These results are no guarantee for other Navi44 GPUs and not an invitation to flash firmware.

← Back to blogCthulhu backstory →