Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/v1-review-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

44 KiB
Raw Blame History

v1-review-v2 — adversarial review of package v1, round 2 (p5/v1 3fb97cc5..c9d84e33)

Reviewer: Claude (Opus 5). Perturbations executed and reverted in ~/w7/p5-v1 and in v1's joint scratch ~/w7/p5-v1-joint (branch p5/v1-joint2, ba0dcdb9 = c9d84e33 + p5/c1@f280baf2, which is 41992649 plus the docs-only merge c3e736a3 — code-identical to the head v1 reports). Submodule links toggled off before every git command and on before every build. Both worktrees are clean at the end: p5-v1 at c9d84e33 with an empty git status, p5-v1-joint at ba0dcdb9 with exactly the three merge-time hunks it carried when I started (Init.cpp 19, PipeApplier.cpp 5, ServerLoop.cpp 26 lines, byte-identical diffstat before and after). Nothing committed. ~/w7/pipe/build-*, ~/w7/p5-c1 and every other ~/w7/p5-* worktree were never written to.

Counts over the 16 charter items: 7 CLOSED (1, 3, 8, 11, 12, 13, 16), 7 PARTIAL (2, 5, 6, 7, 9, 10, 14), 1 NOT CLOSED (4 - M-3 has no gate anywhere; ID-41 inside it is closed); item 15 is a measurement, reported below. Two sub-items inside a PARTIAL are themselves NOT CLOSED: M-6 (item 7) and the round-2 census correction (item 14). Plus 9 new findings - 5 major, 4 minor.

Temp files kept because they are cited: ~/w7/p5-v1rev2-{reprobe,probe4,census,failnames,c7-run,revert-r2-dgles,restore-joint}.sh, ~/w7/p5-v1rev2-{myperturb,jointperturb,c2-latch,c2-prefix,c9-pipeline,c7-instr,c7-tuple,item12,patcher}.py, and the logs ~/w7/p5-v1rev2-{gaterun,redcheck,myperturb,jointperturb,joint-inproc,joint-isplit,joint-isplit-audit,joint-isplit-barrier0,barrier0-direct}.log, ~/w7/p5-v1rev2-c7-*.out, ~/w7/p5-v1rev2-probe-*.out.


The scoreboard

# item verdict
1 ID-49 server half CLOSED (the size half is ungated — see N-5)
2 M-1 / codex 8, the R-11 production gate PARTIAL — the copy half is gated end-to-end, the coverage half is gated nowhere
3 M-2 / codex 3, the audit becomes real CLOSED — and proved by a real red, which round 1 could not get
4 M-3 / codex 4, the whole-store readers NOT CLOSED as a gate (code correct, nothing fails when it is deleted); ID-41 CLOSED
5 m-5 / codex 5, DropAll and the freed base PARTIAL — container control only; no ASan-shaped control exists
6 M-4 + codex 11, the affinity gate PARTIAL — off is now a real control; codex 11's own fix has none
7 M-6 / M-7 M-7 CLOSED; M-6 NOT CLOSED as a gate
8 C2, the post-cancellation hang CLOSED, two-directionally
9 C6, the seven capability reads PARTIAL — the accessor is gated, the seven call sites are not
10 C7 / ID-54 PARTIAL — "never unbind" measured true; "bind once per tuple" not demonstrated
11 C9, the red-check runner CLOSED
12 C10, the park tests CLOSED
13 item 12 / ID-55, resource_flush_range CLOSED
14 the minors and the report corrections minors CLOSED; the census correction is wrong again
15 the joint numbers measured; one new major (N-1) and one refuted triage row (N-2)
16 G1 CLOSED

Item by item

1. ID-49, the server half — CLOSED

ServerVerbSink::OnReadPixels (PipeApplier.cpp:174, the ID-49 block at :205-267) computes tight = w * h * GetInputBytesPerPixel(...) (:216), forces neutral pack state through MGPipeApplySetPixelPackState (:248), reads into the tight scratch, restores the saved state and posts tight bytes (:265). MGPPixelPackState has exactly one member (MGPipeTypes.h:944-947), so the save/restore round-trip is complete — not a partial restore.

Executed, v1's own line: the three DepthReadbackHonoursThePackPixelStoreParameters entries on the joint under inproc — round 1 had two of them SEGFAULT —

$ cd ~/w7/p5-v1-joint/build-split && MOBILEGL_TRANSPORT=inproc ctest -R DepthReadbackHonoursThePackPixelStoreParameters
100% tests passed, 0 tests failed out of 3

and the full inproc census has 0 SEGFAULT (~/w7/p5-v1rev2-joint-inproc.log).

My perturbation (~/w7/p5-v1rev2-jointperturb.py id49-neutral-pack-not-forced, on the joint): delete the MGPipeApplySetPixelPackState(neutralPack) line only.

   integration-split: 100% tests passed, 0 tests failed out of 21
   depthpack: 0% tests passed, 3 tests failed out of 3 ; SEGFAULT lines=2
      DirectGLES.DepthStencilReadbackMatrixScenario.DepthReadbackHonoursThePackPixelStoreParameters (SEGFAULT)
      DirectVulkan.DepthStencilReadbackMatrixScenario...                                            (Failed)
      DirectGLES.ForcedDepthStencilEmulation...DepthReadbackHonours...                              (SEGFAULT)

That is a genuine, executed red-once for the neutral-read half, end to end, reproducing exactly the pre-fix shape. ID-49's server half is closed.

