A write of a multiple of 4096 bytes holds the partial line it ends with, as one that fills its Twrite does: a burst through a mount no longer runs its cut lines as two commands

selfmount's 1000-line burst reported 943 lines, on main too. The log
ring was not losing records: a follower opened before the burst heard
exactly 943 and no `lost`, and the burst itself exited 1 with
`err 1 exec: wrong #args in control message "Msg"`. `seq ... > exec`
through the mount arrives as stdio's 4096-byte writes, each shorter than
a Twrite. The rule that such a write is whole ran each one's cut last
line at once, so both halves of the line ran as commands (hence `exit
127` records). At 12288 bytes the cut left a bare `Msg`, which was
refused and failed the write and the rest of the burst.

A write of a multiple of 4096 bytes is where a writer's buffer (stdio, a
page cache) filled, so it may go on: its unended tail now waits for the
next write or the close, like one that fills its Twrite. `printf Save >
exec` stays whole at once. fs.md says so, the 9P fuzzer's model of served
lines follows it, and a unit test cuts a `Msg` at 4096 bytes.

A follower does not lose records silently: a ring that outruns one
already reads it `lost N` first (documented, tested). selfmount now
follows the log from before the burst, so it checks every line heard
once, in order, or a loss said, not a fresh open of a 64 KiB ring. It
passed 3 in 3 and joins the gates with the new 9ns.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

1 files changed, 4 insertions, 3 deletions

diff --git a/test/monkey9p.py b/test/monkey9p.py
index 4d190bbc..fd8c80fa 100644
--- a/test/monkey9p.py
+++ b/test/monkey9p.py
@@ -674,8 +674,9 @@ def served_lines(data, sizes, room):
     (fs.md, tree.zig write): each ended line, and the unended tail of a piece
     shorter than a Twrite holds (`room`, msize less 24), which is whole in
     itself, as acme takes each write; a piece that fills its Twrite may go
-    on, and its tail waits for the next. A line written a byte a Twrite is
-    so as many lines as bytes."""
+    on, and its tail waits for the next, and so does one of a multiple of
+    4096 bytes, where a writer's buffer filled. A line written a byte a
+    Twrite is so as many lines as bytes."""
     lines, pending, at = [], b'', 0
     for size in sizes:
         piece = data[at:at + size]
@@ -683,7 +684,7 @@ def served_lines(data, sizes, room):
         pending += piece
         *done, pending = pending.split(b'\n')
         lines += done
-        if pending and len(piece) < room:
+        if pending and len(piece) < room and len(piece) % 4096 != 0:
             lines.append(pending)
             pending = b''
     if pending: