WIP: fix(nvn): the array binds check the count and the whole guest array before reading it #2018
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/tooling
area/upscaling
beanstalk: approved
beanstalk: failed
beanstalk: needs approval
beanstalk: running
beanstalk: tested
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
risk
high
risk
low
risk
medium
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
ci: approved
No milestone
No project
No assignees
3 participants
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!2018
Loading…
Reference in a new issue
No description provided.
Delete branch "siantm/Longshot:fix/nvn-bind-array-span"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Summary
The native NVN layer's array binds read the game's array before checking that all of it lies in the guest window.
BindTextures,BindImages,BindSeparateTextures,BindSeparateSamplers, theirDeferredforms (8-byte handles)and
BindVertexBuffers(16-byte buffer ranges) passed the array asP(4)/P(3), which checks one byte of it(
NVN_OBJ_MIN).BindTexturesandBindTexturesDeferredalso letHOS_NVN_WATCH_TEX's watch read the handles beforebind_handleschecked their count. So an array that starts inside the window and runs past its end was read past it:host memory, or a crash, instead of the stop with the window's line that every other array argument gets (and that
the Deferred array's second read at submit already gets). Two more holes, found in review of this PR: a positive count
at guest address 0 (
P/PNgive NULL for 0) reached the watch or the record'smemcpy, andBindVertexBuffersandBindVertexBufferchecked their first and count only asfirst + count > 16, anintsum the game's values canoverflow (first 1 with a count of
INT_MAXpassed it).This checks the count first (0 to 32 handles, as
bind_handlesrecords, inbind_array; for vertex buffers, invbufs_check, first 0 to 16 and the count 0 to 16 - first, each compared alone, which both vertex-buffer entry pointsgo through) and then the whole array in the window (
bind_span: all 8 x count or 16 x count bytes, and guest address 0only with a count of 0), before the watch or the record reads an element. A count of 0 at address 0 is recorded empty,
and nothing is copied from NULL. The result: such an array stops the game with its line ("guest memory ... is outside
the guest window", "bind of 2 array elements at guest address 0", "BindVertexBuffers 1+2147483647"); arrays inside the
window are recorded as before.
How to see it on
main: not in normal play (the game passes arrays inside the window). Game-free:python -I -B tests/test_nvn_bind_span.pywithmain'shost/nvn_native.cmakes these binds read past the window'send, copy from a null array or accept an overflowing first + count (50 of 104 cases fail, see Measurements).
Found by BeanBot's review of #1954 (point 2, "count and span before the read")
and named inherited in futondestroyer's review of #1954
("The missing full-span check in the bind-array wrappers is inherited"); the null array and the overflowing sum by
BeanBot's review of this PR.
Read first:
bind_span,vbufs_check,bind_arrayand thenvnCommandBufferBind*entry points inhost/nvn_native.c;tests/test_nvn_bind_span.py.Overlap: #1954 (
perf/nvn-bind-fields@fe1dd999) rewritesbind_handlesand the watch just above these lines; the twomerge without a conflict (checked with
git merge-treeat this head), in either order. Proposed order: this first;#1954 is rebased when it lands (its watch's own 0 to 32 check then only repeats this one). The watch's own races and its
frame walk (BeanBot's points L3 and L4 here) are #1954's: its
519f5c7eandfe1dd999fix them; this PR does not touchthe watch. Left alone, pre-existing on
main:resolve_deferredwrites each submit's resolved handles into theshared recording (L5), for a separate change.
Testing
Tested: Windows 11, i7-9700, RTX 4060 (NVIDIA 610.88), llvm-mingw clang 23.1.5; game-free checks only. This has
NOT run in the game on this PC (Still to test). Each check ran in a hidden console of its own, in build jobs of the PC's
job queue (fb2-2018-1, and fb2-2018-2 for
main's column), onmain@b62932a9, head555b5160:python -I -B tests/test_nvn_bind_span.py(no--cc:LONGSHOT_MINGW's clang; and again withCCa commandwith a flag,
clang.exe --target=x86_64-w64-mingw32): "PASS: every array bind checks its count and its whole spanbefore it reads the array (104 cases)": the 9 array entry points x edge, zero, zero-null, null, past, order, over,
huge, negative (BindVertexBuffers also far), BindVertexBuffer's edge, over, far and negative (first 15, 16,
INT_MAX,-1), and
BindTextures(Deferred)again withHOS_NVN_WATCH_TEX=beef. A bind kept is checked whole (opcode, size, stage/first, count, a Deferred bind's source,then the elements); a stop must give its own line and leave no record.
45d430a8(the PR's first fix, without555b5160): 24 of 104 fail: a count of 2 at guestaddress 0 and a count of 0 there, for every entry point and watch mode (22:
memcpygiven NULL, or the watch's readof address 0), and BindVertexBuffers with first 1 and a count of
INT_MAX(an access fault:first + countoverflowed and passed) and with first
INT_MAX(the array read before a stop). BindVertexBuffer's own firstINT_MAXpassed there too (the compiler folded itsfirst + 1 > 16); it is checked now without relying on that.(
BindImagesDeferred): 2 fail (edge, zero: "source 0, not ..."); the span checked before the count: 30 fail (over,huge, negative stop with the window's line, not the count's); the first handle read before the span check: 10 fail
(order: "read the array ... before the bind checked it"; past still passes, as the review said it would).
host/nvn_native.ccompiled (-fsyntax-only) with the host build's own flags, with and without Tracy: no error.python -I -B tests/run_all.py --strict --changed origin/main(RX_CPMset): 21 passed, 2 failed, 1 skipped(
test_tracy_funcs.py: Linux only). The 2 failing (test_dev_packs.py,test_host_guest_writes.py) fail onmain@b62932a9too, run by name from amainworktree in the same job, with the same messages; none of the 24 failedfor want of the Vulkan headers.
main@f1f2dc5b, jobs fb3-sep-1 and fb3-sep-2): their first test passed atthe fix and failed 13 of 55 at the test commit.
Still to test:
this PR against
main, expecting no stop, the same picture and frame times within the runs' spread (by hand)python3 -I -B tests/test_nvn_bind_span.py(and withCC='ccache clang'), expectingit to pass (by hand)
Hyrule Field, two minutes each, this PR against
main, expecting no stop and the same picture (the Test Farm: playCastle Town's market and Hyrule Field on Linux, Windows with an AMD GPU and the Steam Deck, this PR against main,
looking for a stop with "outside the guest window", "at guest address 0" or "BindVertexBuffers", or a changed picture)
mise run lint(ruff, pre-commit) andmise run teston a PC with ruff and pre-commit (none here), expecting nofailure but
main's (by hand; CI runs them on the head too)Measurements
Verdict: the bug is gone in the game-free fixture: with
main'shost/nvn_native.c50 of the 104 cases of thisPR's
tests/test_nvn_bind_span.pyread past the window's end, read the array before checking it, copy from a nullarray or accept an overflowing first + count; with this PR none (104 pass). Nothing about speed is claimed or measured.
Setup: Windows 11, i7-9700, llvm-mingw clang 23.1.5;
python -I -B tests/test_nvn_bind_span.py(the head's test),one run each, game-free, in build jobs of the PC's job queue: Before,
main'shost/nvn_native.candhost/hos.hwith the head's test (fb2-2018-2); After, the head (fb2-2018-1). The fixture compiles the real entry points over a
guest window followed by no-access pages; each case is a process of its own.
b62932a9555b5160memcpygiven NULL)Risks
An array the game passes that runs past the guest window's end, which
mainread past, now stops the game with thewindow's line; if the game ever did that on purpose, it would stop here where
mainread host memory (and could crashor draw with garbage handles). So does a positive count with a null array (
mainread address 0 of the host: a crash),and a vertex-buffer first and count beyond 16 that
mainlet through when first + count overflowed. Arrays inside thewindow, a count of 0, and the count's own stop (more than 32 handles, more than 16 ranges) are unchanged.
No switch: a revert gives back
main's code. Players notice nothing after updating: no settings, saves or caches change.Checklist
Ready for review
main; the title is a Conventional Commit.mise run testpasses (any failure that also fails onmainis named).main, or Measurements says why there is nothing to measure.third_party/untouched; nothing GPL-incompatible.When it applies
mainand passes here.Assisted-by:/Co-Authored-By:trailers.Ready to merge
main, measured again or a comment says why the numbers still hold.Recommendation: Request changes. The new checks catch non-null arrays that cross the guest window, but a null array still reaches a host read and the vertex count check can overflow. Both need to reject the input before recording or reading it.
Adds guest-window checks to nine NVN array binds so malformed calls can stop with a diagnostic instead of faulting. It reuses the existing range helper and preserves the command format, but the vertex wrapper uses a zero-byte span for invalid counts and relies on a separate, unsafe count check.
@fixwill do (10)host/nvn_native.c:2183: PN returns NULL without validating guest address zero. (more on the line)host/nvn_native.c:2119: The wrapper checks zero bytes when the count exceeds 16, then depends on the inherited signed addition in bind_vbufs. (more on the line)host/nvn_native.c:2158: The inherited watch still races when independent command-buffer threads initialize want on their first texture binds, even with the switch off. With the watch enabled, two matching chains can also race on seen and nseen, including at the table's last slot. Initialize the setting once with synchronized publication and protect the lookup and insertion together.host/nvn_native.c:2163: The inherited watch checks the frame pointer's start before reading two words. If a handle matches and the frame pointer is eight bytes below the guest-window end, the saved return address is read outside the window. Validate the full frame pair against the runtime window and stop walking on an invalid frame.host/nvn_native.c:2511: The inherited deferred resolver writes new handles into the shared recording. With asynchronous replay, submitting the same recording again before the first submit drains can overwrite the first submit's handles while replay reads them. Give each queued submit its own resolved payload and retain it until replay finishes.tests/test_nvn_bind_span.py:210: The over and negative cases accept any fatal diagnostic because the expected string is empty. (more on the line)tests/test_nvn_bind_span.py:201: The success check only compares the trailing bytes. (more on the line)tests/test_nvn_bind_span.py:44: CC works for a single executable, but a common setting such as CC='ccache clang' is passed to subprocess as one nonexistent executable. (more on the line)tests/test_nvn_bind_span.py:94: The POSIX signal handler calls snprintf, which is unsafe in a signal handler, and sends its unchecked return value to write. (more on the line)For the author (1) (a run, a measurement or a decision)
Checks: Still running:
CI / Conventional Commit title (pull_request),CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request),CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request),CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request),CI / Workflow lint (actionlint) (pull_request),CI / Website build and checks (pull_request),Guide screenshots / Guide images and local UI source review (pull_request),Third-party parts / As their notes say (pull_request),Third-party parts / The same as upstream (pull_request).More: does it help, other systems, switches, what was read
Does it help: Yes for the tested end-of-window cases. The PR reports 13 faults in 55 fixture cases on the test-only commit and 55 of 55 passing with the fix on the same Windows PC, before the rebase. The current head, Linux, and normal gameplay remain unverified. No performance gain is claimed.
Other systems: The host bind path runs before Vulkan replay on Windows, Linux and Steam Deck, regardless of GPU vendor. Valid inputs take the same recording path, with the same payload layouts and submit-time deferred reads. The fixture does not cover rendering, frame pacing or repeated submissions. Windows still commits reserved guest pages on first touch, and Linux maps the guest window read/write. The new check verifies the window boundary, with no change to those memory policies. The diff has no path into saves, caches, audio, input or the Launcher.
Switches: None added, changed or removed. HOS_NVN_WATCH_TEX stays off by default in gpu/vk/switches.def. The fixture explicitly clears it and enables it for the two texture entry points that use it.
Reviewed:
cfd24dda9bagainst40bfceb055: Read tests/test_nvn_bind_span.py in full, the complete diff and both commits, AGENTS.md, CONTRIBUTING.md, the Forgejo template and docs/dev/standards.md. No docs/review-checklist.md exists in the checkout. Read the changed host/nvn_native.c blocks and traced the guest-window helpers, command allocation, dispatch, deferred submit and replay consumers. Skimmed nearby unchanged NVN code, existing source checks and CI configuration. Unrelated portions of host/nvn_native.c were not read line by line. No generated files or translations changed. The run evidence is from the PR description, with no comments or reviews supplied.; nothing run (a code review).Checked and fine:
Testing: Read-only review. No build, fixture, project script or game run was performed. The author reports two filtered-suite failures also present on the older base and one Linux-only skip. Head CI is still running, with no head-only failure reported.
Overlaps and merge order: #1954 rewrites bind_handles and the texture watch. Use #2018 first, then rebase #1954 and rerun the combined fixture, including both watch modes. The PR reports a conflict-free merge in either order. The sibling revision was unavailable in this checkout.
Automated code review by BeanBot (gpt-6.2-sol), on the pull request's opening. Nothing was run; a maintainer decides.
@ -2117,1 +2117,3 @@NV(nvnCommandBufferBindVertexBuffers) { bind_vbufs(CB(P(0)), I(1), I(2), (const NVNbufferRange *)P(3)); }NV(nvnCommandBufferBindVertexBuffers) { /* (the whole array in the guest window: P checks its first byte only) */const int n = I(2); /* (out of 0 to 16: bind_vbufs stops the game before it reads any) */bind_vbufs(CB(P(0)), I(1), n, (const NVNbufferRange *)PN(3, n > 0 && n <= 16 ? sizeof(NVNbufferRange) * (uint64_t)n : 0));L2: The wrapper checks zero bytes when the count exceeds 16, then depends on the inherited signed addition in bind_vbufs. With first = 1 and count = INT_MAX, first + count overflows before the comparison, so the guard cannot safely reject the call. Validate first and count before translating the pointer, using first between 0 and 16 and count between 0 and 16 - first. Use the same rule for the single-buffer entry point and add an extreme-value case.
@ -2174,0 +2180,4 @@static const uint64_t *bind_array(Ctx *c) {const int n = I(3);if (n < 0 || n > 32) die("bind of %d handles", n);return (const uint64_t *)PN(4, 8 * (uint64_t)n);L1: PN returns NULL without validating guest address zero. A positive count with a null array reaches watch_tex or memcpy, including the vertex-buffer call at line 2119. Reject null for positive counts before the watch or recorder. For a zero count, preserve the empty record and skip memcpy so a null array never reaches it. Cover both cases in the fixture.
@ -0,0 +41,4 @@clone's folder), else clang, gcc or cc on PATH"""for c in (given, os.environ.get("CC")):if c:return shutil.which(c) or cL8 (minor): CC works for a single executable, but a common setting such as CC='ccache clang' is passed to subprocess as one nonexistent executable. Accept a compiler command from CC, preserving existing executable paths with spaces, and append the fixture arguments to that command.
@ -0,0 +91,4 @@static void fault(int sig, siginfo_t *si, void *u) {(void)sig, (void)u;char b[256];const int n = snprintf(b, sizeof b, "FAIL: %s, %s: read guest %#llx, past the window's end (%#llx), before any stop\n",L9 (minor): The POSIX signal handler calls snprintf, which is unsafe in a signal handler, and sends its unchecked return value to write. Both platform handlers label every access fault as a read past the guest window, including a null dereference. Check handler registration and distinguish faults in the guard from unexpected faults using fixed messages and signal-safe calls on POSIX.
@ -0,0 +198,4 @@const uint64_t array = WINDOW - (uint64_t)elem * (n ? n : 1);const uint8_t *cur0 = host_rec.cur;if (bind_case(e, n, array)) { fprintf(stderr, "FAIL: %s, %s: stopped: %s\n", entry_name, k, died_line); return 1; }if (host_rec.cur == cur0 || (n && memcmp(host_rec.cur - (size_t)elem * n, GP(array), (size_t)elem * n))) {L7 (minor): The success check only compares the trailing bytes. A deferred wrapper that records src as zero still passes and then replays the stale record-time handles. The zero case accepts any record size or count. Check the opcode, size, count and deferred source before comparing the payload within the verified record bounds.
@ -0,0 +207,4 @@}int n;uint64_t array;const char *want = "";L6 (minor): The over and negative cases accept any fatal diagnostic because the expected string is empty. A wrapper that checks the full span first and stops with a window error for an excessive count would pass. Also, the past case leaves the first element readable, so it cannot prove that validation precedes every read. Require the count diagnostic for invalid counts and protect the readable prefix in a separate ordering case.
cfd24dda9b555b5160d3Pushed
555b5160(with lease overcfd24dda), onmain@b62932a9, for BeanBot's review:main@b62932a9without a conflict; the two earlier commits are unchanged (git range-diff:405eb181=033c238e,cfd24dda=b398ced3).45d430a8test(nvn): null-array, zero-count-at-address-0, overflowing first + count and ordering cases; invalid counts must stop with the count's own line; a kept bind is checked whole; fault handlers with fixed lines that tell the guard, the no-access page and any other fault apart;CC/--cctake a compiler command with flags (L1, L2's test, L6-L9).555b5160fix(nvn):bind_spanstops a positive count at guest address 0 before the watch or the record, and a count of 0 there copies nothing from NULL (L1);vbufs_checktakes first 0 to 16 and the count 0 to 16 - first, each alone, before the array is translated, for both vertex-buffer entry points (L2).555b5160, 24 of 104 cases fail at45d430a8, three changes of the fix are caught, syntax with and without Tracy,--changed); Measurements has the fixture'smainagainst this PR (50 of 104 fail onmain, 0 here, job fb2-2018-2) and no longer the unmeasured "one compare more" (L10). The game run, Linux and the lint are still to test (L11).git merge-treeagainstfe1dd999); this PR is still proposed to land first.Re #2018 (comment) (L1): fixed in
555b5160, test first in45d430a8.bind_span(used bybind_arrayandBindVertexBuffers) stops the game with "bind of N array elements at guest address 0" for a positive count at address 0, before the watch or the record; for a count of 0 the record is kept empty,bind_vbufsskips its copy andbind_arrayhandsbind_handlesan empty non-NULL array (bind_handlesitself is left to #1954, whose rewrite already skips the copy for 0). The fixture's newnullandzero-nullcases (every entry point, both watch modes; the fixture'smemcpyfails on a NULL pointer even for 0 bytes) fail 22 times at45d430a8and pass at555b5160, in the same queue job.Re #2018 (comment) (L2): fixed in
555b5160, test first in45d430a8.vbufs_checktakes first 0 to 16 and the count 0 to 16 - first, each compared alone, andBindVertexBufferscalls it before the array is translated;bind_vbufs(whichBindVertexBufferalso goes through) checks the same way. New cases: first 1 with a count ofINT_MAXand firstINT_MAXwith a count of 1 forBindVertexBuffers, and first 15, 16,INT_MAXand -1 forBindVertexBuffer. At45d430a8the first two fail (an access fault, and the array read before any stop: the sum wrapped and passed);BindVertexBuffer'sINT_MAXalready stopped there (its compiledfirst + 1 > 16did not wrap, though the sum is undefined in C), which the new check no longer relies on. All pass at555b5160.Re #2018 (comment) (L3): right, and inherited: this PR does not change
watch_tex, and the race is inmain's version (the function-staticwantset on the first bind,seen/nseenunlocked). #1954, which rewrites the watch, fixes both in its519f5c7e: the switch is read once underwatch_tex_lockand published with an atomic store (the inline test is an atomic load), and the chains are looked up and added under the same lock, the table's last slot included. This PR lands first and #1954 is rebased onto it (the two merge without a conflict), so the fix is not repeated here.Re #2018 (comment) (L4): right, and inherited from
main'swatch_tex, which this PR does not change. #1954 fixes the walk: its519f5c7ereads a frame only when all 16 bytes (saved frame pointer and return address) are mapped guest memory and stops at a link that does not go up the stack, and itsfe1dd999(its head now) also keeps the walk inside the recording thread's own guest stack (fp - stk <= stk_n - 16). So the pair is checked whole before either word is read, and the walk ends at the first frame that fails.Re #2018 (comment) (L5): right as far as the code shows, and pre-existing on
main, which this PR does not change. Onmain@b62932a9,resolve_deferredcopies each Deferred bind's handles (host/nvn_native.c:2504) and buffer ranges (:2508) into the shared recording at every submit (:2534), while the replay reads that recording later in three paths: the render thread (gpu/vk/vk_replay.cpp:7781queues only the handles; Threaded rendering On, or Auto from 4 cores, orRX_VK_ASYNC=1), a queue stopped at an event wait on the submitting thread (submit_job,vk_replay.cpp:3027, with the render thread off), andHOS_NVN_HOLD=1(nvn_native.c:2552). In each, a second submit of the same command buffer before the first is replayed overwrites the handles the first will read (on the render thread possibly while it reads them); whether the game resubmits a recording with Deferred binds inside that window is not determined here (it needs a game run). The fix would give each queued submit its own resolved copy, kept until its replay ends: a change to submit and replay, left for a separate change, not this bounds fix.Re #2018 (comment) (L6): fixed in
45d430a8.over,hugeandnegative(andfar) now require the count's own line exactly ("bind of 33 handles", "BindVertexBuffers 1+2147483647"), with the window's last page made no-access, and a newordercase repeatspastwith that page no-access, so any read of the array before the span check faults. Both were checked against changes of the fix in the same queue job: checking the span before the count fails 30 cases (the window's line instead of the count's), and reading the first handle before the span check fails the 10ordercases whilepaststill passes, as you said it would.Re #2018 (comment) (L7): fixed in
45d430a8. A kept bind (edge, zero, zero-null) is checked whole: the record's size must equal the bytes the allocator moved on by and rec's rounded size, then its opcode, stage/first, count and a Deferred bind's source (the array's address, 0 for the others), and only then the elements within that size. WithBindImagesDeferredchanged to record its source as 0, its edge and zero cases fail ("source 0, not 3, 5, 32, 0x3ff00"), in the same queue job.Re #2018 (comment) (L8): fixed in
45d430a8.--ccandCCnow go throughtests/compiler_command.py'sparse_compiler(asrun_all.pyand the input checks do): an existing path, spaces included, is kept as one executable, anything else is split as a command (Windows rules there,shlexelsewhere), and the fixture's arguments are appended to it. It ran withCCset toclang.exe --target=x86_64-w64-mingw32and passed; accache clangrun on Linux is in Still to test.Re #2018 (comment) (L9): fixed in
45d430a8. Both handlers now write fixed lines only (POSIX:writein a loop, nosnprintf; Windows:WriteFile) and tell three faults apart by address: in the guard pages ("read past the window's end", exit 5), in the window's no-access last page ("read the array ... before the bind checked it", exit 6), and anything else ("an access fault outside the guard and the no-access page (a null or stray pointer)", exit 7).AddVectoredExceptionHandler,sigaction,VirtualProtect/mprotectand the page size are checked, and the fixture stops with "fixture: no ..." if one fails; the Linux side is not run here (Still to test).Re #2018 (comment) (L10): fixed in the description. Measurements now has a Verdict, the Setup and the fixture's table,
main@b62932a9(itshost/nvn_native.cwith this PR's test, job fb2-2018-2) against this PR @555b5160(job fb2-2018-1): 50 of 104 cases fail onmain, by kind, and none here. The unmeasured "one compare more per array bind" is gone; no speed claim is made.Re #2018 (comment) (L11): the game-free part is redone on this head (Tested: the fixture at
555b5160and at45d430a8, withCCas a command, the host file's syntax with and without Tracy,run_all.py --strict --changedwith its 2 failures shown onmain@b62932a9too). The author's game run on this PC (Castle Town's market and Hyrule Field againstmain) is pending and has been asked for; the Linux fixture and host build,CC='ccache clang', UTF-8 paths, the Tier 1 runs (Linux NVIDIA/AMD, Windows AMD, Steam Deck), the lint and the whole suite are in Still to test with who runs them. The PR stays WIP until those are in Tested.@Beanstalk This fixes the native NVN array binds (Bind*Textures, Images and Samplers, deferred or not, and BindVertexBuffer(s); host/nvn_native.c): each checks the count, the first index and the game's whole array before reading it, and stops on a null array. No switch: a revert gives back main's code; play should not change. It has not run in the game on these PCs yet. Please start from the market-entrance save and play Castle Town Market for two minutes, then Hyrule Field for two minutes, the PR against main on the same PC, with a picture in each compared with main's, on Linux with NVIDIA, Linux with AMD (RADV), Windows with Intel and the Steam Deck. The same picture as main, no crash and no stop with "outside the guest window", "at guest address 0" or "BindVertexBuffers" in the log; frame time p99 equal to main's, within the run-to-run spread.
@siantm only members of
BigBeanscan start the farm. One of them can approve this request by reacting 👍 to it or to this comment.View command line instructions
Checkout
From your project repository, check out a new branch and test the changes.