But (feeding N-5): the tight-size half has no control anywhere. Both id49-reply-uses-dstsize (post info.DstSize instead of tight) and id49-scratch-sized-by-dstsize (size the scratch from info.DstSize) leave the joint at 21/21, the depthpack family green, and v1's 19 unit cases green. That is not surprising — c1's PackedReadbackBytes is already the tight size, so tight == info.DstSize on this head — but it means the MGLOG_E_ONCE mismatch branch (:225) and the bytesPerPixel == 0 → trust DstSize fallback (:216-219) are unexercised dead paths, and a future c1 regression to a packed DstSize would be caught by nothing on v1's side.

2. M-1 / codex 8 — PARTIAL

Half one, the copy, is now gated twice over. The redcheck entry m1-subdata-site-raw-offset restores resource->hostBytes = static_cast<const Uint8*>(bytes) - offset; at Managers.cpp:2131-2133:

=== m1-subdata-site-raw-offset (the exact rule-C violation R-11 exists to fix, at its production call site)
   RED for its own reason (rc=8): kept a pointer into SEG_STAGE

and — this is new, and stronger than anything v1 claims — the same perturbation takes the joint's reduced-path lane from 21/21 to 11/21 (~/w7/p5-v1rev2-jointperturb.log):

   integration-split: 52% tests passed, 10 tests failed out of 21
      DirectGLES.Split.ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels (Failed)
      ... TriangleScenario.AVboBackedTriangleReachesReadPixels (Failed)  [and 8 more]

So R-11's copy is load-bearing in production, not only in a container test. This is the measurement round 1 said would settle M-1/M-2 and it comes out in v1's favour.

Half two, the coverage clamp, is gated nowhere. The charter's second perturbation — neuter RequireStagedCoverageForPendingRanges (Managers.cpp:1053-1065, loop body → continue) —

$ python3 ~/w7/p5-v1rev2-myperturb.py require-pending-coverage-neutered
=== require-pending-coverage-neutered  (anchor count=1 in Managers.cpp)
   ctest rc=0
   *** NOTHING WENT RED ***

(over ServerLoopTest|StagedShadowTest|StagedShadowProductionTest, 19 cases), and on the joint (~/w7/p5-v1rev2-jointperturb.log):

=== require-pending-coverage-neutered
   integration-split: 100% tests passed, 0 tests failed out of 21
   depthpack: 100% tests passed, 0 tests failed out of 3 ; SEGFAULT lines=0

Answer to the charter's question: restoring hostBytes = raw - offset goes red on StagedShadowProductionTest.SubDataThroughTheRealOpsTable… with the string kept a pointer into SEG_STAGE; neutering RequireStagedCoverageForPendingRanges goes red on nothing at all, in the unit lane or on the joint. Round 1's M-1 is half closed.

3. M-2 / codex 3 — CLOSED

liveHostBase() (Managers.cpp:2941-2960) returns resource->hostBytes unconditionally under an active transport; the MappedData() arm is #if MOBILEGL_BUILD_DISAGGREGATED + transport-guarded, so monolith is untouched. The audit is real, and I have the direct evidence round 1 lacked: the production copy's removal (item 2 above) turns the joint reduced-path lane red in 10 places. That is exactly "the draw reads the shadow"; before M-2 the same perturbation was invisible (round 1's review deleted the copy and all 1985 split unit cases stayed green).

Both gaps M-2 exposed are fixed and both are visible in the diff: StagedShadowStore::HasShadow (StagedShadow.h:136-146) discriminating freed-on-context-loss from live-just-staged, and the lazy twin minted at subdata (Managers.cpp:2096-2110, transport-guarded).

Monolith byte-identical, re-measured (~/w7/p5-v1rev2-gaterun.log): G2 pull-vs-push name diff lines: 0; G14 pull removed 0 / added 40, push removed 0 / added 40; push integration-gpu: 100% tests passed, 0 tests failed out of 1128; split/monolith integration-gpu: 100% tests passed, 0 tests failed out of 1149.

4. M-3 / codex 4 — NOT CLOSED as a gate (the code is right; nothing can notice it going away)

Both whole-store readers do now go through the refusal: Managers.cpp:3028-3029 ("pool_reuse_whole_store", before the whole-store glBufferSubData) and :3104-3113 ("respecify_whole_store", called from both RespecifyStorageWith arms).

My perturbation: delete each one, then both.

=== m3-poolreuse-require-deleted   ctest rc=0   *** NOTHING WENT RED ***
=== m3-respecify-require-deleted   ctest rc=0   *** NOTHING WENT RED ***
=== m3-both-requires-deleted (joint)
   integration-split: 100% tests passed, 0 tests failed out of 21
   depthpack: 100% tests passed, 0 tests failed out of 3 ; SEGFAULT lines=0

v1-v2.md says "the production wiring is exercised end-to-end on the joint". It is not: the joint does not move. The only red-once v1 offers for M-3 is StagedShadowTest.ADrainOutsideTheStagedCoverageIsFatalByName, which perturbs StagedShadowStore::RequireCoverage — the class the case constructs. This is round 1's M-1 shape recurring one level out.

ID-41 — CLOSED. Both G5 scripts pass in the worktree and FlushPendingRangesFrom hashes to the pin:

$ bash scripts/p3a_untouched_regions.sh ff2994d9 HEAD
172b022273db01b16e772d15b269ffcd797fe38c767f7354d83ce113a66040d0  FlushPendingRangesFrom
[p3a-untouched] the 11 pool / deferred-release / ring / flush-drain functions are byte-identical
$ bash scripts/p4a_untouched_regions.sh ff2994d9 HEAD
[p4a-untouched] the 17 ... regions are byte-identical between ff2994d9 and HEAD

Worth naming: ShouldUseCaveatTextureFormat is in p4a's pinned set and Utils.cpp is a file C6 edited — the hash still matches, so C6 did not touch a pinned body.

5. m-5 / codex 5 — PARTIAL

