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.
25 KiB
s1 — round 3 (wave 1.5): the five confirmed findings, ID-47, and the CI ledger red
Branch p5/s1, one commit 949ba509 on top of the integration head ce53553c (merged first, per
ID-44; fast-forward, my round-2 head 4ba14fa4 was already an ancestor). Committer identity checked:
Swung0x48 <swung0x48@outlook.com> (ID-40). Working tree clean after the commit.
Everything in the commit is MOBILEGL_BUILD_DISAGGREGATED-only (MG_Remote/*, MG_Test/Wire/*) plus
one CONTRACT row, and G1 proves it (§7).
0. The one-line summary per item
| # | finding | what changed | red once by |
|---|---|---|---|
| 1 | ID-47 / finding 2 | SEG_REPLY 16 MiB, 8 × 2 MiB, MaxReplyBytes = 2,097,136; ReplySlotPool::CanHold + RequireReadPixelsFits (client-side named refusal); ClientSession::ReplyCanHold / RequireReadPixelsReplyFits forwarders; ProtocolSmokeTest pin (now also reads replyPool back); CONTRACT §2 row 23 |
reverting ReplyBytes to 8 MiB → TheDefaultReplyGeometryHoldsTheLargestP5Read dies in Post; bare std::abort() in RequireReadPixelsFits and < for <= in CanHold → AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName |
| 2 | finding 5 | the pad-bit case stamps kRecPad into the header itself, past Reserve's mask, plus the opposite control (a genuine filler still vanishes and does not advance appliedSeq) |
deleting && header.kind == kRingPadRecordKind in Pop → red on its own message |
| 3 | finding 6 | CapsAbiFingerprint() IS MixAbiFingerprint(CapsAbiFingerprintInputs()) — one mixer over an inputs struct; CapsCodec's second FNV loop deleted; sensitivity case moved to SessionHandshakeTest and started from the production entry point |
return 1; in CapsAbiFingerprint → red; deleting one mix(...) line → red naming the input |
| 4 | finding 7 | null-union Hello driven through ServerSession::Accept; null-union Welcome driven through ClientSession::StartOverTransportPair (Start's second half, now public); each asserts the guard's own log line |
deleting either msg_as_*() == nullptr clause → SegFault (red) |
| 5 | finding 10 | WireLogFatal (MGLOG_F + stderr echo + abort) carries every Transport Fatal; both SessionTestDeath controls name their diagnostic |
bare std::abort() in AdvanceMonotonic / in Post → "died but not with the expected error" |
| 6 | CI run 35079459114 | the ledger reads VmHWM/VmRSS in ONE pass and reports its OWN running peak (SampleRoleMemoryInto), never the kernel's verbatim |
PeakRssBytes = kernelPeakRssBytes; → red |
All eleven perturbations were executed by ~/w7/p5-s1-redcheck.sh (log ~/w7/p5-s1-redcheck.log): every
one RED for its own reason, every file restored byte-for-byte (sha256-checked), baseline green before
and after. §8 has the verbatim lines.
1. ID-47 — the reply geometry (finding 2)
What was wrong. ReplyBytes 8 MiB / 8 slots = 1 MiB slots, MaxReplyBytes() = 1,048,560. The
512×512 RGBA8 read my v1 report claimed the slot covered is 1,048,576 bytes — 16 over. E2's retrace
snapshot is a full-surface 640×480 GL_RGBA/GL_UNSIGNED_BYTE read = 1,228,800 bytes — 180,240 over.
What changed.
SessionSegmentSizes::ReplyBytes = 16 MiB(SessionRings.h),kDefaultReplySlotCountstays 8 → slots of 2 MiB,MaxReplyBytes() = 2,097,136. Canonical sizes are now 8/32/16 MiB + 256 KiB; the header comment inSessionRings.hand the geometry comment inReplySlot.hsay so and say why. No knob was added (§5 has none forSEG_REPLY, by design — ID-47 did not ask for one).ProtocolSmokeTest.WelcomeCarriesTheFourSegmentAnnouncementspins 16 MiB and now readsreplyPool()back — before this round the pin built the reply SegmentRef and never asserted on it, so a moved size would have gone unnoticed there.SessionTest.TheDefaultGeometryIsTheFourContractRingSizespins 16 MiB on the mapping and the announcement.- CONTRACT §2 row 23 (line 147, c0's file, the one row ID-47 granted): the geometry, the canonical sizes, the client-side refusal and its message, and the P6 debt. Nothing else in that file was touched.
- The helper.
ReplySlotPool::CanHold(bytes)(inclusive boundary, false on an unconfigured pool) andReplySlotPool::RequireReadPixelsFits(width, height, format, type, bytes)— returns when the answer fits, otherwiseWireLogFatalwith exactlyMGPipe: Fatal{ReplyTooLarge, "ReadPixels <w>x<h> 0x<format>/0x<type> <bytes> > <cap>"} - ...and abort.<format>is the GL enum pair the record carries (MGPReadbackInfo::Format/Type), printed as hex, e.g.ReadPixels 640x480 0x1908/0x1401 1228800 > 2097136.ClientSession::ReplyCanHoldandClientSession::RequireReadPixelsReplyFitsforward verbatim (a fifth primitive beside Encoder / Producer / WaitForApplied / ReadReply). Post's oversize refusal is unchanged in meaning and is documented as the LAST line of defence; it now goes throughWireLogFatalso it can be named by a death test (§5).
The one line c1 must add, in OnReadPixels, immediately before EmitAndWait(MGPWireOp::ReadPixels, ...):
Client::ClientSession::Active()->RequireReadPixelsReplyFits(info.Box.W, info.Box.H, info.Format, info.Type, info.DstSize);
(with whatever names c1's emitter uses for the box extent, the two enums and the byte count it computed
for DstSize; the byte count passed is what would have been posted, so what is refused is exactly that).
ReplyCanHold(bytes) is there for a caller that wants a non-fatal probe first.
Controls (R-16).
SessionTest.TheDefaultReplyGeometryHoldsTheLargestP5Read— the verifier's case, committed: a pool fromSessionSegmentSizes{}posts exactly640*480*4bytes and reads them back byte-for-byte, then512*512*4in the next slot; pinsSlotBytes()==2 MiB,MaxReplyBytes()==2097136. Red once by revertingReplyBytesto 8 MiB:Subprocess aborted(Post's oversize branch), the verifier's original outcome.SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName— the boundary pair on the DEFAULT geometry: exactly 2,097,136 bytes (524284×1 RGBA8) returns; 2,097,137 dies withFatal{ReplyTooLarge, "ReadPixels 524284x1 0x1908/0x1401 2097137 > 2097136"}; 1024×512 RGBA8 (exactly 2 MiB, sixteen over — the same sixteen-byte shape that sank the 1 MiB claim) dies with its own dimensions in the line; E2's 640×480 read returns. Red once by a barestd::abort()inRequireReadPixelsFits(regex matches nothing) and, separately, by<for<=inCanHold(the exact-cap call dies).SessionTestDeath.AReplyLargerThanItsSlotIsFatalRatherThanTruncatedis now a boundary pair at the Post level too (exactlyMaxReplyBytes()posts and reads back; +1 is the named refusal) — see §5.
The fingerprint did not move for ID-47: it mixes no segment size (§3 lists what it mixes), and the
Welcome SegmentRef cross-check in Start is what catches a geometry disagreement.
Not mine, flagged: docs/Disaggregated/ARCHITECTURE.md:422 says "SEG_REPLY … 8 MiB,4 KiB slot" —
stale before this round and stale after it; ~/w7/notes/p5/BRIEF-P5.md:742 lists "SEG_REPLY 8 MiB". ID-47
says the BRIEF/ID-file sentences change in the same commit, but ~/w7/notes is not a git repository and
those files were not in my grant, so they are the integrator's two lines to fix.
2. Finding 5 — the pad-bit case never sent the bit
RingProducer::Reserve masks kRecPad out (flags & ~kRecPad), so Reserve(7, kRecPad, 16) put flags=0
on the wire and the case was green with Pop's kind check deleted. The case now does what a codec with its
own header struct does: Reserve(7, kRecNone, 16), then stamps kRecPad into the eight header bytes
directly. ApplyOne must deliver it (seen==1, kind 7, the bit intact, appliedSeq==1), and the opposite
control follows in the same case: a header wearing kRecPad whose kind IS kRingPadRecordKind is a
genuine filler, still vanishes, and does NOT advance appliedSeq (R-9). That last assertion is what this
case adds over ID-43's RingTest.TheTwoFlagSpacesAreDisjointByTranslation, which is the same control at
the ring; this one is at the session.
Red once by deleting && header.kind == kRingPadRecordKind from RingConsumer::Pop:
SessionTest.ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller ... ***Failed on its own
message ("the record was skipped as a wrap filler because it wore bit 2 …"). Chosen over deleting the case
because the session-level half (appliedSeq counts the record, not the filler) is not stated anywhere else.
§8.2 of s1-v1.md is re-pointed here: the kind-check control is this case AND
RingTest.TheTwoFlagSpacesAreDisjointByTranslation; the v1 text that named the old case as the control
was false at the time it was written.
3. Finding 6 — the fingerprint gate tested a function with no production caller
What changed. Transport::AbiFingerprintInputs (struct, SessionRings.h) and
MixAbiFingerprint(const AbiFingerprintInputs&) (Ring.cpp) are the ONE mixer.
CapsAbiFingerprintInputs() (new, CapsCodec.h/.cpp) fills it from the real values;
CapsAbiFingerprint() is the one-liner return Transport::MixAbiFingerprint(CapsAbiFingerprintInputs());.
The hand-rolled FNV loop in CapsCodec.cpp (the second implementation) is deleted.
What the fingerprint mixes after this round (in order, FNV-1a, never 0):
sizeof(DynamicBackendParameters), sizeof(MGPCaps), sizeof(GLFunctionsTable),
kFormatCapabilityTargetCount, kFormatCapabilityFormatCount, kFormatCapabilitiesCodecVersion,
kRendererInfoCodecVersion, MGPWireOp::kOpCount (ID-33), MOBILEGL_ABI_VERSION(major, minor) (ID-33),
a presence marker for the stamp, then GIT_COMMIT_HASH_SHORT's bytes (ID-33). ID-33's inputs are all
kept. Two value-level changes versus the previous CapsAbiFingerprint: the stamp is preceded by a
presence marker (so nullptr and "" are distinct inputs — the old mixer collapsed them), and the
zero-guard. Nothing pins the value itself; both roles are one build in P5. It did not move for ID-47
(no segment size is mixed).
The case SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes (moved from
SessionTest, which cannot include CapsCodec.h without the umbrella header): (1) CapsAbiFingerprint()
is non-zero, stable, and EQUAL to MixAbiFingerprint(CapsAbiFingerprintInputs()); (2) every field of
CapsAbiFingerprintInputs() equals the real sizeof/constant (so a hard-coded input is caught); (3) each of
the ten inputs, perturbed by one on a copy of the REAL inputs, changes the answer, and nullptr ≠ "" ≠
a real stamp.
Red once by (a) Uint64 CapsAbiFingerprint() { return 1; } — the verifier's exact perturbation —
***Failed on "CapsAbiFingerprint() is not MixAbiFingerprint over CapsAbiFingerprintInputs()"; (b)
deleting mix(inputs.OpCount); from the mixer — ***Failed on "MGPWireOp::kOpCount is not mixed".
PipeWireCodecTest.TheAbiFingerprintIsStableWithinABuildAndNotZero (w1's) still passes and is untouched.
4. Finding 7 — the null-union case never reached either guard
What changed. New suite MG_Test/Wire/SessionHandshakeTest.cpp (own main() that points
MOBILEGL_LOG_FILE_PATH at a per-pid file before anything logs — PipeWireCodecTest's shape — because
Defines.h compiles the console sink out and "refusal by message" means reading the log). Registered in
Wire/CMakeLists.txt with PipeWireCodecTest's include paths.
ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced: a realInProcessTransportpair, the null-union Hello sent from the client end, aServerSessionof the case's own (the constructor is public; not the process singleton) →AcceptreturnsMOBILEGL_ERR_PROTOCOL_MISMATCH,Accepted()is false, the log delta containsMG_Remote server: the first control frame is not a verifiable Helloand noFatal{.ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced:Start()builds its transport pair itself, so no control could queue a frame ahead of the server's Welcome.ClientSession::StartOverTransportPair( clientEnd, serverEnd)is Start's second half (everything from Hello on), now public and documented as such —Start(mode, endpoint)= the mode refusal +CreatePair+ this. The case queues the null-union Welcome on the server→client direction, then calls it: Hello goes out, the singleton server'sAcceptruns FOR REAL (segments, resolver, its genuine Welcome queued behind the injected one), the client reads the injected frame first, refuses withMG_Remote client: the server's first control frame is not a verifiable Welcome, andStop()'s not-started path closes the server (Accepted()false,ServerSession::Active()null). The case also requires the server's "accepted with NO backend" line in the delta, provingStartwas driven past the point a stub would stop at.- The old
SessionTest.AVerifiableFrameCanCarryANullUnionPayloadstays as the reachability premise, renamedANullUnionFrameVerifiesWhichIsThePremiseOfBothHandshakeGuards, with a comment saying it is the premise and not the control.
Red once by deleting envelope->msg_as_Hello() == nullptr (ServerSession.cpp) →
ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced ... ***Exception: SegFault; deleting
envelope->msg_as_Welcome() == nullptr (ClientSession.cpp) →
ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced ... ***Exception: SegFault. Red by crash rather
than by message — with the clause gone the very next line dereferences the null member, which is the
defect the guard exists for; there is no message left to name.
s1-v1.md:338 corrected: the sentence "so the guard cannot be simplified away" was false when written
— the case it cited never called either handshake. After this round the two guards are protected by the
two SessionHandshakeTest cases above, which do.
5. Finding 10 — empty death regexes
Why they were empty, mechanically. Defines.h:71-72 builds the logger with MOBILEGL_LOG_ENABLE_CONSOLE 0
and the file sink on, so an MGLOG line never reaches stderr — and a gtest death test matches its regex
against the child's stderr and nothing else. There was nothing to name.
What changed. Transport::WireLogFatal(format, ...) (WireLog.h/.cpp, [[noreturn]], printf-checked):
formats once, MGLOG_F, echoes the line to stderr (flushed; abort() does not flush stdio), aborts.
AdvanceMonotonic's backwards-watermark block and all three of Post's refusals (unconfigured pool,
seq 0, oversize) go through it, as does RequireReadPixelsFits. Texts unchanged. A Fatal now also shows on
a terminal and in a CI job log, which the file-only sink never did.
AWatermarkThatMovesBackwardsIsFatalRatherThanIgnored: regexFatal\{ProtocolCorruption, "watermark"\} appliedSeq moved backwards, 10 -> 9.AReplyLargerThanItsSlotIsFatalRatherThanTruncated: regexreply pool: Fatal\{ProtocolCorruption\} - a 8177 byte answer for seq 2 does not fit a 8192 byte slot \(payload cap 8176\), and the case now posts exactlyMaxReplyBytes()first and reads it back (the boundary pair at the Post level).
Red once by replacing the WireLogFatal block in AdvanceMonotonic with (void)name; std::abort();
→ ***Failed ("Death test: … Result: died but not with expected error"); the same in Post's oversize
branch → ***Failed. Both are the verifier's perturbations, which previously left both cases green.
6. GitHub run 35079459114 — TheMemoryLedgerIsPerRoleAndIsReleasedOnClose red on CI (add-on)
Diagnosis: CONFIRMED, with the mechanism one step sharper than proposed. The kernel stores
mm->hiwater_rss only when RSS is about to DROP; task_mem() reports VmHWM = max(stored, rss-at-this-read).
Within ONE read of /proc/self/status the pair is therefore self-consistent — but the wave-1 sampler read
the two keys in TWO passes (one fopen per key), and the second fopen itself grows RSS (stdio buffer,
allocator), so the second pass's VmRSS can exceed the first pass's VmHWM. Probe (~/w7/p5-s1-probe/,
kernel 6.18.33.2-microsoft-standard-WSL2):
pass1: VmHWM=3660 VmRSS=3788 | after touching 4 MiB: VmRSS=7884 > pass1 VmHWM? YES | VmHWM re-read=7884
single-pass reads with 64 KiB growth between them: 0/1000 had VmRSS > VmHWM
— two passes disagree by 128 KiB with nothing allocated between them (exactly the CI shape: 4,784,128 <
4,849,664 is 64 KiB); one pass never disagrees. Why CI and not local: only timing — the second fopen's
first-touch pages are more often already resident locally; the race is real everywhere.
What changed (as ruled). ProcessRssBytes(&peak, ¤t) reads BOTH keys in one pass (the two old
accessors remain, implemented over it). SampleRoleMemoryInto(runningPeak, role, kernelPeak, kernelCurrent)
folds max(kernelPeak, kernelCurrent) into a caller-owned running peak (CAS loop — the GL and apply
threads both log memory at phase boundaries) and reports THAT as PeakRssBytes, so Peak >= Current
holds by construction and never decreases; SampleRoleMemory(role) = one pass + the fold into a
process-wide running peak. RoleMemory.h documents the rule and the run id. The LogRoleMemory line is
unchanged in shape (t1's grep tag MG_Remote memory[ is untouched).
Controls. The CI assertion EXPECT_GE(sample.PeakRssBytes, sample.CurrentRssBytes) stays, now true by
construction. New SessionTest.TheLedgersPeakIsItsOwnRunningMaxAndNeverTheKernelsHighWaterMarkVerbatim:
a running peak of its own, fed (peak 100, current 200) → PeakRssBytes == 200; then (150, 120) → stays
200; then (300, 100) → 300 (the kernel's peak still counts when larger); and one real
ProcessRssBytes pass on Linux is non-zero and self-consistent. Red once by reverting the fold to
sample.PeakRssBytes = kernelPeakRssBytes; → ***Failed ("the kernel's peak was reported verbatim
although its current exceeded it", 100 vs 200) — the CI line, deterministically.
7. The four self-tests (all on 949ba509; scripts ~/w7/p5-s1-gate3.sh, logs ~/w7/p5-s1-gate3-run.log, ~/w7/p5-s1-split-unit.log, ~/w7/p5-s1-split-monolith-igpu.log, ~/w7/p5-s1-igpu-push.log)
- G1 against
~/w7/p5-before-libMobileGL.so(.READY=4595163c…, the ID-44 re-take):27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed,.text 10806611 -> 10806611 (+0, +0.000%);nmof the pull library finds 0MG_Remotesymbols.check_include_closure.py: 4 probes, 0 problems.gen_pipe.py --check: up to date (no.defor generator touched). ctest -L unit: pull 1814/1814, push 1814/1814, verify 1814/1814; split 1979/1980 with exactly the ONE known red that is not mine (PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot, c1's) — 1980 = the head's 1975 + 5 (six cases added:TheDefaultReplyGeometryHoldsTheLargestP5Read,AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName,TheLedgersPeakIsItsOwnRunningMax…, and the threeSessionHandshakeTestcases; one moved out ofSessionTest). Split Wire suites under the task's regex (^Ring|^Doorbell|^Framing|^FdPassing|^InProcessTransport|^Protocol): 58/58 unchanged; with^Sessionadded: 91/91 (SessionTest30,SessionHandshakeTest3).integration-gpu: push 1128/1128; G14 vs~/w7/p5-before-ctest-names.txt(the reference gate'snames/comm): 0 removed, 40 added — the head's own P5 entries, none from this round (my cases are split-only); G2 pull-vs-push name diff 0. Split underMOBILEGL_TRANSPORT=monolith: 1149/1149.- Generators: not touched;
--checkgreen as above.
Build-harness hygiene (the verifier's C-10 note): every build ran from a script file, the generator was
confirmed Ninja from CMakeCache.txt for all three reconfigured dirs, the split configure was reused, and
p5-s1-redcheck.sh refuses to run a test when the perturbed build's rc is non-zero.
8. The red-once ledger, verbatim (~/w7/p5-s1-redcheck.log)
RESULT: RED as required (geometry-8mib) SessionTest.TheDefaultReplyGeometryHoldsTheLargestP5Read ...Subprocess aborted***Exception
RESULT: RED as required (readpixels-bare-abort) SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName ...***Failed
RESULT: RED as required (canhold-exclusive) SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName ...Subprocess aborted***Exception
RESULT: RED as required (pop-kind-check) SessionTest.ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller ...***Failed
RESULT: RED as required (fingerprint-return-1) SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes ...***Failed
RESULT: RED as required (fingerprint-drop-opcount) SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes ...***Failed
RESULT: RED as required (hello-guard) SessionHandshakeTest.ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced ...***Exception: SegFault
RESULT: RED as required (welcome-guard) SessionHandshakeTest.ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced ...***Exception: SegFault
RESULT: RED as required (watermark-bare-abort) SessionTestDeath.AWatermarkThatMovesBackwardsIsFatalRatherThanIgnored ...***Failed
RESULT: RED as required (post-bare-abort) SessionTestDeath.AReplyLargerThanItsSlotIsFatalRatherThanTruncated ...***Failed
RESULT: RED as required (ledger-kernel-peak) SessionTest.TheLedgersPeakIsItsOwnRunningMaxAndNeverTheKernelsHighWaterMarkVerbatim ...***Failed
Each perturbation is an exact-text edit applied and reverted by ~/w7/p5-s1-redcheck.py (sha256 of the
file checked equal after revert; no git command runs while the submodule links are on). Baseline green
before and after: 11/11 named cases pass on the unperturbed tree.
9. Corrections to s1-v1.md (the verifier's three falsifications)
- :134 "1 MiB, which covers a 512×512 RGBA8 ReadPixels" — false by 16 bytes (the header). True now: 2 MiB slots, cap 2,097,136, which holds 512×512 RGBA8 (1,048,576) and E2's 640×480 RGBA8 (1,228,800); the committed control posts both.
- :338 "so the guard cannot be simplified away" — false: the cited case never called a handshake.
True now:
SessionHandshakeTest's two cases drive both guards and go red (SegFault) when either clause is deleted. - §8.2 named
ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFilleras the kind-check control while its producer stripped the bit. True now: that case stamps the bit itself and is red under the perturbation, beside ID-43'sRingTest.TheTwoFlagSpacesAreDisjointByTranslation.
10. What needs the integrator, and accounts left open
- Two sentences outside my grant still say 8 MiB:
docs/Disaggregated/ARCHITECTURE.md:422("8 MiB,4 KiB slot" — wrong on both numbers, before and after) and~/w7/notes/p5/BRIEF-P5.md:742. ID-47's "same commit" clause cannot cover the notes (not a git repo); both are one-line edits. - c1's one line (§1) is the only thing between ID-47's ruling and a server-side abort on an oversize
read; until
OnReadPixelslands,Post's refusal is still the only defence. The helper, its message and its boundary are pinned on my side, so c1 owes a call, not a test. StartOverTransportPairis public for the Welcome control only. If the integrator prefers afriend-shaped seam, it is a two-line change; I chose the public function because it is Start's real second half (Start now composes it) rather than a test-only hook, and its header comment says who may call it (nobody but Start and the control).- The reply-slot count is not announced in Welcome. Under inproc both roles read the same
SessionSegments; under P6's spawn the client would needReplySlotCounton the wire (or the fingerprint) to size its pool. Not a P5 defect — noted so P6 does not rediscover it. - Wire-suite count for the gate: the task's regex still gives 58; a gate that wants the new suite
counted needs
^Sessionin it (91 today). - Perf: not measured this round; nothing on a hot path changed (the fold is at phase boundaries, the client-side check is one compare per ReadPixels).
11. Files
Committed (949ba509): MG_Remote/Transport/{WireLog.h,WireLog.cpp,ReplySlot.h,SessionRings.h,Ring.cpp,RoleMemory.h,ShmSegment.cpp},
MG_Remote/{CapsCodec.h,CapsCodec.cpp}, MG_Remote/Client/{ClientSession.h,ClientSession.cpp},
MG_Remote/CONTRACT-P5.md (row 23 only), MG_Test/Wire/{SessionTest.cpp,SessionHandshakeTest.cpp (new),ProtocolSmokeTest.cpp,CMakeLists.txt}.
Not touched: anything of w1's (MG_Remote/Wire/*, PipeWireCodecTest.cpp), c1's (OnReadPixels,
MG_Impl/Pipe/*), protocol.fbs, any .def or generator, ServerSession.cpp (the guard is exercised, not
edited). No line of mine meets w1's finding-3 work.
Kept under ~/w7/ (cited above): p5-s1-gate3.sh, p5-s1-gate3-run.log, p5-s1-redcheck.{py,sh,log},
p5-s1-redcheck-run.log, p5-s1-split-unit.log, p5-s1-split-monolith-igpu.log, p5-s1-igpu-push.log,
p5-s1-names-{linux,push}.txt, p5-s1-symbols.md, p5-s1-build-{linux,push,verify,split}.log,
p5-s1-probe/. Deleted: the configure logs and the interim library-build log.