Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/c1-codex-verify-v2.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.

1. P6's plan and contract draft (neither started; not one line of code)

     docs/Disaggregated/P6-SPAWN-PLAN.md      the package plan
     docs/Disaggregated/P6-CONTRACT-DRAFT.md  the contract draft (moves to
                                              MG_Remote/CONTRACT-P6.md when c6 lands)

   The three findings that mattered, all written into the documents:

   a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
      the tree and already tested: SocketDoorbell including hangup detection and the two
      lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
      passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
      protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
      SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
      assembly plus a control plane plus a process, not "write a socket transport".

   b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
      audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
      the tree again. So the first package, a6, is a read-only audit that writes no code, and
      every contract row that depends on it is marked PENDING a6 rather than decided in
      advance.

   c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
      and protocol.fbs:186-196's own comment says Android transfers the window out of band -
      that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
      the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
      gate measures. A real window reaching the server is a named refusal. This gets its own
      section because "P6 is done" would otherwise read as "the game runs now".

   The contract adds rule G: a role may not name a process-local handle. It extends P5c's
   rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
   EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
   a token this contract defines or they do not cross, and a descriptor crosses only through
   SCM_RIGHTS, where the kernel renumbers it.

   What P5e left for P6 gets its own section. The latch semantics are already designed
   (ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
   client no longer waits while the peer process can DIE: the client holds records that were
   published and will never be applied, and Android's freezer suspends the child without
   closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
   That is P6's only new design; everything else is carriage. It shares a predicate with E1's
   outstanding re-specification (ID-122), and the two should be designed together.

   Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
   match integration-split's name for name, because a differing set means the lane is quietly
   running less; and the arm-proof gate requires every entry to record the child pid and
   transport=spawn in its OWN private log - ID-124 established that this kind of false green
   really happens, and a spawn lane that actually ran monolith would pass every other gate.
   S2's shape must be settled before it is written, and the document says why: E1 is the
   cautionary case.

2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)

   ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
   the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
   is under no version control. A record cited hundreds of times that lives only locally is not
   a record, so it moves in whole, with its directory structure intact.

   Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
   stay where they are: they are evidence DATA rather than documents - large, regenerated per
   run, and mostly carrying absolute paths and device serials that mean something only on the
   machine that produced them. The mapping and this split are written in
   docs/Disaggregated/notes/README.md.

   Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
   document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
   material salvaged from failed workflow runs, which may duplicate the like-named phase
   directories and is kept because a few of those were the only complete version at the time.

   CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
   deliberately outside it: those notes' file:line citations were written against their own
   code heads, and resolving them against today's HEAD would fail wholesale - which is not an
   error, it is their correct state as a historical record. To check one, use the revision it
   declares (--rev).

3. Inconsistencies fixed in passing

   - README.md's status line still said P5e was in progress while the stage table already said
     closed.
   - CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
     (a) and (b) were run in the previous commit; rewritten to closed plus the one item that
     actually remains (E1).
   - ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
     package order, the scope boundary and the two new gates.

Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
2026-09-18 23:31:39 -04:00

47 KiB
Raw Blame History

c1 cross-family review, round 2 — VERIFICATION

Executes the ten findings of p5-results/c1-codex-review-v2.md that are c1's — 2, 4, 5, 6, 7, 8, 9, 10, 11, 12. Findings 1 and 3 are v1's open items (ID-55 item 12, ID-56 blockers 1 and 3) and were not assigned here; §D records where they turned up anyway.

Worktree: ~/w7/p5-verify, branch p5/verify, detached at 41992649 (p5/c1's head), build-split, ccache, -j 14. ~/w7/p5-verify-submodlinks.sh off before every git command and on before every build. build-split/CTestTestfile.cmake present (580 bytes, 3174 entries). Nothing was fixed and nothing was committed. Every perturbation is a local, uncommitted edit, reverted with the driver's own saved-text restore, and git status --short was verified empty between findings — printed as (clean) in every log below. Final state: clean, detached at 41992649, init patch reverted.

The init patch. Every integration entry under inproc needs c1's documented MG_Backend/Init.cpp direct-construction one-liner (~/w7/p5-c1-r2-redcheck.py, init_patch), reproduced verbatim in ~/w7/p5-verify3-initpatch.py / p5-verify3-drive.py:init_patch. It was applied as a local, uncommitted edit for every integration run in this document, and reverted after each one. Runs marked "unit" do not use it.

Driver and artefacts. ~/w7/p5-verify3-drive.py (apply → build → run → revert → git status), ~/w7/p5-verify3-probes.py (the temporary read-only probes), per-finding scripts ~/w7/p5-verify3-f*.py, logs ~/w7/p5-verify3-*.log. Temp files all carry the p5-verify3- prefix. No GitHub LFS fetch, no adb device, no other ~/w7/p5-* worktree touched.


The unperturbed baselines, green first

Unit lane — cd ~/w7/p5-verify/build-split && ctest -L unit -j 14 (~/w7/p5-verify3-baseline-unit.log):

100% tests passed, 0 tests failed out of 2025
UNIT_RC=0

Integration-split, with the init patch — ctest -L integration-split -j 8 (~/w7/p5-verify3-isplit-inproc.log):

67% tests passed, 7 tests failed out of 21
The following tests FAILED:
	3161 - DirectGLES.Split.PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw (Subprocess aborted)
	3162 - DirectGLES.Split.PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw (Subprocess aborted)
	3163 - DirectGLES.Split.PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares (Subprocess aborted)
	3164 - DirectGLES.Split.PersistentMapArm.PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares (Subprocess aborted)
	3172 - DirectGLES.Split.SmallRing.PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw (Subprocess aborted)
	3173 - DirectGLES.Split.SmallRing.PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw (Subprocess aborted)
	3174 - DirectGLES.Split.SmallRing.PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares (Subprocess aborted)

c1-v2.md §6's 14 / 21 reproduces exactly, and the seven are exactly the seven it names. Probed with MOBILEGL_LOG_FILE_PATH, entry 3162's own diagnostic is c1-v2.md §6's, verbatim:

[Linux mgl-srv-apply/FATAL]: MGPipe: Fatal{ProtocolCorruption} resource_flush_range {slot=1, gen=0, glName=1}: a non-empty flush carries no bytes (offset=0, size=120, storage=120 bytes)

Finding 2 — a pack-PBO offset is used as a client CPU destination — CONFIRMED (blocker)

ID-57 already rules the P5 behaviour (refuse by name). The job here was to confirm that this head dereferences the offset. It does, and the proof is a SIGSEGV rather than an inference.

Source. EmitReadPixels has no PBO branch at all. MobileGL/MG_Remote/Client/EmitTables.cpp:

291:            info.DstOffset = 0;
292:            info.DstSize = tight;
322:                                    pixels, tight, &status);      // the tight fast path
331:                                bounce.data(), tight, &status);   // the bounce path