StagedShadowTest.HasShadowIsTrueAfterAdoptAndFalseAfterTheShadowIsDropped asserts both directions and is a real control for the discriminator. The fix — if (!ServerStaged().HasShadow(resource)) resource->hostBytes = nullptr; at Managers.cpp:2983-2985 — is gated by nothing:

=== m5-production-null-deleted   ctest rc=0   *** NOTHING WENT RED ***          (unit, 19 cases)
=== m5-production-null-deleted   integration-split: 100% ... out of 21          (joint)

The charter asks for "the ASan-shaped control". There is none: no ASan build, no context-loss case, and the shipped control cannot reach the freed base. codex 5 is fixed in source and unverified in behaviour.

6. M-4 + codex 11 — PARTIAL

The off half is now a real control. Deleting if (std::strcmp(raw, "off") == 0) return 0; (ServerLoop.cpp:86) — the exact perturbation that stayed green in round 1 —

=== affinity-off-branch-deleted
   ctest rc=8
   RED: ServerLoopTest.TheAffinityStringResolvesToAMaskAndTheMaskIsLogged (Failed)
      | ../MobileGL/MG_Test/Wire/ServerLoopTest.cpp:362: Failure

(:362 is the new EXPECT_EQ(log.find("is not auto, off or a number"), npos).) The explicit-mask case passes and logs RESOLVED mask 0x3. Redcheck resolved-mask-not-logged is still red for its own reason.

codex 11's own fix is gated by nothing. Replacing the sched_getaffinity read-back (ServerLoop.cpp:126-136) with return requested;:

=== affinity-reports-requested   ctest rc=0   *** NOTHING WENT RED ***

ServerLoopTest.cpp:373 says "Red once by making ApplyAffinity return requested". That is false on any box whose cpuset is not trimmed — which is every box the suite runs on — and the comment's next clause admits as much. This is the R-16 clause about a red-once line that was never executed.

7. M-6 and M-7

M-7 — CLOSED. Making the !m_running && backendAlive arm an inline fallback again:

=== m7-fatal-becomes-fallback
   ctest rc=8
   RED: ServerLoopTest.AForwarderWithABackendButNoThreadIsFatalNotAnAppThreadFallback (Failed)
      | Expected: (log.find("Fatal{ApplyThreadNotRunning")) != (std::string::npos)

Which test dies: AForwarderWithABackendButNoThreadIsFatalNotAnAppThreadFallback, on the missing Fatal{ApplyThreadNotRunning line in the log file (plus the EXPECT_EXIT signal assertion at :774).

M-6 — NOT CLOSED as a gate. The fix is the new MG_Remote::Server::ServerLoopInstance().Stop(); at MG_Backend/Init.cpp:194. Delete exactly that line:

=== m6-shutdown-stop-deleted  (anchor count=1 in Init.cpp)
   ctest rc=0
   *** NOTHING WENT RED ***

ServerLoopTest.StopWithoutAStartedThreadStillDropsThePrivateBackend (:786) gates ServerLoop::Stop()'s !joinable arm — which round 1 already had (the diff does not touch it) — not the new call. ShutdownSplitRoles still has no test of any kind.

8. C2 — CLOSED, two-directionally

The shipped deterministic case plus redcheck c2-inline-after-stop (red on did not return NOT_INITIALIZED). Beyond that I replayed the verifier's latch harness on the fixed tree (~/w7/p5-v1rev2-c2-latch.py, latch at the same program point: after the OnApplyThread() test, before any lock):

[ RUN      ] ServerLoopVerifyC2.AControlRequestPostedAfterTheFinalCancellationPassReturnsNotInitialized
C2_ARM: the caller is past the running check and held
C2_STOP: Stop() returned in 0 ms; Running()=0
C2_RESULT: CALLER_RETURNED rc=1 (NOT_INITIALIZED=1)
[       OK ] ... (3 ms)

and the 19 shipped cases stay green with the latch compiled in but unarmed. Then, to prove the harness is not vacuous, I restored the pre-fix shape (~/w7/p5-v1rev2-c2-prefix.py: the m_running check back outside m_controlMutex, the clear back outside the cancellation-pass critical section) and ran the same case:

C2_RESULT: CALLER_HUNG - no answer 30000 ms after the loop was joined
[  FAILED  ] ServerLoopVerifyC2....  (30002 ms)

Both directions executed; both trees reverted. v1's own reasoning for shipping only the deterministic half (the fix works by mutual exclusion, so a latch cannot sit inside the new critical section without starving the apply thread's exit) is correct — a latch at the fixed check point would deadlock Stop() into Fatal{ApplyThreadJoinTimeout}. The harness above is the honest replacement and it is not shipped; v1 should take it or its shape.

9. C6 — PARTIAL

The seven reads are converted through ActiveBackendFormatCaps() (Utils.h:15-27, Utils.cpp:39-51), each #if MOBILEGL_BUILD_DISAGGREGATED-guarded; the pull build never sees the symbol:

$ nm --defined-only ~/w7/p5-v1/build-linux/libMobileGL.so | grep -c ActiveBackendFormatCaps
0

The two-object control passes and redcheck c6-accessor-reads-global is red on returned the process global's cache.

But the routing is ungated. Reverting ONE of the seven (the HasCachedFormatCapability pair, Utils.cpp:89-112) back to pActiveBackendObject:

=== c6-one-callsite-reverted   ctest rc=0   *** NOTHING WENT RED ***

The control gates the accessor, not the seven reads the ruling is about. That is codex 8's shape again, transplanted: a test that would not notice the conversion being undone one site at a time. Mitigation: G1 (0 added / 0 removed) and the #else arms make an accidental revert loud in review, not in CI.

C6 is also not the cause of any of the 23 inproc wrong answers — see item 15.

10. C7 / ID-54 — PARTIAL

ClassifyEglMakeCurrent's release test is character-for-character IsReleaseCurrentRequest's (BackendObject_DirectGLES.cpp:30-33); the unit case MakeCurrentClassifiesRepeatAndReleaseWithoutRebinding (:829) asserts all four arms of the pure decision.

The instrumented counts, measured (~/w7/p5-v1rev2-c7-instr.py + c7-run.sh, then reverted). One counter immediately before each native eglMakeCurrent (DirectGLES.cpp:11925, :11964) and one line per ApplyMakeCurrent classification, same scenario, same binary:

monolith inproc (split)
native eglMakeCurrent binds, per process 2 2
native eglMakeCurrent(NO_CONTEXT) releases 1 0
ApplyMakeCurrent actions n/a 1 × NativeBind, 1 × ClientRelease, 0 × RepeatNoOp
C7_ACTION pid=46515 0 tuple dpy=0x1 draw=0x1 read=0x1 ctx=0x1 | held=0 ...
C7_ACTION pid=46516 0 tuple dpy=0x1 draw=0x1 read=0x1 ctx=0x1 | held=0 ...   <- the pre-flight fork
C7_ACTION pid=46515 2 tuple dpy=0x1 draw=(nil) read=(nil) ctx=(nil) | held=1 ...
      2 C7_NATIVE_BIND pid=46515 ;  2 C7_NATIVE_BIND pid=46516 ;  0 C7_NATIVE_RELEASE
  • "Never unbind on a client release" — CONFIRMED. The client's release-current is recorded and not forwarded: 1 native release under monolith, 0 under split, with a ClientRelease classified.
  • "Bind once per tuple" — NOT DEMONSTRATED. The native bind count per process is unchanged (2 under both transports). Only one of the two reaches ServerMakeEGLCurrent; the other comes from DirectGLES's own internal MakeCurrent() calls (DirectGLES.cpp:11829, :11847), which the forwarder-level dedup cannot see. RepeatNoOp is classified zero times on the whole reduced-path lane, in all three scenario families. So the verifier's C7 count ("two binds in one process → NATIVE_BIND #1, #2") is still true at the DirectGLES layer after the fix, and ServerLoop.h:33-40's "makes DirectGLES.cpp's six cache invalidations a one-off startup cost" is not established.
  • ID-54 names three controls ("2 identical binds → 1 native bind"; "release → 0 native releases"; "bind after release, same tuple → 0 native binds"). None of the three is shipped, on p5/v1 or on the joint, and NativeBindCount()/ClientReleaseCount() have zero readers anywhere (N-6).
  • The production wiring is ungated: making ApplyMakeCurrent ignore the classification entirely (c7-applymakecurrent-always-binds) leaves all 19 cases green.
  • See N-3: the cached tuple is never invalidated when the context or surface it names is destroyed.

11. C9 — CLOSED

Re-ran the shipped runner (~/w7/p5-v1rev2-redcheck.log): C9 META-CONTROL … PASS, 14 of 14 perturbations RED for its own reason, P5_V1_REDCHECK_ALL_WENT_RED, exit 0.

The charter asks for the pipeline, not just classify(). ~/w7/p5-v1rev2-c9-pipeline.py loads the shipped runner as a module and stubs build()/ctest() so the real main() drives the real patch/classify/report path:

A: every perturbed run returns an UNRELATED non-zero failure
main() returned 2, perturbed ctest calls=14
ALL_WENT_RED printed: False
   === FINDINGS
    - stamp-removed: red, but not for its own reason (expected /StampVerbBoundary did not run/)
    ... [all 14]
B: every perturbed run stays GREEN
main() returned 2 ; ALL_WENT_RED printed: False ; [all 14] "stayed GREEN with the implementation broken"
worktree after the two scenarios (empty == clean):  (clean)

Both halves of the charter's question answered: an unrelated failure does not count as red, and an all-green sweep exits non-zero. Minor caveat in N-9.

12. C10 — CLOSED

ServerFixture::WaitUntilTrulyParked() polls RingControl::consumerParked, the flag Doorbell::Wait sets inside its blocking section (Doorbell.h:142), and the three park-dependent cases plus the two new ones use it. Redcheck c10-wait-never-blocks (the :269 wait replaced by true):

=== c10-wait-never-blocks
   RED for its own reason (rc=8): never entered the blocking park

13. item 12 / ID-55 — CLOSED

Executed red-once, precisely the one the charter names (~/w7/p5-v1rev2-item12.py: drop the && MG_Config::Transport == Monolith guard at PipeApply.cpp:1885-1886, nothing else):

integration-split with the guard dropped: 67% tests passed, 7 tests failed out of 21
   DirectGLES.Split.PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw (Subprocess aborted)
   ... [all seven PersistentCoherentMapScenario entries, both lanes]
restored: build rc=0 ; 100% tests passed, 0 tests failed out of 21

21 → 14 → 21, and the seven are exactly the seven v1 names. Under monolith the guard is MG_Config::Transport == Monolith with Transport an inline constexpr TransportMode::Monolith (Config.h:514), so the expression folds to && true; G1 reports .text +0 and 0 added / 0 removed / 0 resized / 0 renamed, G2 reports 0 pull-vs-push name diff lines, and push integration-gpu under monolith is 1128/1128. MGPipeApplyResourceFlushRange is unchanged under monolith.

14. The minors and the report corrections