info.DstOffset is the literal 0 on every path, so the server never learns the PBO offset; the GL pixels argument is handed to ClientSession::EmitAndWait as replyOut, and EmitAndWait memcpys the reply into it. The frontend permits the offset: GL_Framebuffer.cpp:3055-3078 checks only that the PBO is not non-persistently mapped and that pixels is aligned to GetTexturePixelDataTypeSize(type) — 1 byte for GL_UNSIGNED_BYTE, so offset 16 passes.

Command. python3 ~/w7/p5-verify3-f2.py and the monolith arm in ~/w7/p5-verify3-f6-f4c.py. The probe (temporary TEST_F in the Split lane's ClearThenReadPixelsScenario, P.F2_CASE): clear to (0.25, 0.5, 0.75, 1.0), bind a 64-byte GL_PIXEL_PACK_BUFFER, then glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void*)16).

Unperturbed control — the scaffolding alone, existing case, inproc + init patch:

--- run --gtest_filter=ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels  => rc=0 ---
[  PASSED  ] 1 test.

Split (inproc), the offset-16 read — rc = -11 (SIGSEGV):

--- run --gtest_filter=ClearThenReadPixelsScenario.VerifyF2PackPboOffsetIsNotACpuDestination  => rc=-11 ---
[ RUN      ] ClearThenReadPixelsScenario.VerifyF2PackPboOffsetIsNotACpuDestination
F2: probeLive=1
F2: 64-byte GL_PIXEL_PACK_BUFFER bound, glError=0
F2: about to glReadPixels(0,0,1,1,RGBA,UNSIGNED_BYTE, (void*)16)

The process never reaches the next line (F2: RETURNED from glReadPixels). The reply's four bytes were written to CPU address 16. No Fatal{UnmigratedVerb, "ReadPixels+PACK_BUFFER"} and no other named refusal — ID-57's required diagnostic does not exist on this head.

Monolith control, the identical call (MOBILEGL_TRANSPORT=monolith, no MGITEST_SPLIT_LANE):

--- run --gtest_filter=ClearThenReadPixelsScenario.VerifyF2PackPboOffsetIsNotACpuDestination  => rc=0 ---
[       OK ] ClearThenReadPixelsScenario.VerifyF2PackPboOffsetIsNotACpuDestination (2 ms)
F2: probeLive=0
F2: RETURNED from glReadPixels; glError=0
F2: PBO[16..19] = 40 80 bf ff (0xEE = untouched)

40 80 bf ff is the cleared colour (64, 128, 191, 255) at PBO offset 16. So the monolith arm is correct today and the split arm dereferences the offset — precisely ID-57's premise.

Minimal fix shape. In EmitReadPixels, before RequireReadPixelsReplyFits and before any use of pixels: if MG_State::pGLContext reports a bound BufferTarget::PixelPack, take R-4's class-C refusal — Fatal{UnmigratedVerb, "ReadPixels+PACK_BUFFER"} — under MG_Config::Transport != Monolith only, so the monolith path is byte-identical (G2/G14). Red-once control. ID-57's own: a bound 64-byte pack PBO and the offset-16 read under inproc must die with that string (assert it from a private MOBILEGL_LOG_FILE_PATH, see finding 7), and the same call under monolith must still read back 40 80 bf ff at offset 16 through glGetBufferSubData. Delete the refusal and the inproc half must SIGSEGV again.


Finding 4 — Stop installs driver-reaching adapters while the transport is still active — CONFIRMED (major)

Source. MobileGL/MG_Remote/Client/WireTables.cpp:487-493:

    void UninstallClientWireTables() {
        // PUTS THE MONOLITH ARM BACK rather than nulling the rows. ...
        MG_Pipe::MGPipeInstallMonolithTables();
    }

No transport, role or session guard of any kind. ClientSession::Stop() calls it as its first statement, before m_started, g_active, the server, the applier, the rings or the transports go away.

Command. python3 ~/w7/p5-verify3-f4-f9b-f12.py and ~/w7/p5-verify3-f6-f4c.py (the F4c variant), inproc + init patch, probe P.F4C_CASE.

First attempt (glBufferData with data) aborted at rc = -6, and the diagnostic — readable only because the probe set MOBILEGL_LOG_FILE_PATH — was not a refusal of the forbidden path:

[Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{InitialBytesNotCarried, "resource_respecify"} - the respecify crossed with initialBytes = nullptr (R-13.3) and the resource_subdata records that were supposed to follow it emitted NOTHING, so 16 bytes of initial content exist on no side of the wire

That is c1's own content self-check firing by accident: the split-only follow-up walk still runs (it is gated on Transport != Monolith, not on which table is installed), its ResourceSubData records now go to the monolith adapter, so ClientWireRecordsEmitted() does not move. It fires only for a respecify that carries initial bytes.

The decisive run uses mutations that carry none (glBufferData(..., nullptr, ...) then glDeleteBuffers), so the numbers can be read:

--- run --gtest_filter=ClearThenReadPixelsScenario.VerifyF4cUninstallThenAMutationWithNoInitialBytes  => rc=0 ---
[       OK ] ClearThenReadPixelsScenario.VerifyF4cUninstallThenAMutationWithNoInitialBytes (0 ms)
[  PASSED  ] 1 test.
F4c: BEFORE uninstall wireRecords=15 emitSeq=15
F4c: Uninstall returned; sessionActive=1
F4c: AFTER  uninstall wireRecords=15 emitSeq=15
F4c: VERDICT wireOrdinalMoved=0 emitSeqMoved=0 survivedWithNoRefusal=1

sessionActive=1 — the session, the server and its applier are all still live. The wire ordinal did not move; MGPipeApply* ran on the calling GL thread; the test passed. That is exactly the forbidden path, taken silently. Finding 9's part 2 (below) is the same effect from the other direction: a glDeleteBuffers through the monolith adapter, delta 0, everything green.

The failed-Start → Stop half — CONFIRMED at source. ClientSession::Stop() (:578-586) calls UninstallClientWireTables() before if (!m_started) { ... }, so every one of Start's failure paths leaves the process with monolith adapters installed while MG_Config::Transport is still inproc. The resulting table state is byte-for-byte the state F4c measured, and the split-only follow-up walks keep running against it. No separate runtime probe was built: forcing a Start failure needs a transport fault injector this head does not have.

Minimal fix shape. UninstallClientWireTables() should install a teardown table, not the monolith one: every row a named Fatal{SessionTornDown, "<row>"} (R-4's class-C shape) under Transport != Monolith, and MGPipeInstallMonolithTables() only when the transport really is monolith. That keeps the "not a null row" property c1 wanted while refusing rather than executing. Red-once control. F4c's own probe, asserted: after UninstallClientWireTables() on a live session, one routed resource mutation must die naming SessionTornDown; deleting the guard must turn it back into wireOrdinalMoved=0 … PASSED.


Finding 5 — the two acceptance escapes convert ERROR into an ordinary decline — CONFIRMED (major)

Source. The two escapes read status straight out of EmitAndWait and never mint or take a reply slot. MobileGL/MG_Remote/Client/WireTables.cpp:

// Wire_Escape_ResourceRespecify
            if (status == 1) ++g_declined;
            return status == 0;                 // Status 2 (ERROR) -> false, same as DECLINED

// Wire_Escape_MapPersistent
            if (status == 0) { MGLOG_F("... Fatal{UnexpectedMapAccept ...}"); std::abort(); }
            return nullptr;                     // Status 2 (ERROR) -> nullptr, same as DECLINED

EmitAndWait itself only logs ERROR (MGLOG_E("... answered ERROR"), ClientSession.cpp:773) and returns. Fatal{ReplyError} exists in exactly two production places, both in the mailbox the generated rows use — MG_Pipe/PipeRoute.cpp:137 (MGPipeTakeReplyBool) and :151 (MGPipeTakeReplyPointer) — and the escapes reach neither.

Command. python3 ~/w7/p5-verify3-f5-f10b-f11.py, inproc + init patch, each perturbation posting the correct sequence with ReplySink::kStatusError.

(a) ResourceRespecify answered ERROR — PipeWireCodec.cpp, the respecify case, PostReply(op, seq, ReplySink::kStatusError, nullptr, 0) in place of noteAcceptance(...):

--- run --gtest_filter=TriangleScenario.AVboBackedTriangleReachesReadPixels  => rc=0 ---
[  PASSED  ] 1 test.
---- F5a ResourceRespecify=ERROR : Fatal/ERROR lines ----
   (NO 'Fatal{' line at all)
   ReplyError present: False

(b) MapPersistent answered ERROR — same file, kStatusDeclined → kStatusError:

--- run --gtest_filter=PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares  => rc=-6 ---
   [Linux mgl-srv-apply/FATAL]: MGPipe: Fatal{ProtocolCorruption} resource_flush_range {slot=1, gen=0, glName=1}: a non-empty flush carries no bytes (offset=0, size=120, storage=120 bytes)
   ReplyError present: False

The abort is the pre-existing flush seam, byte-identical to the unperturbed baseline above. ERROR produced no observable difference at all from DECLINED.

(c) the comparison the claim makes — a GENERATED acceptance row answered ERROR (noteAcceptance posts kStatusError):

--- run --gtest_filter=TriangleScenario.AVboBackedTriangleReachesReadPixels  => rc=1 ---
[  FAILED  ] TriangleScenario.AVboBackedTriangleReachesReadPixels
   [Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{ReplyError, "resource_create"} - the row answered ERROR, which is not an acceptance answer; folding it into accepted or refused would make a transport fault look like a resource decision
   ReplyError present: True

So the review's claim is exact: the generated wrappers abort, the two escapes decline.

Minimal fix shape. Give both escapes the mailbox's rule rather than a copy of it: after EmitAndWait, if (status == 2) { MGLOG_F("MGPipe: Fatal{ReplyError, \"resource_respecify\"} …"); std::abort(); } (and "map_persistent"). Better still, route them through MGPipeTakeReplyBool/MGPipeTakeReplyPointer by minting a slot and posting the wire status into it, the way Wire_ResourceCreate already does — one mechanism, not two. Red-once control. Perturbations (a) and (b) as executed, each asserting Fatal{ReplyError, "<row>"} from a private log file; deleting the new check must make the Triangle entry pass again (a) and leave (b) indistinguishable from the flush-seam abort.


Finding 6 — ReadPixels incorrectly applies PACK_SKIP_IMAGES — CONFIRMED (major)

Source. EmitTables.cpp:595-621, and the comment states the behaviour as deliberate:

        // SKIP_IMAGES is in the parameter set and is meaningless for a 2D read, so it is
        // applied as GL defines it (whole images of ROW_LENGTH x IMAGE_HEIGHT) rather than
        // ignored ...
        auto* out = static_cast<Uint8*>(destination) +
                    static_cast<Uint64>(pack.SkipImages) * imageRows * strideBytes + ...

and ReadbackPackStateIsTight (:97-104) rejects the fast path on pack.SkipImages != 0. The monolith conversion path is the opposite: DirectGLES.cpp:10904 passes /*honorPackImageParams=*/false.

Command. python3 ~/w7/p5-verify3-f6-f4c.py (unit; no init patch). The review's exact probe — SkipImages=1 on an otherwise neutral pack state, 4×3 RGBA8, 96-byte sentinel destination — added as a temporary case in MG_Test/Wire/RemoteClientTest.cpp driving the exported ScatterTightReadbackIntoPackState and ReadbackPackStateIsTightForTest, i.e. the functions the emitter itself calls.

Unperturbed: ctest-equivalent RemoteClientTest --gtest_filter=RemoteReadback.* → rc=0, [ PASSED ] 4 tests.

With the case added:

--- run --gtest_filter=*VerifyF6SkipImagesOnATwoDimensionalRead*  => rc=1 ---
F6: ReadbackPackStateIsTight = 0 (0 => the SCATTER runs)
F6: destination bytes touched = 48, first = 48, last = 95
[  FAILED  ] RemoteReadback.VerifyF6SkipImagesOnATwoDimensionalRead

Bytes 48–95 receive the reply; bytes 0–47 keep their sentinel — exactly the claim. An application that supplied the 48-byte destination GL requires is overrun by 48 bytes. Re-run over the whole suite: RemoteReadback.* → 4 PASSED, this one FAILED — the four existing cases are blind to it.

Minimal fix shape. Drop SkipImages/ImageHeight from the scatter's destination arithmetic and from ReadbackPackStateIsTight's rejection list — one term in out and one clause in the predicate — matching honorPackImageParams=false. Red-once control. The case above as written (require bytes 0–47 to hold the reply and 48–95 the sentinel); putting the SkipImages term back must turn it red, and TheFastPathIsTakenExactlyWhenTheScatterWouldChangeNothing must be extended to drive the predicate with SkipImages=1 so the two halves stay coupled.


Finding 7 — R-1's assertion is inert on this head and checks too late even after the bracket — CONFIRMED (major)

(i) Inert on this head

$ cd ~/w7/p5-verify && git grep -nE 'ScopedApplierEntry|NoteApplyThreadEnteredApplier|ApplyThreadIsInsideApplier' 41992649 -- MobileGL
41992649:MobileGL/MG_Remote/CONTRACT-P5.md:342: ... (the contract's prose)
41992649:MobileGL/MG_Remote/Client/ClientSession.cpp:692:        if (ApplyThreadIsInsideApplier()) {
41992649:MobileGL/MG_Remote/Client/ClientSession.cpp:801:    Bool ClientSession::ApplyThreadIsInsideApplier() {
41992649:MobileGL/MG_Remote/Client/ClientSession.cpp:804:    void ClientSession::NoteApplyThreadEnteredApplier() {
41992649:MobileGL/MG_Remote/Client/ClientSession.h:114:        static Bool ApplyThreadIsInsideApplier();
41992649:MobileGL/MG_Remote/Client/ClientSession.h:123-130: (the declarations and ScopedApplierEntry itself)

Every hit is a declaration, a definition, or the single consumer. ScopedApplierEntry has no use anywhere outside its own definition, and no production applier is bracketed. PipeApplier::ApplyOne (:295-325) calls StampVerbBoundary and LeaveApplier(), and LeaveApplier() is MG_Pipe::MGPipeServerClearVerbBoundary() (:342) — p1's verb-boundary flag, a different flag from g_applyThreadInsideApplier. So ApplyThreadIsInsideApplier() is permanently false and the check at :692 never fires.

The check itself works — it is only never armed. Raising the flag by hand on the head as committed:

--- run --gtest_filter=...VerifyF7aTheFlagIsUpAtEmission  => rc=-6 ---
F7a: flag before = 0
F7a: flag raised = 1; now emitting a verb...
   [Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{BarrierViolation, "ResourceRespecify"} - the apply thread is inside the applier while the GL thread is emitting. ...

(ii) The placement claim, with the bracket applied

The bracket hunk from ~/w7/p5-v1-joint-seam.diff (the PipeApplier.cpp #include plus const Client::ClientSession::ScopedApplierEntry insideApplier; at the top of ApplyOne) was applied locally. Command: python3 ~/w7/p5-verify3-f7b.py.

With the bracket in place and the flag up at emission, the check fires as before (Fatal{BarrierViolation, "ResourceRespecify"}, rc=-6). With the flag up during the residual-fill window and down again before emission — the exact ordering the review describes, made deterministic:

--- run --gtest_filter=...VerifyF7bTheFlagWasUpDuringTheFillAndDownAtEmission  => rc=0 ---
F7b: flag UP during the residual-fill window = 1
F7b: flag DOWN before emission = 0; now emitting...
F7b: the emission-time check did NOT fire - a fill that raced the applier and finished before EmitAndWait is unobserved
[  PASSED  ] 1 test.
---- F7 (iii) bracket + flag down at emission : Fatal lines ----
   (NO 'Fatal{' line at all)

MGP_FILL(ReadPixels) is at MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp:3097, one line before the table call at :3098, so a real racing fill lands inside exactly that window. The only check is at ClientSession.cpp:692, inside EmitAndWait, which the emitter reaches afterwards.

PARTIAL on one sub-point: no two-thread harness was built that blocks a real applier mid-apply while the GL thread fills. The raise/lower sandwich reproduces the ordering deterministically but with the flag driven by the test, not by PipeApplier::ApplyOne. Everything else is CONFIRMED.

(iii) The bracket is safe to add (R-17.3): with it applied, the lane stays green — ClearThenReadPixelsScenario.* → 5 PASSED, TriangleScenario.* → 2 PASSED, no Fatal{.

(iv) The log-destination sub-claim — CONFIRMED. MGL_ITEST_GLES_SPLIT_ENVIRONMENT (MG_IntegrationTest/CMakeLists.txt:1854-1857, used by all three DirectGLES.Split. gtest_discover_tests blocks at :1914, :1923, :1932) carries MOBILEGL_BACKEND_TYPE, MOBILEGL_TRANSPORT, MOBILEGL_IPC_SERVER_PATH, MGITEST_SPLIT_LANE and the capability/common env — and no MOBILEGL_LOG_FILE_PATH, although fourteen other lanes in the same file have one. Observed throughout this verification: every split-lane abort printed nothing to stderr; every Fatal{...} quoted in this document was readable only because the probe set the variable itself. ID-53 ruling (1) has not landed for these lanes.

Minimal fix shape. (a) Land the ScopedApplierEntry bracket (v1's file, the integrator's at the merge). (b) Move the check to the residual write: an MGP_FILL-side assertion — either inside MGPipeInputsBeginFill or a ClientSession::RequireApplierNotInside("<verb>") called from MGP_FILL — so the flag is read where gPipeInputs is actually written, keeping the EmitAndWait check as a second line. (c) Give every DirectGLES.Split.* entry its own MOBILEGL_LOG_FILE_PATH per ID-53. Red-once control. Delete the bracket → the arming case must stop firing; keep the bracket but move the check back to emission only → the fill-window case must go from red to green. Both are executable with the raise/lower probe above.


Finding 8 — "20 / 20 RED" does not establish twenty failures for their own reasons — CONFIRMED (major)

Commands. python3 ~/w7/p5-verify3-f8-patch.py && python3 ~/w7/p5-verify3-f8-redcheck-copy.py — a COPY of ~/w7/p5-c1-r2-redcheck.py with ROOT pointed at ~/w7/p5-verify and run() returning ("UNRELATED_FAILURE", 1) for every case, exactly as proposed. build() was also stubbed to (True, "") so that no case could be scored red through the BUILD-BREAK (also a red) arm instead of through the verdict predicate; the review itself notes no project build is needed. The edit/restore machinery ran for real and the worktree was verified clean afterwards.

preflight: all five targets build clean before any control runs
RED   R1 the install really fills the escape table
RED   R2 the install is reachable from a header, not an orphan .o
RED   R3 a missing answer Fatals rather than defaulting
RED   R4 a missing answer is not silently false
RED   R5 two outstanding answers are a barrier fault
RED   R6 ERROR is not folded into an acceptance answer
RED   R7 DECLINED is false and is COUNTED
RED   R8 DECLINED is not folded into accepted
RED   ID47-a the boundary is the pool's cap, not 'any pool at all'
RED   ID47-b the emitter really asks the helper, with its own number
RED   ID49-a DstSize is the TIGHT extent, not the packed one
RED   ID49-b the scatter honours SKIP_ROWS / SKIP_PIXELS
RED   ID49-c the scatter writes the ROW, never the whole stride
RED   ID49-d the neutral-pack fast path really equals the scatter
RED   ID31 the acceptance answer really rides the slot
RED   ID31-b the slot's status agrees with the applier's answer
RED   R8 the liveness gate reads the mirror, not the op table
RED   R17 the role gate keeps the apply thread off the wire
RED   v1-seam m_started is set before g_active
RED   R13.3 the respecify's bytes really follow as sub-data
--- restoring
CONTROLS_THAT_DID_NOT_GO_RED=none
P5_C1_R2_REDCHECK_DONE
SCRIPT_EXIT_CODE=0

All twenty controls scored RED on a stubbed runner that never ran anything, and the harness reported its headline result, CONTROLS_THAT_DID_NOT_GO_RED=none. The predicate is red = rc != 0 or "[ FAILED ]" in out or "PASSED ] 0 tests" in out, plus BUILD-BREAK and TimeoutExpired — no case asserts its own diagnostic.

Second half — "does the script exit non-zero when failures is non-empty?" No. python3 ~/w7/p5-verify3-f8b-patch.py && python3 ~/w7/p5-verify3-f8b-redcheck-copy.py, with run() returning ("[ PASSED ] 20 tests", 0) so every case scores STILL GREEN:

CONTROLS_THAT_DID_NOT_GO_RED=['R1 the install really fills the escape table', 'R2 ...', ... all twenty ...]
P5_C1_R2_REDCHECK_DONE
SCRIPT_EXIT_CODE=0

Twenty listed failures and exit code 0. There is no sys.exit after the final print. The restore loop also excludes ITEST (for target, binary in {PCT, RCT, PWC, SAN}) and only prints its results.

Minimal fix shape. Add a per-case expect string to the CASES tuples and make the verdict red = (rc != 0 or "[ FAILED ]" in out) and expect in out; drop the bare-rc != 0 and BUILD-BREAK arms from "red" (a build break is a harness failure, not a control going red); include ITEST in the restore loop; and end with sys.exit(1 if failures else 0). Red-once control. The two runs above, kept as the harness's own self-test: stub run() to an unrelated failure and the script must report every case as NOT red and exit non-zero.


Finding 9 — the 33+4 catalogue test cannot detect one missing client-wire installation — CONFIRMED (major)

Source. MG_Test/Pipe/PipeCatalogueTest.cpp:150-196 calls MGPipeInstallMonolithTables() itself and counts gMGPipeScreen / gMGPipeContext / gMGPipeRouteEscapes. It never calls InstallClientWireTables(), so nothing in it can observe that table at all.

Command. python3 ~/w7/p5-verify3-f9-f10a.py (unit) and ~/w7/p5-verify3-f4-f9b-f12.py (integration). Perturbation: delete only gMGPipeScreen.ResourceDestroy = &Wire_ResourceDestroy; from InstallClientWireTables.

Unperturbed: PipeCatalogueTest --gtest_filter=* → rc=0, [ PASSED ] 32 tests.

Perturbed:

--- run --gtest_filter=*ExactlyTheRoutedRowsAreInstalledAndTheRestAreStillNull*  => rc=0 ---
[       OK ] PipeCatalogue.ExactlyTheRoutedRowsAreInstalledAndTheRestAreStillNull (0 ms)
[  PASSED  ] 1 test.
--- run --gtest_filter=*  => rc=0 ---
[  PASSED  ] 32 tests.

Green, unchanged, whole suite included.

Part 2 — does anything notice at runtime? With the same deletion still in place, the init patch applied, and a split entry that destroys a resource:

--- run --gtest_filter=ClearThenReadPixelsScenario.VerifyF9bADestroyedResourceWithTheRowDeleted  => rc=0 ---
[  PASSED  ] 1 test.
F9b: destroy: wireRecords 16 -> 16 (delta 0), emitSeq 16 -> 16 (delta 0)
F9b: VERDICT destroyReachedTheWire=0
--- run --gtest_filter=ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels  => rc=0 --- [  PASSED  ] 1 test.
--- run --gtest_filter=TriangleScenario.*  => rc=0 --- [  PASSED  ] 2 tests.

Control, same probe, row still installed:

F9b: destroy: wireRecords 16 -> 17 (delta 1), emitSeq 16 -> 17 (delta 1)
F9b: VERDICT destroyReachedTheWire=1

So the deletion is a clean, silent, fully green regression: the destroy runs the monolith applier on the GL thread, no record reaches the wire, and every lane entry still passes.

Minimal fix shape. Give PipeCatalogueTest a case that calls InstallClientWireTables() and asserts, row by row, that each of the 33 + 4 pointers differs from the monolith table's — or, the cheaper and stronger form the review asks for, a control that invokes the row through the installed split table and requires ClientWireRecordsEmitted() to advance and the opcode to appear on the wire. ClientWireRecordsEmitted() is read by no test at this head (confirmed by grep); the F9b probe above is that control, ready to be asserted. Red-once control. Delete any one assignment in InstallClientWireTables → the per-row comparison must name that row, and the destroy probe's destroyReachedTheWire must go 1 → 0.


Finding 10 — the readback red-checks miss deletion of the mechanisms they protect — CONFIRMED (major), both halves

(a) The tight-size test does not observe production

Command. python3 ~/w7/p5-verify3-f9-f10a.py (unit). Perturbation: production EmitTables.cpp:292, info.DstSize = tight; → info.DstSize = tight + 16;.

Unperturbed: RemoteReadback.* → rc=0, [ PASSED ] 4 tests.

Perturbed:

--- run --gtest_filter=*DstSizeIsTheTightExtentAndNeverThePackedOne*  => rc=0 ---
[       OK ] RemoteReadback.DstSizeIsTheTightExtentAndNeverThePackedOne (0 ms)
[  PASSED  ] 1 test.
--- run --gtest_filter=RemoteReadback.*  => rc=0 ---
[  PASSED  ] 4 tests.

The named case stays green with the emitted DstSize 16 bytes wrong, because it only exercises TightReadbackByteCount, the test-facing wrapper; production multiplies width × height × bpp independently at :290-292. ID49-a's reported red therefore proves nothing about the emitted value.

(b) The capacity perturbation cannot detect deletion of the pre-check

Command. python3 ~/w7/p5-verify3-f5-f10b-f11.py, inproc + init patch. Perturbation: delete only the production session.RequireReadPixelsReplyFits(...) call (EmitTables.cpp:304-307).

--- run --gtest_filter=ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels  => rc=0 ---
[  PASSED  ] 1 test.
--- run --gtest_filter=ClearThenReadPixelsScenario.*  => rc=0 --- [  PASSED  ] 5 tests.
--- run --gtest_filter=TriangleScenario.*  => rc=0 --- [  PASSED  ] 2 tests.
---- F10b : Fatal lines ----  (NO 'Fatal{' line at all)

ID47-b's named scenario — ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels — is a small read that fits the pool, so with the call gone it simply passes. The perturbation ID47-b actually performs (tight * 1000) only proves the helper is reachable when it is called.

Minimal fix shape. Replace ID49-a's mutation with the production one (info.DstSize = tight + 16) and give DstSizeIsTheTightExtentAndNeverThePackedOne a way to read the emitted record's DstSize — a test-visible last-record peek on the encoder, or the existing wire decode path — so the test observes what crossed rather than a helper. For (b), add the control the review names: an oversized emission attempt (a read whose tight extent exceeds MaxReplyBytes) through the installed split table, requiring Fatal{ReplyTooLarge, "ReadPixels …"} before the record ordinal advances; deleting the call must then leave the read unrefused. Red-once control. Exactly the two perturbations executed here: tight + 16 must turn the tight-size case red, and deleting RequireReadPixelsReplyFits must turn the oversized-emission case red. Both are green today.


Finding 11 — short successful replies and failed reads become plausible pixels — CONFIRMED (major)

Source. ClientSession::EmitAndWait checks only for an oversized reply (if (replyOut != nullptr && replySize > replyBytes) … Fatal{ReplyTooLarge}, :781-787). There is no minimum-extent check, and EmitReadPixels passes &status but never inspects it (EmitTables.cpp:313-333).

Command. python3 ~/w7/p5-verify3-f11n.py, inproc + init patch. The server sink perturbed at MG_Remote/Server/PipeApplier.cpp:199, keeping the same sequence. The probe is a 4×3 RGBA8 read into a 0xCD-filled destination after a clear to (0.25, 0.5, 0.75, 1.0).

Why neutral pack state. The review's non-neutral variant cannot isolate finding 11 on this head: with ROW_LENGTH=8, SKIP_ROWS=1, SKIP_PIXELS=2 the unperturbed control already returns zeros and dies -11, because the server half of ID-49 is absent (review blocker 1, v1's) and the backend honours the client's pack state into a tight scratch. Measured, see §D. The neutral read takes the emitter's zero-copy fast path — the reply lands straight in the application's pointer — so only the reply's extent and status vary.

Unperturbed control:

--- run ...VerifyF11nAShortReplyOnTheTightPath  => rc=0 ---  [  PASSED  ] 1 test.
F11n: row 0 bytes  0.. 3 = 40 80 bf ff
F11n: row 1 bytes 16..19 = 40 80 bf ff
F11n: row 2 bytes 32..35 = 40 80 bf ff
F11n: of the 48 destination bytes, 0 are still the sentinel 0xCD

Perturbed — Status=OK with info.DstSize - oneRowBytes, same sequence:

--- run ...VerifyF11nAShortReplyOnTheTightPath  => rc=0 ---  [  PASSED  ] 1 test.
F11n: row 0 bytes  0.. 3 = 40 80 bf ff
F11n: row 1 bytes 16..19 = 40 80 bf ff
F11n: row 2 bytes 32..35 = cd cd cd cd
F11n: of the 48 destination bytes, 16 are still the sentinel 0xCD
---- F11n short OK reply : Fatal lines ----  (NO 'Fatal{' line at all - no named refusal)

The application receives its own stale bytes as the third row of pixels, the call returns normally, glGetError() is 0 and the test passes.

Perturbed — Status=DECLINED, zero payload, same sequence:

--- run ... => rc=0 ---  [  PASSED  ] 1 test.
F11n: row 0 bytes  0.. 3 = cd cd cd cd
F11n: row 1 bytes 16..19 = cd cd cd cd
F11n: row 2 bytes 32..35 = cd cd cd cd
F11n: of the 48 destination bytes, 48 are still the sentinel 0xCD
(NO 'Fatal{' line at all - no named refusal)

Perturbed — Status=ERROR, zero payload, same sequence: identical output, 48/48 sentinel, rc=0, [ PASSED ] 1 test., no Fatal. The ReadPixels status is ignored entirely.

Minimal fix shape. Two lines, both in ClientSession::EmitAndWait's reply block: require replySize == replyBytes for a reply-owning row that offered a destination — Fatal{ReplyShort, "<row>"} — and refuse to deliver on a non-OK status for ReadPixels; plus, in EmitReadPixels, branch on status before scattering or returning. The exact-extent rule is CONTRACT §2 row 23's own ("never truncated"). Red-once control. The three perturbations executed here, each asserting its own diagnostic from a private log file and asserting the destination is untouched; removing the extent check must restore 16 of 48 stale, PASSED.


Finding 12 — a repeated successful MakeEGLCurrent does not adopt its new caps — CONFIRMED (major)

Source. Server::ServerMakeEGLCurrent (MG_Remote/Server/ServerLoop.cpp:618-628) republishes a snapshot on every call once the session is accepted. BackendObject_Remote::MakeEGLCurrent (BackendObject_Remote.cpp:206-213) forwards and then calls the base, and MG_Backend::BackendObject::MakeEGLCurrent (BackendObject.cpp:341-347) calls InitCapabilities() only if (!m_backendCapabilitiesInitialized). BackendObject_Remote::InitCapabilities (:106-140) is the only thing on that path that calls session->PumpControlPlane().

Command. python3 ~/w7/p5-verify3-f4-f9b-f12.py, inproc + init patch. The probe repeats eglMakeCurrent on the already-initialised surface and reads the mirror generation and a public cap getter with no PumpControlPlane and no Present.

--- run ...VerifyF12RepeatedMakeCurrentAdoptsItsSnapshot  => rc=1 ---
F12: BEFORE repeat  mirrorGeneration=3 GL_MAX_TEXTURE_SIZE=16384
F12: AFTER  repeat   ok=1 mirrorGeneration=3 GL_MAX_TEXTURE_SIZE=16384  (NO PumpControlPlane, NO Present)
F12: EXPLICIT PumpControlPlane() adopted=1 mirrorGeneration=4
F12: VERDICT repeatAdoptedIt=0 snapshotWasWaiting=1
F12: after TWO more repeats gen=4, then pump adopted=2 gen=6

The make-current succeeded (ok=1), a snapshot was published (the explicit pump adopted exactly one and moved the generation 3 → 4), and neither the mirror generation nor the public GL_MAX_TEXTURE_SIZE moved at the time of the call. The accumulation half is confirmed too: two further repeats leave the generation at 4 and the next pump adopts 2 at once (4 → 6).

(The gtest verdict rc=1 is the Split fixture's own arming assertion in TearDown — this probe emits no wire records, so EmitSeq does not move. It is not a failure of the measurement; the numbers above are the result.)

Minimal fix shape. In BackendObject_Remote::MakeEGLCurrent, after the base call succeeds and when the surface was already initialised, adopt what the forwarder just published — a session->PumpControlPlane() plus RefreshFormatCapabilities(), i.e. the tail of InitCapabilities() factored out — so that "a second CapsSnapshot arrival IS the invalidation" (c0's R-12 ruling) holds at the make-current that caused it. Red-once control. The probe above, asserted: mirrorGeneration must increase across a repeated successful make-current and a following explicit pump must adopt 0. Removing the new pump must restore repeatAdoptedIt=0 snapshotWasWaiting=1.


§C. The two report discrepancies

(i) p5-c1-r2-igpu-split-mono.log says 19 failed of 1149; c1-v2.md §6 says 7 — the log is right, and §6's sentence is wrong twice over

$ sed -n '2301p' ~/w7/p5-c1-r2-igpu-split-mono.log
98% tests passed, 19 tests failed out of 1149

The failure list (:2504-2523) is nineteen entries, every one of them a DirectGLES.Split.* entry, each labelled integration-gpu integration-split. The two Split entries that are not in it are #3157 and #3168, the two AMultisampleResolveBlitIntoTheDefaultFramebufferKeepsItsOrientation cases, which passed. The label summary in the same log confirms the overlap:

integration-gpu      = 323.60 sec*proc (1149 tests)
integration-split    =   5.80 sec*proc (21 tests)

Yes, the Split. entries force inproc, and that is why they are in a monolith-labelled run. MG_IntegrationTest/CMakeLists.txt:1854-1857 builds MGL_ITEST_GLES_SPLIT_ENVIRONMENT with "MOBILEGL_TRANSPORT=inproc" and the three gtest_discover_tests blocks at :1908, :1917, :1926 attach it as a ctest ENVIRONMENT property together with LABELS "integration-gpu;integration-split". A ctest ENVIRONMENT property overrides the parent environment, so those 21 entries run inproc whatever the surrounding invocation says — and -L integration-gpu selects them because they carry that label too.

So, precisely:

  • 19 is the correct count for that log. All 19 failures are Split entries run without the init patch — which is the state c1-v2.md §6 itself describes two paragraphs earlier ("Without it the lane is 19 failed / 21 on this head").
  • The 1128 non-Split integration-gpu entries were entirely green under monolith in that run.
  • 7 is the count you get with the init patch applied, and it is a count of Split entries, not of monolith ones. Measured here: ctest -L integration-split with the init patch gives exactly 7 tests failed out of 21, the seven PersistentCoherentMapScenario entries.

§6's sentence "The same seven are the only integration-gpu failures in build-split under monolith (1149, 7 failed)" is wrong in two ways: the saved log records 19, not 7; and the failures it counts are not monolith failures at all — they are inproc Split entries that happen to share the integration-gpu label. The correct statement is: "under monolith transport the 1128 non-Split integration-gpu entries are green; the 21 Split entries force inproc and, with the init patch, seven of them fail on the resource_flush_range seam."

(ii) Is there a full inproc integration-gpu lane log for this head? — No. One was run.

~/w7/p5-c1-* contains p5-c1-r2-igpu-push.log (push build), p5-c1-r2-igpu-split-mono.log (build-split, monolith invocation, the log above) and p5-c1-r2-isplit-inproc.log (the 21-entry integration-split lane only). No full inproc integration-gpu log exists, confirming the review's "what I could not verify" note. It was therefore run once — see §C-census below.


§C-census. The full inproc integration-gpu lane, run once

$ cd ~/w7/p5-verify/build-split          # init patch applied locally
$ MOBILEGL_TRANSPORT=inproc ctest -L integration-gpu -j 8
49% tests passed, 583 tests failed out of 1149      (40 s wall, ctest rc=8)

Log: ~/w7/p5-verify3-igpu-inproc.log. Parsed by ~/w7/p5-verify3-census.py / -census2.py.

verdict count
Passed 386
Skipped 180
Subprocess aborted 558
Failed (assertion) 23
SegFault 2
Timeout 0
total 1149

Aborted + Failed + SegFault = 583 = ctest's failure count. By lane:

lane total passed skipped aborted failed / segfault
DirectGLES 526 172 72 270 10 / 2
DirectVulkan 487 144 68 265 10 / 0
DirectVulkan.HandleRecycle 72 32 32 6 2 / 0
DirectGLES.HandleRecycle 36 23 8 4 1 / 0
DirectGLES.Split 10 7 0 3 0 / 0
DirectGLES.Split.SmallRing 10 7 0 3 0 / 0
DirectVulkan.AsyncCompile 5 0 0 5 0 / 0
DirectGLES.MapPersistentRoundtrips 2 1 0 1 0 / 0
DirectGLES.Split.PersistentMapArm 1 0 0 1 0 / 0

This is the expected shape, not a regression. Under MOBILEGL_TRANSPORT=inproc every ordinary entry takes the split emit table, and BRIEF §12 C-3 rules that only six of 71 slots are implemented; the other 65 are Fatal{UnmigratedVerb}. The census is therefore mostly a measurement of the reduced path's size. The seven Split failures are the known flush seam (3 + 3 + 1 across the three Split lanes).

First failure per lane, with one probed log line (MOBILEGL_LOG_FILE_PATH set per probe, ~/w7/p5-verify3-probe.sh; note that nothing reaches stderr without it):

lane first non-passing entry its own diagnostic
DirectGLES CrossFrameBufferScenario.VertexBufferSubData MGPipe: Fatal{UnmigratedVerb, "DrawElements"}
DirectVulkan CrossFrameBufferScenario.VertexBufferSubData MGPipe: Fatal{UnmigratedVerb, "DrawElements"}
DirectVulkan.AsyncCompile XfbAfterClipDistanceScenario.SkipComponentsCaptureAlone MGPipe: Fatal{UnmigratedVerb, "BeginTransformFeedback"}
DirectGLES.HandleRecycle Handles.HandleRecycleScenario.AFramebufferAtARecycledAddressDoesNotInheritItsPredecessorsTwin MGPipe: Fatal{BlobMissing, "SetDynamicState"} - the row's decoder requires a declared blob and the call site handed over 0 bytes at 0x7ffe2d5d48a0. Under monolith the companion pointer carries them; under split they have to be staged, and there is nothing to stage
DirectGLES.Split (all three) PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw MGPipe: Fatal{ProtocolCorruption} resource_flush_range {slot=1, gen=0, glName=1}: a non-empty flush carries no bytes (offset=0, size=120, storage=120 bytes)

The Fatal{BlobMissing, "SetDynamicState"} line is the one genuinely new diagnostic the census surfaces: a kHasBlob row reaching the decoder with Size = 0 on the ordinary (non-Split) lanes under inproc. It is contract §2 table 1 row 4's known "declared real, nothing reads it" gap seen from the split side; it is not one of the twelve findings and needs an integrator ruling on ownership.

The 2 SegFaults and 23 assertion failures are worth naming because two of them are ID-49's own:

Exception: SegFault    DirectGLES.DepthStencilReadbackMatrixScenario.DepthReadbackHonoursThePackPixelStoreParameters
Exception: SegFault    DirectGLES.ForcedDepthStencilEmulation.DepthStencilReadbackMatrixScenario.DepthReadbackHonoursThePackPixelStoreParameters

These are exactly the two SEGFAULTs ID-49 cites as the shape of the missing server half.


§D. Blocker 1 (v1's) turned up while verifying finding 11 — reported, not assigned

Building finding 11's probe in the review's own non-neutral pack state (ROW_LENGTH=8, SKIP_ROWS=1, SKIP_PIXELS=2, 4×3 RGBA8) produced a broken unperturbed control:

--- F11 CONTROL (unperturbed server reply) => rc=-11 ---
F11: row 0 first pixel at byte  40 = 00 00 00 00
F11: row 1 first pixel at byte  72 = 00 00 00 00
F11: row 2 first pixel at byte 104 = 00 00 00 00

Zeros and a SIGSEGV with no perturbation at all. This is review blocker 1 (ID-56 blocker 1, v1's open half of ID-49): ServerVerbSink::OnReadPixels (PipeApplier.cpp:163-202) resizes m_readbackScratch to info.DstSize — ID-49's tight 48 bytes — and then calls the backend, which under inproc reads the client's own pack state through PackStateFromContext() and writes rows at 40, 72 and 104…119. There is no neutral-pack scope anywhere in that function. The census's two DepthReadbackHonoursThePackPixelStoreParameters SegFaults are the same defect.

It is recorded here only because it blocks any non-neutral readback verification on this head; it is v1's item and was not perturbed or fixed.


Verdict table

# finding verdict the decisive evidence
2 pack-PBO offset used as a CPU destination (blocker) CONFIRMED offset-16 read under inproc → rc=-11, never returns; same call under monolith returns PBO[16..19] = 40 80 bf ff; info.DstOffset is literal 0
4 Stop reinstalls driver-reaching adapters on a live transport CONFIRMED after UninstallClientWireTables() with sessionActive=1: wireOrdinalMoved=0 emitSeqMoved=0, test PASSED, no refusal. Failed-Start half confirmed at source
5 the two escapes turn ERROR into an ordinary decline CONFIRMED respecify ERROR → rc=0, no Fatal{; MapPersistent ERROR → indistinguishable from baseline; generated row ERROR → Fatal{ReplyError, "resource_create"}
6 PACK_SKIP_IMAGES applied to a 2-D read CONFIRMED bytes touched = 48, first = 48, last = 95 on a 96-byte destination; fast path predicate = 0
7 R-1's assertion inert, and checks too late after the bracket CONFIRMED (one sub-point PARTIAL) zero production uses of ScopedApplierEntry; with the bracket, flag up during the fill window and down at emission → check silent, PASSED. No real two-thread applier race harness
8 "20/20 RED" does not establish twenty attributed failures CONFIRMED stubbed run() → 20/20 RED, CONTROLS_THAT_DID_NOT_GO_RED=none, exit 0; all-green stub → 20 failures listed, exit 0
9 the 33+4 catalogue test cannot see a missing client-wire row CONFIRMED row deleted → PipeCatalogueTest 32/32 green; split destroy wireRecords 16→16 (delta 0) vs control 16→17, all lane entries green
10 the readback red-checks miss the mechanisms they protect CONFIRMED (a and b) DstSize = tight + 16 → named case still green; RequireReadPixelsReplyFits deleted → ID47-b's scenario + 5 + 2 entries all green
11 short / failed replies become plausible pixels CONFIRMED one row short → 16 of 48 destination bytes stale, PASSED, no Fatal; DECLINED and ERROR with zero payload → 48 of 48 stale, PASSED, no Fatal
12 a repeated MakeEGLCurrent does not adopt its new caps CONFIRMED gen 3 → 3 across a successful repeat, explicit pump adopted=1 → gen 4; two more repeats → pump adopted=2 → gen 6

Ten of ten confirmed, one with a single sub-point at PARTIAL (finding 7's true concurrent race).

For the integrator

  1. Finding 7 (c) is an ID-53 gap, not a c1 finding: MGL_ITEST_GLES_SPLIT_ENVIRONMENT sets no MOBILEGL_LOG_FILE_PATH, so every DirectGLES.Split.* abort in CI is unattributed. ID-53 ruling (1) has not landed for these three blocks. Owner unclear (t1's lane plumbing vs the joint-merge package).
  2. Fatal{BlobMissing, "SetDynamicState"} (census, DirectGLES.HandleRecycle and its family) is a kHasBlob row reaching the decoder with Size = 0 on the ordinary lanes under inproc. Not one of the twelve findings; needs an owner.
  3. Findings 5 and 11 both argue for one mechanism, not two: the escapes and EmitReadPixels should read their answers through the same mailbox rules the generated rows already obey. Worth deciding before c1's round 3 splits the fix across two files.