verdict
m-1 (present↔swap is a convention) CLOSED — PipeApplier.cpp:156-165 says so, and Presents() is exposed (PipeApplier.h:128)
m-2 (the death test names its mode) CLOSED — EXPECT_EXIT(..., KilledBySignal(SIGABRT), ".*") + the exact Fatal grep; passes
m-3 (Start resets its diagnostics) CLOSED — ./ServerLoopTest with no filter is now 19 tests from 3 test suites ran. [ PASSED ] 19 (round 1 gave DrainedRecords … 9 vs 8)
m-4 (the doorbell Fatal text) CLOSED — ServerLoop.cpp:604-612 now says Notify suffices and Kill is the belt
m-6 (AssertConsumerMaskIsHonest re-runs) present at Init.cpp:224, but see N-8 — it cannot detect the thing its comment claims
m-7 (reply ordering documented) CLOSED — documented against ReplySlot.h:36 ("ORDERING")

Report corrections:

  • Round-1 census 428/185/506/28 + 2 SEGFAULT = 1149 — correct, re-derived from ~/w7/p5-v1-joint-inproc.log (428 Passed, 185 Skipped, 508 ***Exception of which 2 SEGFAULT, 28 Failed).
  • "The 506 are class-C by one probed example, not per-abort" — correctly restated.
  • "The VERB_BARRIER=0 / STRICT_ERRORS=1 failure NAMES come from the MobileGL log FILES" — correct and reproduced: with MOBILEGL_LOG_FILE_PATH set I read [Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{BarrierViolation, "SetTextureParams"} verbatim (~/w7/p5-v1rev2-barrier0-direct.log:78). The DirectGLES.Split.* ctest entries still set no log path, so on the lane itself it remains unattributed (ID-53's plumbing, assigned to the joint-merge package by ID-56). See N-1 for the much worse thing that has happened to that lane.
  • "No 0xDD reached a draw is now ESTABLISHED" — accepted, and on better evidence than v1 gives: the claim rests on M-2 making the shadow the only base, and that is now a measured fact (removing the copy turns the lane red in 10 places), not an inference from a green lane.
  • "The thread really PARKED first now rests on consumerParked" — correct (item 12).
  • §8's HandleRecycle.* correction — the old sentence was indeed wrong, but the replacement is also wrong: see N-2.
  • The round-2 census — wrong, and in the flattering direction: see N-4.

15. The joint numbers I measured

Joint = p5/v1-joint2 ba0dcdb9 (c9d84e33 + p5/c1@41992649(+docs) + the two merge hunks), rebuilt here, BUILD_RC=0.

lane result
ctest -L integration-split (inproc) 21/21 — 19 pass + the 2 TheMapLandsInTheArmItsLaneDeclares design skips
MOBILEGL_IPC_AUDIT=1 ctest -L integration-split 21/21
MOBILEGL_IPC_STRICT_ERRORS=1 19 of 21 red (2 design skips) — the negative control still works
MOBILEGL_IPC_VERB_BARRIER=0 21/21 "passed", ctest exit 0 — the negative control is GREEN. See N-1
inproc ctest -L integration-gpu census 392 passed / 183 skipped / 551 subprocess-aborted / 23 failed / 0 SEGFAULT (= 1149)

Fatal{BarrierViolation} is readable — but only from a MobileGL log file the operator sets by hand.

The 23, by family, with attribution I tested rather than assumed. All 23 names match v1's table and its per-family counts (12 Layered / 3 packed-depth GetTexImage / 3 PrimGen / 3 HandleRecycle / 1 swizzle / 1 P4aFinal).

Two ownership experiments, on the joint:

  1. C6 is not the cause. Disabling ActiveBackendFormatCaps's server arm (the obvious v1-shaped suspect for format/attachment answers) and rebuilding (BUILD_RC=0): all six probed entries still fail, identically. Reverted.
  2. v1's round 2 as a whole is not the cause. I reverted every round-2 hunk in Managers.cpp, Utils.{h,cpp}, BackendObject_DirectGLES.cpp and PipeApply.cpp to their 3fb97cc5 text on the joint (~/w7/p5-v1rev2-revert-r2-dgles.sh), rebuilt (BUILD_RC=0) and re-ran: all six still fail identically under inproc, all six pass under monolith. (The same revert drops integration-split to 14/21, which independently confirms that v1's round 2 is what produced 21/21.)

So v1's claim that none of the 23 is v1's holds for the two families the charter asked me to test (P4aFinalFixScenario, HandleRecycle.Legacy) and for four more besides. Their classification, however, does not — see N-2. Against c1's own measured baseline on the same c1 head (ID-56: 386/180/558/23/2), v1's round 2 is +6 passed, −7 aborted, −2 segfault — a small, genuine improvement.

16. G1 — CLOSED

$ python3 scripts/symbol_report.py --before ~/w7/p5-before-libMobileGL.so \
      --after ~/w7/p5-v1/build-linux/libMobileGL.so --threshold 0
symbol-report: .text 10806611 -> 10806611 (+0, +0.000%)
symbol-report: 27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed

nm pull MG_Remote = 0, split = 431, split ServerLoop = 27, pull ActiveBackendFormatCaps = 0. Run after a fresh cmake --build build-linux (rc=0) inside the gate, so it is not a stale binary.

The other three self-tests re-measured in the same run (~/w7/p5-v1rev2-gaterun.log): unit 1814/1814 in each of pull/push/verify; split 1994 with one red (PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot, c1's ID-31); flake sweep ctest -R 'ServerLoopTest|StagedShadowTest' -j 8 --repeat until-fail:100 → 100% tests passed, 0 tests failed out of 18; generators --check up to date; include-closure 0 problems.


New findings, most severe first

N-1 — major — MOBILEGL_IPC_VERB_BARRIER=0, R-1's negative control, is GREEN on the joint head: all 21 entries SKIP and ctest exits 0

File:line: MobileGL/MG_IntegrationTest/CMakeLists.txt:1854-1857 (MGL_ITEST_GLES_SPLIT_ENVIRONMENT)

  • the harness's forked pre-flight EGL child (Scenarios/../Harness/ScenarioFixture.h:111).

Claim: with the barrier off, the pre-flight child now dies of Fatal{BarrierViolation, "SetTextureParams"}; the harness reads a pre-flight child that died on signal 6 as "the EGL bring-up ABORTS on this platform" and SKIPS every scenario; the entries carry SKIP_REGULAR_EXPRESSION, so ctest records 21 skips and prints 100% tests passed.

Failure scenario: exit gate E1 (Fatal{BarrierViolation} must be red under barrier-off) is retired silently. Round 1's joint gave 19 of 21 red here. Anyone reading the lane sees a pass.

How to confirm (executed):

$ cd ~/w7/p5-v1-joint/build-split && MOBILEGL_IPC_VERB_BARRIER=0 ctest -L integration-split -j 4
100% tests passed, 0 tests failed out of 21        # every entry ***Skipped
$ MOBILEGL_IPC_VERB_BARRIER=0 MOBILEGL_ITEST_REQUIRE_GPU=1 ctest -L integration-split -j 4
0% tests passed, 21 tests failed out of 21         # red, but for "no usable GPU", not per-entry
$ ... MOBILEGL_LOG_FILE_PATH=... ./MobileGLIntegrationTest --gtest_filter=TriangleScenario.*
~/w7/p5-v1rev2-barrier0-direct.log:78: Fatal{BarrierViolation, "SetTextureParams"}

MOBILEGL_IPC_STRICT_ERRORS=1 is unaffected (19 of 21 red) because it aborts inside the scenario, after the pre-flight has succeeded.

Owner: not v1's code — the abort moved into the pre-flight because c1's round-2 R-17 routes SetTextureParams through the wire. It belongs with ID-53's lane plumbing in the joint-merge package (ID-56 already assigned the missing MOBILEGL_LOG_FILE_PATH there). Fix shape: the split lanes must set MOBILEGL_ITEST_REQUIRE_GPU=1 (or the pre-flight must not run the transport), and E1 must assert Fatal{BarrierViolation, "<slot>"} from a per-entry log file.

Severity: major. It is a phase exit gate that currently cannot fail.

N-2 — major — two of v1's six M-5 triage rows call a deterministic split defect a -j flake, on probes that ran zero tests

File:line: ~/w7/p5-v1-probe.sh:4-6 and its primgen / handlerecyc entries; v1-v2.md §"M-5 triage" rows 3 and 4.

Claim: the probe exports MOBILEGL_BACKEND_TYPE=DirectGLES and an unprefixed gtest filter, so it ran the plain DirectGLES.PrimitivesGeneratedNoXfbScenario.* and DirectGLES.HandleRecycleScenario.* entries — which are SKIPPED, not passing. gtest exits 0 when everything skips, so rc=0 was read as "passes standalone". The entries that actually fail are DirectVulkan.*, DirectVulkan.PrimGenReroute.*, DirectGLES.HandleRecycle.Legacy.*, DirectVulkan.HandleRecycle.{Legacy,AbaControl}.* — different backends and different ctest lanes.

How to confirm (executed):

$ bash ~/w7/p5-v1rev2-reprobe.sh           # v1's own probe parameters
===== primgen rc=0 =====      [  SKIPPED ] ... ; [  PASSED  ] 0 tests.
===== handlerecyc rc=0 =====  [  SKIPPED ] ... ; [  PASSED  ] 0 tests.
$ bash ~/w7/p5-v1rev2-probe4.sh ~/w7/p5-v1-joint/build-split inproc     # the entries that DO fail
DirectGLES.HandleRecycle.Legacy...AFramebufferAtARecycledAddress...  [inproc]   0% tests passed, 1 failed
DirectVulkan.PrimGenReroute...CountsADrawMadeWithNoCaptureSpan       [inproc]   0% tests passed, 1 failed
$ bash ~/w7/p5-v1rev2-probe4.sh ~/w7/p5-v1-joint/build-split monolith
... all six: 100% tests passed

Six of the 23 (3 PrimGen + 3 HandleRecycle) are deterministic, reproducible standalone under inproc, green under monolith — not flakes. The census log agrees: the DirectGLES entries v1 probed are ***Skipped in it.

Consequence: six wrong answers on the split path currently have no owner, because they were filed as scheduling noise. This is R-16's third clause ("一条探针不得对着桩武装") applied to a triage probe.

Severity: major (as a report/triage defect; the underlying six are still not v1's — see item 15).

N-3 — major — the C7 tuple cache is never invalidated when the context or surface it names is destroyed

File:line: ServerLoop.h:195-202 (m_haveCurrentTuple at :198, m_curDpy/Draw/Read/Ctx at :199-202); ServerLoop.cpp:216 (the only clear, in Start()); ServerLoop.cpp:798-813 (ServerReleaseEGLResources, which runs backend->ReleaseEGLResources() → DestroyEGLContext and clears nothing); ServerLoop.cpp:264-290 (ApplyMakeCurrent).

Claim: ApplyMakeCurrent keys "already bound" on the client's (dpy, draw, read, ctx) handle values and keeps that key across context and surface destruction.

Failure scenario: client binds (D,S,S,C) → NativeBind, tuple cached. Client destroys the context and/or surface (ServerReleaseEGLResources / ServerReleaseEGLSurface) without the session being restarted, then creates new ones. EGL handle values are routinely recycled — on this host every one of them is literally 0x1 (~/w7/p5-v1rev2-c7-clear.out) — so the next make-current compares equal, classifies RepeatNoOp, performs no native eglMakeCurrent and skips the R-12 caps republish. Every later GL call on the apply thread then runs with no context current, silently, and ServerMakeEGLCurrent returns true.

How to confirm: add m_haveCurrentTuple = false clearing to ServerReleaseEGLResources and to ServerReleaseEGLSurface (when the surface matches m_curDraw/m_curRead), and to the backend-destroy path in ApplyThreadMain; write a case that binds, releases resources, rebinds the same handle values and asserts NativeBindCount() == 2. Today that case would read 1. Not reachable on the P5 reduced-path lane (measured: exactly one make-current per process, item 10), so it is a latent hazard for the exit-gate traces, OpenRA and P6 rather than a live P5 red.

Severity: major (silent wrong context, no diagnostic).

N-4 — major — the round-2 inproc census in v1-v2.md is arithmetically impossible and overstates the result

File:line: v1-v2.md §"M-5 triage", first paragraph.

Claim: "575 passed / 183 skipped / 551 subprocess-aborted / 23 failed / 0 SEGFAULT" sums to 1332, not 1149. 575 is ctest's passed + skipped figure (1149 − 574), so the 183 skips are counted twice.

How to confirm (executed, on v1's own log and on my re-run, byte-identical at 3071 lines):

$ bash ~/w7/p5-v1rev2-census.sh ~/w7/p5-v1-joint2-inproc.log
Passed: 392 ; Skipped: 183 ; Aborted(***Exception): 551 ; Failed: 23 ; SEGFAULT: 0   (= 1149)

Consequence: the report presents "round 1 was 428/185/506/28/2" beside "575", i.e. as a jump of +147 passing tests. The honest comparison is 428 → 392: 36 fewer tests pass on the round-2 joint than on the round-1 joint, with aborts up 506 → 551. That delta is c1's R-17 routing (against c1's own baseline on the same c1 head, 386 passed, v1 is +6), but it is the opposite sign from what the report tells the integrator, and it is the second round in which this census has been mis-stated.

Severity: major as a report defect; the underlying tree is fine.

N-5 — major — seven of the round's own fixes have no control that fails when the production wiring is removed

R-16's fourth clause ("每条门在报告里都要带一行'我把它弄红过一次,方式是 X'") — each of these ships a red-once line that either names a container test or names a perturbation that does not go red here. All executed with ~/w7/p5-v1rev2-myperturb.py / jointperturb.py; each left the 19-case unit surface AND the joint's 21/21 untouched:

fix file:line deleted what went red
M-1's coverage half Managers.cpp:1058-1063 (loop body → continue) nothing
M-3 pool-reuse Managers.cpp:3028-3029 nothing
M-3 respecify Managers.cpp:3104-3113 nothing
m-5's null Managers.cpp:2983-2985 nothing
M-6's call Init.cpp:194 nothing
codex 11's read-back ServerLoop.cpp:126-136 → return requested; nothing
C7's classification ServerLoop.cpp:264 → always NativeBind nothing
C6's routing (1 of 7 sites) Utils.cpp:89-112 nothing
ID-49's tight size PipeApplier.cpp:216/:265 → info.DstSize nothing (unit and joint)

Fix shape: the ones that are cheap to gate today are M-6 (a case that calls ShutdownSplitRoles after a forced ClientSession::Start failure and asserts ServerLoop::Backend() == nullptr), C7 (assert NativeBindCount()/ClientReleaseCount() through the forwarders — the counters already exist and have no readers), and C6 (assert each of the seven helpers' answer with two objects installed, not just the accessor's address). M-3, m-5 and codex 11 need a sparse-shadow case, an ASan context-loss case and a cpuset-restricted child respectively, and should be booked with owners rather than claimed.

Severity: major in aggregate — three of the round's charter items (M-3, m-5, M-6) rest on nothing executable, and the report states red-once lines for two of them that do not hold.

N-6 — minor — NativeBindCount() / ClientReleaseCount() have zero readers in the whole tree

ServerLoop.h:133-138 says they are "read by the C7 control"; rg NativeBindCount|ClientReleaseCount over p5/v1 and over the joint returns only the declaration, the definition and the comments. The shipped C7 control reads neither.

N-7 — minor — m-5's null is #if MOBILEGL_BUILD_DISAGGREGATED but not transport-guarded

Managers.cpp:2983-2985 runs in a disaggregated build under monolith transport too. There StagedShadowStore::m_copies is false, so Adopt never sets m_any, HasShadow always answers false, and resource->hostBytes is nulled on every twin's first ensure. Harmless today (split-under-monolith integration-gpu is 1149/1149, and liveHostBase() prefers MappedData() there), but "Under monolith nothing changes" — the comment two lines above it and the report's §"M-2 cascade" — is not exactly true, and the two other round-2 Managers.cpp hunks are transport-guarded. Make it consistent.

N-8 — minor — m-6's second AssertConsumerMaskIsHonest cannot detect what its comment says it closes

Init.cpp:216-224. The check only fires on claimsResources && !hasResourceOps. A client object that registers into MGPipeSetResourceOps (the case the comment names — "a client-registered g_resourceOps would flip the answer under the applier's feet") makes hasResourceOps true, which the check treats as correct. The re-run can only newly fire if the table was removed between step 2 and step 5. Either re-word the comment or compare the pointer against the one step 2 saw.

N-9 — minor — two red-check expected regexes carry almost no information

~/w7/p5-v1-redcheck.py: drained-tally-removed expects /DrainedRecords/ — an identifier the case prints in several assertions — and park-predicate-loses-control expects /Timeout/, which any ctest timeout satisfies, including an unrelated hang. They are better than the round-1 rc != 0, but they are the two entries round 1 called tautological and they are still the two weakest.


Claims in v1-v2.md the code does not support

  1. "the round-2 joint inproc census … 575 passed / 183 skipped / 551 … / 23 failed / 0 SEGFAULT" — sums to 1332, not 1149; v1's own log says 392 passed (N-4).
  2. "PrimitivesGeneratedNoXfbScenario … passes standalone (p5-v1-probe-primgen rc=0) … flaky under -j 6" and "HandleRecycleScenario… passes standalone … flaky under -j" — both probes ran a different backend/lane from the failing entries and SKIPPED every test ([ PASSED ] 0 tests); the failing entries fail deterministically standalone (N-2).
  3. M-3: "the production wiring is exercised end-to-end on the joint" — deleting both MGL_SERVER_STAGED_REQUIRE whole-store calls leaves the joint at 21/21 and the unit lane at 19/19 (item 4).
  4. M-6: "Red once (unit StopWithoutAStartedThreadStillDropsThePrivateBackend)" — that case gates ServerLoop::Stop()'s pre-existing !joinable arm, which round 2 did not change. Deleting M-6's actual fix (Init.cpp:194) goes red on nothing (item 7).
  5. m-5: "Red once (unit StagedShadowTest.HasShadowIsTrueAfterAdoptAndFalse…)" — that gates the discriminator, not the fix. Deleting the fix goes red on nothing (item 5).
  6. ServerLoopTest.cpp:373: "Red once by making ApplyAffinity return requested" — executed; the suite stays green. The effective-mask read-back has no control on an unrestricted box (item 6).
  7. C7: "the instrumented native-bind COUNT is a joint-lane control" and ServerLoop.h:133-138's "read by the C7 control" — no such control exists on p5/v1 or on the joint; the counters have zero readers (N-6). Measured, the native bind count per process is unchanged at 2 and RepeatNoOp is classified zero times on the whole lane (item 10).
  8. "the R-12 republish decision" on an identical repeat — ID-54 says a repeat is "a no-op apart from the R-12 republish decision"; the code skips the republish entirely on a repeat (ServerLoop.cpp:733, if (!ok || !outcome.boundNatively) return MOBILEGL_OK;). Harmless on this head only because c1's BackendObject_Remote::InitCapabilities asks the server directly (BackendObject_Remote.cpp:118-125), which the report does not say. Worth an integrator sentence.
  9. "201 split-only = wave-1 + v1's two suites" — v1 now ships three suites on split (ServerLoopTest, StagedShadowTest, StagedShadowProductionTest); the gate's own line prints "split-only names that are NOT v1s suites: 183" because its grep does not know about the third. Cosmetic.

What I could not verify, and why

  • Whether the audit poison itself is armed on the joint lane. I established the stronger thing it exists to support (the draw's only base is the server shadow, provably), but I did not instrument PipeWireCodec's 0xDD fill on the joint to count the runs it poisons.
  • N-3 as a live reproduction. The reduced-path lane performs exactly one make-current per process, so the recycled-handle window cannot be reached without a scenario that destroys and recreates an EGL context — none exists in the tree today.
  • codex 11 under a real cpuset. Confirming the effective-mask read-back needs a cgroup-restricted child; I did not create one.
  • ASan anything. No ASan build exists in this worktree set and configuring one was out of budget; m-5 and codex 5 remain source-level only.
  • DirectVulkan under split on a device, OpenRA/SPLIT, adb — out of scope and out of reach.
  • Whether the 23 are c1's specifically. I established they are not v1's round 2 (two independent reverts) and that they are split-path-only. Naming the owning package needs c1's emit table, which is c1's round 3 and currently in flight in ~/w7/p5-c1.

Verdict

Mergeable after one small fix round, and the fix round is about gates and the report, not about the code. Every behavioural item the charter names is either correct-and-proved (ID-49 server half, M-2, M-7, C2, C9, C10, item 12, G1) or correct-in-source with the control missing (M-3, m-5, M-6, codex 11, C7's bind half, C6's routing). The two blockers of round 1 are genuinely closed, and M-2 is closed with the exact measurement round 1 said would settle it — the reduced-path lane now goes red when R-11's copy is deleted, which it did not before.

What the fix round must close, in this order:

  1. N-4 — correct the census in v1-v2.md to 392/183/551/23/0 and state the 428 → 392 direction plainly, with the c1-baseline delta (+6/−7/−2) beside it. This is the second round with the same error and it currently reads as a large improvement where there is a small one.
  2. N-2 — withdraw the "flaky under -j" classification for PrimitivesGeneratedNoXfbScenario and HandleRecycleScenario; both are deterministic split-path wrong answers. Re-probe with the failing entries' own backend and lane environment, and give those six an owner.
  3. N-5, the three that are cheap — a real gate for M-6 (ShutdownSplitRoles after a forced early Start failure), for C7 (NativeBindCount/ClientReleaseCount through the forwarders; the counters exist and nothing reads them), and for C6 (assert the seven helpers, not the accessor's address). Strike the red-once lines for M-6 and m-5, and the ApplyAffinity one at ServerLoopTest.cpp:373, or make them true.
  4. N-3 — clear m_haveCurrentTuple in ServerReleaseEGLResources, in ServerReleaseEGLSurface for a matching surface, and on backend destruction. One line each; the failure mode is a silent no-context-current.
  5. Item 10's prose — ServerLoop.h:33-40 and v1-v2.md must stop claiming that the six DirectGLES cache invalidations became a one-off startup cost. Measured, the native bind count per process is unchanged; what ID-54 actually bought is the release half (1 → 0 native releases), which is real and worth saying on its own.

Track as follow-ups with owners rather than blocking: M-3's and m-5's missing controls (they need a sparse-shadow case and an ASan context-loss case), codex 11's cpuset control, ID-49's tight-size half, N-7, N-8, N-9.

Not v1's, but it must not merge unnoticed: N-1. MOBILEGL_IPC_VERB_BARRIER=0 is E1's exit gate and on the joint head it exits 0 with every entry skipped. It belongs with ID-53's lane plumbing in the joint-merge package and it should be fixed before the joint merge is called green, not after.