diff --git a/capsules/v4/sys/acl.f18 b/capsules/v4/sys/acl.f18 index f2db167d..abe662d6 100644 --- a/capsules/v4/sys/acl.f18 +++ b/capsules/v4/sys/acl.f18 @@ -81,3 +81,25 @@ set HDR-NFA here ", ACL-HEAT@ #id, #, 0 #, HDR-NFA #, HDR-LINK set HDR-LIN \ ( xt -- n ) a number for the word that never changes: its address set HDR-NFA here ", ACL-WORD-ID #id, #, 0 #, HDR-NFA #, HDR-LINK set HDR-LINK here : ACL-WORD-ID (ACL-XT) ; + +\ ( xt -- ) a call from code defined at run time that the kernel sent here +\ (v4/system/mesh.c, on_call) because the word's TTL is 0 or it is denied. +\ As v3's inner interpreter, and as (ACL?): the recheck, or the TTL counted +\ down; then a denied word refused with v3's line -- by its own name, from +\ its entry (WORD's buffer is the running code's, not this) -- the stack +\ emptied and the line ended; an allowed word is jumped to, so it returns to +\ the caller as the call would have (docs/v4.0.0/plans/2026-11-19-acl-at-call.md). +: (ACL-CALL) + dup -3 + a! @ \ xt flags + dup $FFFF0000 and if ZERO + drop -65536 + ! jump TEST \ one use fewer + ZERO: drop drop dup (ACL-RECHECK) + TEST: dup -3 + a! @ 32 and if OK + drop + $33335B1B (EMIT4) $6D (EMIT4) $4E524157 (EMIT4) $203A (EMIT4) $6D305B1B (EMIT4) \ v3's line: WARN: in yellow + $3A4C4341 (EMIT4) $6E656420 (EMIT4) $20646569 (EMIT4) $27 (EMIT4) + -2 + a! @ 4* COUNT TYPE 39 EMIT CR \ the word's own name + DSTACK-DEPTH b! a !b \ as v3, the stack is emptied + pop drop jump (ABANDON) + OK: drop push ; \ on to the word + diff --git a/capsules/v4/sys/compile.f18 b/capsules/v4/sys/compile.f18 index 8a93125c..569ef04c 100644 --- a/capsules/v4/sys/compile.f18 +++ b/capsules/v4/sys/compile.f18 @@ -113,22 +113,25 @@ macro ROT push SWAP pop SWAP endmacro \ bits 16 .. 31 the TTL, a count of uses left before the next recheck \ A new entry has all of them zero: allowed, not pinned, TTL mode, TTL 0. \ -\ (ACL?) is run by INTERPRET for every word it is about to execute or -\ compile. As v3: if the TTL is 0 the word is rechecked, otherwise the TTL -\ is counted down; then a denied word is refused. The recheck is the word -\ whose address is in (ACL-HOOK) -- ACL-RECHECK, once ACL.fth has loaded -- -\ and with none there the word is allowed and given the longest TTL. +\ (ACL?) is run by INTERPRET for every word it is about to execute. As v3: +\ if the TTL is 0 the word is rechecked, otherwise the TTL is counted down; +\ then a denied word is refused. The recheck is the word whose address is in +\ (ACL-HOOK) -- ACL-RECHECK, once ACL.4th has loaded -- and with none there the +\ word is allowed and given the longest TTL. \ -\ v3 checks every execution, inside definitions too. v4 code is native: a -\ compiled call goes straight to its word. So v4 checks a word when it is -\ compiled as well as when it is interpreted -- a denied word cannot be -\ built into anything new -- but a call compiled while the word was allowed -\ is not checked again. +\ As v3, every execution is checked, inside definitions too (2026-11-19, +\ docs/v4.0.0/plans/2026-11-19-acl-at-call.md): a call from code defined at +\ run time is checked by the kernel at the call -- counted down there, or, +\ at a TTL of 0 or a denied word, sent to (ACL-CALL) (acl.f18), which runs +\ (ACL?). A word being compiled is not checked, as in v3. While the policy +\ rechecks a word, (ACL-BUSY) is 1 and the kernel checks nothing, as v3 runs +\ its policy with the check off. \ ( xt -- ) recheck : (ACL-RECHECK) - (ACL-HOOK) a! @ if NONE push ex \ call it with the xt - ; + (ACL-HOOK) a! @ if NONE + 1 (ACL-BUSY) a! ! push ex \ call it with the xt, the kernel's check off + 0 (ACL-BUSY) a! ! ; NONE: drop -3 + a! @ 65535 and -33 and $FFFF0000 + ! ; \ ( xt -- xt ) as above; a denied word ends the line @@ -202,7 +205,7 @@ set HDR-NFA here ", INTERPRET #id, #, 0 #, HDR-NFA #, HDR-LINK set HDR-LIN STATE a! @ if INTERP drop 1 and if COMP \ compiling: immediate words still run drop (ACL?) jump (GO) - COMP: drop (ACL?) (COMPILE,) jump (IL) + COMP: drop (COMPILE,) jump (IL) \ compiled, not checked: the call is, when it runs (as v3) INTERP: drop 16 and if RUN drop drop (.WORD) \ ": compile-only" $6F63203A (EMIT4) $6C69706D (EMIT4) $6E6F2D65 (EMIT4) $796C (EMIT4) CR diff --git a/capsules/v4/sys/end.f18 b/capsules/v4/sys/end.f18 index e454a555..55d71f6c 100644 --- a/capsules/v4/sys/end.f18 +++ b/capsules/v4/sys/end.f18 @@ -35,5 +35,9 @@ store (IMG) &(IDLE) store (IMG)+1 &(FAULTS) store (IMG)+2 &KEY store (IMG)+3 &CR +\ the ACL's check at call: where the kernel sends a call to be checked; and the +\ policy not running +store (ACL-CALLX) &(ACL-CALL) +store (ACL-BUSY) 0 start (IDLE) diff --git a/capsules/v4/sys/map-32.f18 b/capsules/v4/sys/map-32.f18 index a5478832..c1364866 100644 --- a/capsules/v4/sys/map-32.f18 +++ b/capsules/v4/sys/map-32.f18 @@ -120,6 +120,8 @@ constant RSTACK-DEPTH 32752 constant HEAT-OP 29216 constant (EXEC) 30047 constant (RUNX) 29954 +constant (ACL-CALLX) 29956 +constant (ACL-BUSY) 29925 constant ANTICLOCK 29248 constant CFBASE 32672 constant CFEND 32704 diff --git a/capsules/v4/sys/map-64.f18 b/capsules/v4/sys/map-64.f18 index f255ddbb..f34b3431 100644 --- a/capsules/v4/sys/map-64.f18 +++ b/capsules/v4/sys/map-64.f18 @@ -120,6 +120,8 @@ constant RSTACK-DEPTH 32752 constant HEAT-OP 29216 constant (EXEC) 30047 constant (RUNX) 29954 +constant (ACL-CALLX) 29956 +constant (ACL-BUSY) 29925 constant ANTICLOCK 29248 constant CFBASE 32672 constant CFEND 32704 diff --git a/docs/v4.0.0/DECOMPOSITION.md b/docs/v4.0.0/DECOMPOSITION.md index eee6c997..da0df716 100644 --- a/docs/v4.0.0/DECOMPOSITION.md +++ b/docs/v4.0.0/DECOMPOSITION.md @@ -892,11 +892,20 @@ is rechecked, otherwise the TTL is counted down; then a denied word is refused w is in the variable `ACL-HOOK`; with none there, the word is allowed and given the longest TTL. `ACL.fth` puts its `ACL-RECHECK` there (v3 finds it by name each time). -**Where this is weaker than v3.** v3's inner interpreter checks every execution, inside definitions too. v4 -code is native: a compiled call goes straight to its word, and no opcode asks permission. So v4 checks a -word when it is *compiled* as well as when it is interpreted — a denied word cannot be built into anything -new — but a call compiled while the word was allowed is not checked again when it runs. Closing that needs -the check in the node itself (the `call` opcode), which is a hardware decision and is not taken here. +**Where this was weaker than v3, and is not now** (2026-11-19, Captain Bob: "As v3: add at call"; "Engine: call +redirects"; `docs/v4.0.0/plans/2026-11-19-acl-at-call.md`). +- **The old gap:** v3's inner interpreter checks every execution, inside definitions too. v4 checked a word + when it was compiled and when it was interpreted, and a compiled call was never checked again. +- **Now, at the call:** the engine's call hook may send a call elsewhere. The kernel checks every call from + code defined at run time. A word with TTL left is counted down at the call. At a TTL of 0, or for a denied + word, the call goes to `(ACL-CALL)` (`acl.f18`), which rechecks or refuses it by the word's name and goes on + to it. +- **No compile-time check:** a word being compiled is not checked, as in v3. +- **The policy runs unchecked:** while the policy rechecks a word, `(ACL-BUSY)` is 1 and nothing is checked, + as v3 runs its policy with the check off. +- **A node with no kernel has no check at call:** the hosted node is one. Its compiled calls are not checked. +- **On the FPGA,** the `call` opcode must offer its kernel the same redirect. That is to be designed with the + FPGA. | Word | Fate | Notes | | --- | --- | --- | diff --git a/docs/v4.0.0/plans/2026-11-19-acl-at-call.md b/docs/v4.0.0/plans/2026-11-19-acl-at-call.md index 223d6e5e..f8e79102 100644 --- a/docs/v4.0.0/plans/2026-11-19-acl-at-call.md +++ b/docs/v4.0.0/plans/2026-11-19-acl-at-call.md @@ -4,7 +4,7 @@ Written 2026-11-19. Captain Bob ruled "As v3: add at call", then "Engine: call r decision DECOMPOSITION.md §5.20 left open: "Closing that needs the check in the node itself (the `call` opcode), which is a hardware decision and is not taken here." -**Nothing here is built.** +**Built 2026-11-19, ruled "Build it"; section 6 is as built.** ## 1. v3, and v4 today @@ -81,3 +81,47 @@ Each is seen to fail before the change. 1. The design above, 2.1 to 2.4? 2. The FPGA: record the redirect as the call opcode's requirement, to be designed with the FPGA? + +## 6. As built (2026-11-19) + +**Two things changed from the design, both found while building.** Both are needed to match v3, so +neither is a new ruling: +1. **`(ACL-BUSY)`, a recursion guard.** The policy's `ACL-RECHECK` is code defined at run time. Its own + calls would be checked, and at a TTL of 0 they would recheck themselves without end. v3 runs its policy + with the check off (`emergency_console`). `(ACL-RECHECK)` now sets `(ACL-BUSY)` around the policy, and + the kernel checks nothing while it is set. +2. **`(ACL-CALL)` has its own check and refusal.** It prints the word's name from its entry, not from + `WORD`'s buffer. A first version copied the name into that buffer and broke POST's + `CONVERT.digits`, which reads that buffer after `WORD`. + +**The target goes on the data stack** for `(ACL-CALL)`, so it needs no variable. Two map cells were added +from free memory: +- `(ACL-CALLX)`, at `BUF0_W - 113`: `(ACL-CALL)`'s address, stored by `end.f18`; +- `(ACL-BUSY)`, at `BUF0_W - 144`. + +**What changed:** +- `exec.h` and `exec.c`: the hook returns where P goes. +- `mesh.c`: `acl_at_call()`, applied to calls from code; `INTERPRET`'s dispatch is left to `(ACL?)`. +- `compile.f18`: `INTERPRET`'s compile path no longer checks, and `(ACL-RECHECK)` sets `(ACL-BUSY)`. +- `acl.f18`: `(ACL-CALL)`. +- `end.f18`, `host_map.h`, `mkmap.c`, `image.h`: the two cells. + +**Test first** (`logs/20261119-acl-at-call/`): +- `test_mesh_boot`, with the policy on. Five checks failed before: + - a call from a definition is counted down; + - a denied word called from a definition is refused by its own name, and does not run; + - a denied word compiles; + - it is refused when the definition runs. + + The sixth, that a word at the prompt is counted once, passed before and after. +- `test_exec`: a hook that returns another address redirects the call, which returns to the caller. +- `test_host_quit`'s two v4-only expectations changed to v3's: a denied word compiles. That host node has + no kernel, so its compiled calls are not checked there. + +**Verified:** +- `test_mesh_boot` passes 120 checks, with POST 990/990. +- All 52 tests at 64 bits, test-32, and ASan/UBSan pass. +- The amd64 kernel builds, and one amd64 session passes 18/18. +- **The cost** (`timing.txt`, five alternating host mesh boots): median 15.227 s old against 15.439 s new, + +1.4%. That is inside the old runs' own spread, 15.06 to 15.99 s, so no measurable cost. + diff --git a/experiments/bare_metal/runs/doe-amd64-20261119-140436.csv b/experiments/bare_metal/runs/doe-amd64-20261119-140436.csv new file mode 100644 index 00000000..e69de29b diff --git a/logs/20261119-140436/amd64/qemu-amd64-20261119-140436.log b/logs/20261119-140436/amd64/qemu-amd64-20261119-140436.log new file mode 100644 index 00000000..f5f04914 --- /dev/null +++ b/logs/20261119-140436/amd64/qemu-amd64-20261119-140436.log @@ -0,0 +1,213 @@ +[=3h[=3h[=3hBdsDxe: loading Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0) +BdsDxe: starting Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0) +[=3hStarKernel UEFI Loader +Loading kernel from ESP... +[CKPT 001] Entered efi_main - ConOut live +RAW SERIAL UP +[CKPT 002] Serial (COM1) initialized +Monolithic build - kernel linked directly +Collecting boot information... +CmdLine: parsed OK +[CKPT 004] Command line parsed +[CKPT 005] Kernel stack allocation decided +[CKPT 006] Boot info collected (ACPI table located) +GOP: linear framebuffer found +[CKPT 007] GOP: linear framebuffer found +[CKPT 008] About to enter ExitBootServices retry loop +EBS... +EBS OK +Calling kernel_main (monolithic)... + + + _____ _ _ __ _ + / ____| | | |/ / | | + | (___ | |_ __ _ _ __| ' / ___ _ __ _ __ ___| | + \___ \| __/ _` | '__| < / _ \ '__| '_ \ / _ \ | + ____) | || (_| | | | . \ __/ | | | | | __/ | + |_____/ \__\__,_|_| |_|\_\___|_| |_| |_|\___|_| + +LithosAnanke v4.0.0-alpha.5 amd64 +Architecture: amd64 +Build: Nov 19 2026 14:03:55 + +UEFI BootServices: EXITED +Console: serial line is a 16550 at port 0x00000000000003f8 (COM1, probed) + +=== StarKernel Boot Information === +Memory map entries: 126 +Total memory: 1023 MB +Usable memory: 964 MB +=================================== + +PMM initialized. +PMM statistics: + Total pages: 248348 + Free pages : 246821 + Used pages : 1527 + Total MB : 970 + Free MB : 964 + Used MB : 5 + +VMM initialized (mapped RAM, CR3 switched) +VMM initialized (mapped RAM, CR3 switched) +VMM self-test: mapped OK at 0xffff800000000000 +VMM self-test complete. + +IDT installed. + +APIC: init... +APIC: IA32_APIC_BASE MSR=0x00000000fee00900 +APIC: stale-ISR drain: 0 EOI(s) issued +APIC: initialized (xAPIC MMIO, TPR=0, SIVR=0x1FF, EOI-clear) +APIC: init done + +I/O APIC: init... +I/O APIC: base=0xfec00000, gsi_base=0, overrides=5 + override: source=00 gsi=2 flags=0x0000 + override: source=05 gsi=5 flags=0x000d + override: source=09 gsi=9 flags=0x000d + override: source=0a gsi=10 flags=0x000d + override: source=0b gsi=11 flags=0x000d +i8042: keyboard ACKed enable-scanning +i8042: IRQ1 enabled in controller config byte +I/O APIC: keyboard IRQ1 routed (masked) + +Timer: init... +Timer: init start +Timer: PM_TMR_BLK discovered from FADT at port 1544 +Timer: VM mode detected (hypervisor present). +Timer: HPET calibration disabled (VM-exit MMIO would poison timing). +Timer: WARNING: invariant TSC not present under hypervisor. +Timer: continuing in RELATIVE mode (no determinism guarantees). +Timer: RDTSCP not present; using RDTSC (less serialized). +Timer: CPUID frequency unavailable; trying PM Timer... +Timer: trust=1 (0=NONE,1=REL,2=ABS), TSC=2097506845 Hz +Timer: init done + +Kernel heap initialized. +Heap statistics: + Total bytes: 536870872 + Free bytes: 536870872 + Used bytes: 0 + Peak bytes: 0 + Heap base addr: 24641536 + Heap end addr: 561512448 + +Heartbeat: init... +APIC Timer: calibrating... +APIC Timer: apic_hz=1009032821, tick_hz=100, initial_count=10090328 +APIC Timer: configured (masked, ready to start) +Heartbeat: init done +Kernel initialization complete. +Boot successful! + +Boot disk: not a StarshipOS stick +System: StarForth v4 (this build's default) +Stadium: 83886 cells (5242 KB), 50 VM slots +Switch-signal: 50 slots +Kernel-Hermes: 50 channel slots +Kernel-Hermes: 50 pending-queue slots +StarForth v4: Hera, born in the kernel's fabric +V4: capsule v4:sys:map-64.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:map-64.f18 capsule_hash=0x81bda2bfcf496f6a +V4: capsule v4:sys:core.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:core.f18 capsule_hash=0x0f415502fccc3fba +V4: capsule v4:sys:input.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:input.f18 capsule_hash=0x0f13c3f9d5fd07fc +V4: capsule v4:sys:dict.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:dict.f18 capsule_hash=0xe3453808afd5a0af +V4: capsule v4:sys:codegen.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:codegen.f18 capsule_hash=0x36d2ae84d2911b90 +V4: capsule v4:sys:compile.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:compile.f18 capsule_hash=0xbef95acf00cb404a +V4: capsule v4:sys:quit.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:quit.f18 capsule_hash=0x7fa7a7668b6bf1ed +V4: capsule v4:sys:forth.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:forth.f18 capsule_hash=0xc4c0ad315c95eda4 +V4: capsule v4:sys:numout.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:numout.f18 capsule_hash=0xca0fb0f9c1589e20 +V4: capsule v4:sys:words.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:words.f18 capsule_hash=0x2f4e5f7f3e7f736f +V4: capsule v4:sys:system.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:system.f18 capsule_hash=0xfe257eb084c43a5d +V4: capsule v4:sys:qmath.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:qmath.f18 capsule_hash=0xa93783c2c8f9b7db +V4: capsule v4:sys:blocks.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:blocks.f18 capsule_hash=0x09d361dbe6174236 +V4: capsule v4:sys:log.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:log.f18 capsule_hash=0x544cd004233dff62 +V4: capsule v4:sys:acl.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:acl.f18 capsule_hash=0x5ceb5b43b0c5fbb1 +V4: capsule v4:sys:end.f18 signature: missing (unsigned) +PARITY:V4_F18 name=v4:sys:end.f18 capsule_hash=0x22eea18b132f8faf +PARITY:V4_ROM words=2383 rom_hash=0xd858ef412d684f92 instructions=63864013 +V4: capsule v4:forth79.4th signature: missing (unsigned) +PARITY:V4_CAPSULE name=v4:forth79.4th capsule_id=0x4609d6ef54166ef8 capsule_hash=0x4609d6ef54166ef8 dict_hash=0xbfcb975ac5a745f2 +V4: capsule v4:starshipos.4th signature: missing (unsigned) +PARITY:V4_CAPSULE name=v4:starshipos.4th capsule_id=0x1734a8f4fe7483a5 capsule_hash=0x1734a8f4fe7483a5 dict_hash=0x75401e63fcca3f0d +V4: capsule v4:centre.4th signature: missing (unsigned) +PARITY:V4_CAPSULE name=v4:centre.4th capsule_id=0x53b1e3df644e8e25 capsule_hash=0x53b1e3df644e8e25 dict_hash=0xc22f69bd157a4a70 +V4: capsule v4:hera.4th signature: missing (unsigned) +PARITY:V4_CAPSULE name=v4:hera.4th capsule_id=0x78730b1d6effe892 capsule_hash=0x78730b1d6effe892 dict_hash=0x17a3406cec07df1e +V4: capsule v4:physics.4th signature: missing (unsigned) +PARITY:V4_CAPSULE name=v4:physics.4th capsule_id=0x5b0195fc30828bde capsule_hash=0x5b0195fc30828bde dict_hash=0xf547cf4d6ad5de38 +PARITY:V4_POST tests=990 pass=990 fail=0 +PARITY:V4_SYSTEM word_count=405 dict_hash=0x0ffb1d31c4aa7857 +V4: capsule v4:init.4th signature: missing (unsigned) +V4: capsule v4:ACL.4th signature: missing (unsigned) +INFO: ACL: active +PARITY:V4_CAPSULE name=v4:init.4th capsule_id=0x13fe8932fa4d2934 capsule_hash=0x13fe8932fa4d2934 dict_hash=0xbf5e6cc6fde06a08 +PARITY:OK +POST: PASSED +PCI: init... +PCI: ECAM mapped (amd64) +virtio-rng: no device on PCI bus 0 +rng: backend = rdrand +entropy: ready +virtio-input: no device on PCI bus 0 +Starting heartbeat... +APIC Timer: started (LVT=0x00020020 ICR=10090328) +I/O APIC: keyboard IRQ1 unmasked +Heartbeat running. +Stadium opcodes: 31 resident, hottest opcode 8 +Stadium words: promotions=269 evictions=0 +Stadium conservation: resident_sum=43679 reservoir=21857 sum=65536 (Q48_ONE=65536) +Stadium conservation: CONSERVED +Stadium quota grant self-test: OK + Hera reservoir=21857 + test-vm reservoir=65536 +Heartbeat: 3 ticks, trust=0x00010000, variance=0x00000000 +blkio_usb: MSC device ready +Artemis: the stick's partition attached +[Hera] Zuse: genesis minted onto attached thumbdrive +[zuse@Hera] ok> 3 4 + . +[zuse@Hera] 7 ok +[zuse@Hera] ok> NODE-ME . +[zuse@Hera] 0 ok +[zuse@Hera] ok> 11 2 2 BIRTH . +[zuse@Hera] V4: capsule v4:forth79.4th signature: missing (unsigned) +[zuse@Hera] PARITY:V4_BIRTH node=11 dict_hash=0xc8c659cdee409171 +[zuse@Hera] 1 ok +[zuse@Hera] ok> S" 6 7 * ." 11 SEND 11 AWAIT . +[zuse@Hera] 42 1 ok +[zuse@Hera] ok> 11 KILL +[zuse@Hera] Stadium words: promotions=301 evictions=0 +[zuse@Hera] Stadium conservation: resident_sum=115 reservoir=65421 sum=65536 (Q48_ONE=65536) +[zuse@Hera] Stadium conservation: CONSERVED +[zuse@Hera] ok +[zuse@Hera] ok> 11 2 2 BIRTH . +[zuse@Hera] V4: capsule v4:forth79.4th signature: missing (unsigned) +[zuse@Hera] PARITY:V4_BIRTH node=11 dict_hash=0xc8c659cdee409171 +[zuse@Hera] 1 ok +[zuse@Hera] ok> S" VARIABLE N1 : SPIN BEGIN 1 N1 +! AGAIN ;" 11 SEND 11 AWAIT . +[zuse@Hera] 1 ok +[zuse@Hera] ok> S" SPIN" 11 SEND +[zuse@Hera] ok +[zuse@Hera] ok> 3 4 + . +[zuse@Hera] 7 ok +[zuse@Hera] ok> 11 KILL +[zuse@Hera] Stadium words: promotions=306 evictions=0 +[zuse@Hera] Stadium conservation: resident_sum=168 reservoir=65368 sum=65536 (Q48_ONE=65536) +[zuse@Hera] Stadium conservation: CONSERVED +[zuse@Hera] ok +[zuse@Hera] ok>  \ No newline at end of file diff --git a/logs/20261119-acl-at-call/amd64-session.txt b/logs/20261119-acl-at-call/amd64-session.txt new file mode 100644 index 00000000..ea6b7437 --- /dev/null +++ b/logs/20261119-acl-at-call/amd64-session.txt @@ -0,0 +1,20 @@ +LOG: logs/20261119-140436/amd64/qemu-amd64-20261119-140436.log +PASS: POST: PASSED +PASS: Boot disk: not a StarshipOS stick (an ISO or ESP boot) +PASS: Zuse: genesis minted onto attached thumbdrive (a fresh data stick) +PASS: the Stadium: its cells allocated +PASS: the Stadium: conservation CONSERVED +PASS: the heartbeat: ticking +PASS: the Stadium: Hera's words admitted after POST +PASS: [zuse@Hera] ok> +PASS: 7 ok, and a prompt +PASS: NODE-ME: Hera is at place 0 of the kernel's fabric +PASS: BIRTH: node 11 born from Hera, its parity recorded +PASS: node 11 answers Hera: 42, and its text completed +PASS: KILL: node 11 removed, the Stadium CONSERVED after +PASS: after a kill, 11 is born again +PASS: node 11 is given SPIN +PASS: Hera's line ends, though node 11 runs for ever +PASS: and the prompt answers while it runs: 7 ok +PASS: a node running for ever is killed, the Stadium CONSERVED after +RESULT: PASS diff --git a/logs/20261119-acl-at-call/build-amd64.log b/logs/20261119-acl-at-call/build-amd64.log new file mode 100644 index 00000000..2d3fee44 --- /dev/null +++ b/logs/20261119-acl-at-call/build-amd64.log @@ -0,0 +1,269 @@ +CC (loader) v4/src/exec.c + V4ROM capsules/v4/rom -> build/amd64/kernel/v4_rom_64.c build/amd64/kernel/v4_map_64.c build/amd64/kernel/v4_mesh_rom_64.c +CC (loader) v4/system/mesh.c +CC (kernel) v3/src/blkio_ram.c +CC (kernel) v3/src/block_subsystem.c +CC (kernel) v3/src/compudynamics.c +CC (kernel) v3/src/dictionary_heat_optimization.c +CC (kernel) v3/src/dictionary_management.c +CC (kernel) v3/src/heartbeat_export.c +CC (kernel) v3/src/inference_engine.c +CC (kernel) v3/src/io.c +CC (kernel) v3/src/math_portable.c +CC (kernel) v3/src/memory_management.c +CC (kernel) v3/src/physics_execution_hooks.c +CC (kernel) v3/src/physics_hotwords_cache.c +CC (kernel) v3/src/physics_metadata.c +CC (kernel) v3/src/physics_pipelining_metrics.c +CC (kernel) v3/src/physics_runtime.c +CC (kernel) v3/src/profiler.c +CC (kernel) v3/src/rolling_window_of_truth.c +CC (kernel) v3/src/ssm_jacquard.c +CC (kernel) v3/src/stack_management.c +CC (kernel) v3/src/vm_api.c +CC (kernel) v3/src/vm_debug.c +CC (kernel) v3/src/word_registry.c +CC (kernel) v3/src/word_source/acl_words.c +CC (kernel) v3/src/word_source/arithmetic_words.c +CC (kernel) v3/src/word_source/block_words.c +CC (kernel) v3/src/word_source/control_words.c +CC (kernel) v3/src/word_source/defer_words.c +CC (kernel) v3/src/word_source/defining_words.c +CC (kernel) v3/src/word_source/dictionary_heat_diagnostic_words.c +CC (kernel) v3/src/word_source/dictionary_manipulation_words.c +CC (kernel) v3/src/word_source/dictionary_words.c +CC (kernel) v3/src/word_source/double_words.c +CC (kernel) v3/src/word_source/editor_words.c +CC (kernel) v3/src/word_source/format_words.c +CC (kernel) v3/src/word_source/framebuffer_words.c +CC (kernel) v3/src/word_source/inference_words.c +CC (kernel) v3/src/word_source/io_words.c +CC (kernel) v3/src/word_source/keyboard_words.c +CC (kernel) v3/src/word_source/lifecycle_words_hosted.c +CC (kernel) v3/src/word_source/log_words.c +CC (kernel) v3/src/word_source/logical_words.c +CC (kernel) v3/src/word_source/memory_words.c +CC (kernel) v3/src/word_source/mixed_arithmetic_words.c +CC (kernel) v3/src/word_source/physics_benchmark_words.c +CC (kernel) v3/src/word_source/physics_diagnostic_words.c +CC (kernel) v3/src/word_source/physics_freeze_words.c +CC (kernel) v3/src/word_source/physics_pipelining_diagnostic_words.c +CC (kernel) v3/src/word_source/q48_words.c +CC (kernel) v3/src/word_source/return_stack_words.c +CC (kernel) v3/src/word_source/scroll_words.c +CC (kernel) v3/src/word_source/stack_words.c +CC (kernel) v3/src/word_source/starforth_words.c +CC (kernel) v3/src/word_source/string_words.c +CC (kernel) v3/src/word_source/system_words.c +CC (kernel) v3/src/word_source/ttf_words.c +CC (kernel) v3/src/word_source/vocabulary_words.c +CC (kernel) v3/src/test_runner/test_common.c +CC (kernel) v3/src/test_runner/test_contracts.c +CC (kernel) v3/src/test_runner/test_runner.c +CC (kernel) v3/src/test_runner/modules/acl_words_test.c +CC (kernel) v3/src/test_runner/modules/arithmetic_words_test.c +CC (kernel) v3/src/test_runner/modules/block_words_test.c +CC (kernel) v3/src/test_runner/modules/control_words_test.c +CC (kernel) v3/src/test_runner/modules/defining_words_tests.c +CC (kernel) v3/src/test_runner/modules/dictionary_manipulation_words_test.c +CC (kernel) v3/src/test_runner/modules/dictionary_words_test.c +CC (kernel) v3/src/test_runner/modules/double_words_test.c +CC (kernel) v3/src/test_runner/modules/format_words_test.c +CC (kernel) v3/src/test_runner/modules/inference_words_test.c +CC (kernel) v3/src/test_runner/modules/integration_tests.c +CC (kernel) v3/src/test_runner/modules/io_words_test.c +CC (kernel) v3/src/test_runner/modules/logical_words_test.c +CC (kernel) v3/src/test_runner/modules/mama_forth_words_test.c +CC (kernel) v3/src/test_runner/modules/memory_words_test.c +CC (kernel) v3/src/test_runner/modules/mixed_arithmetic_words_test.c +CC (kernel) v3/src/test_runner/modules/physics_freeze_words_test.c +CC (kernel) v3/src/test_runner/modules/q48_words_test.c +CC (kernel) v3/src/test_runner/modules/return_stack_words_test.c +CC (kernel) v3/src/test_runner/modules/stack_words_test.c +CC (kernel) v3/src/test_runner/modules/starforth_words_test.c +CC (kernel) v3/src/test_runner/modules/stress_tests.c +CC (kernel) v3/src/test_runner/modules/string_words_test.c +CC (kernel) v3/src/test_runner/modules/system_words_test.c +CC (kernel) v3/src/test_runner/modules/vocabulary_words_test.c +CC (kernel) v4/src/exec.c +CC (kernel) build/amd64/kernel/v4_map_64.c +CC (kernel) v4/system/mesh.c + MKCAP capsules -> build/amd64/kernel/capsule_generated.c +mkcapsule: scanning capsules + [p] zuse.4th (1684 bytes, hash=0x490ded9be257a90b) + [p] font.4th (17688 bytes, hash=0x3f305911500c78f6) + [p] MANIFEST_AUTO.md (11687 bytes, hash=0xe022545a0755960f) + [p] multiuser-doe.4th (3942 bytes, hash=0x22140588ee7c39e6) + [p] hestia:init.4th (891 bytes, hash=0x64e111990fbc45ff) + [p] contrib:README.md (1855 bytes, hash=0x4212e52b927793e7) + [p] ACL.4th (4318 bytes, hash=0xf8890c05c0d8f921) + [p] workload-3.4th (2189 bytes, hash=0x62b7a71576ad1041) + [p] init-l8-diverse.4th (430 bytes, hash=0xaa293201a6c91838) + [p] user-font-demo.4th (1674 bytes, hash=0xce1fd7d1b581a56d) + [p] workload-9.4th (1321 bytes, hash=0x3f2bec73142aa424) + [p] lib.4th (619 bytes, hash=0x4b216635c359ef73) + [p] workload-calib1.4th (304 bytes, hash=0x3b9f2d17b554fabc) + [m] init.4th (669 bytes, hash=0xd09db9461b336431) + [p] workload-1-lite.4th (540 bytes, hash=0x44a7a7e3176dcc8d) + [p] init-l8-stable.4th (278 bytes, hash=0xdc3830f189063a9a) + [p] v4:physics.4th (2953 bytes, hash=0x5b0195fc30828bde) + [p] v4:forth79.4th (1216 bytes, hash=0x4609d6ef54166ef8) + [p] v4:ACL.4th (2103 bytes, hash=0xdba5690fb0ee12a4) + [p] v4:init.4th (756 bytes, hash=0x13fe8932fa4d2934) + [p] v4:sys:log.f18 (4535 bytes, hash=0x544cd004233dff62) + [p] v4:sys:qmath.f18 (8607 bytes, hash=0xa93783c2c8f9b7db) + [p] v4:sys:map-32.f18 (3215 bytes, hash=0x17ad313814d028ff) + [p] v4:sys:blocks.f18 (6112 bytes, hash=0x09d361dbe6174236) + [p] v4:sys:input.f18 (10692 bytes, hash=0x0f13c3f9d5fd07fc) + [p] v4:sys:dict.f18 (13816 bytes, hash=0xe3453808afd5a0af) + [p] v4:sys:forth.f18 (12617 bytes, hash=0xc4c0ad315c95eda4) + [p] v4:sys:quit.f18 (32141 bytes, hash=0x7fa7a7668b6bf1ed) + [p] v4:sys:map-64.f18 (3254 bytes, hash=0x81bda2bfcf496f6a) + [p] v4:sys:codegen.f18 (4999 bytes, hash=0x36d2ae84d2911b90) + [p] v4:sys:acl.f18 (5303 bytes, hash=0x5ceb5b43b0c5fbb1) + [p] v4:sys:core.f18 (24370 bytes, hash=0x0f415502fccc3fba) + [p] v4:sys:system.f18 (10189 bytes, hash=0xfe257eb084c43a5d) + [p] v4:sys:numout.f18 (6641 bytes, hash=0xca0fb0f9c1589e20) + [p] v4:sys:words.f18 (9642 bytes, hash=0x2f4e5f7f3e7f736f) + [p] v4:sys:compile.f18 (23381 bytes, hash=0xbef95acf00cb404a) + [p] v4:sys:end.f18 (1604 bytes, hash=0x22eea18b132f8faf) + [p] v4:starshipos.4th (706 bytes, hash=0x1734a8f4fe7483a5) + [p] v4:hera.4th (1376 bytes, hash=0x78730b1d6effe892) + [p] v4:rom:sym.f18 (5610 bytes, hash=0xbbad5748f5bbf863) + [p] v4:rom:main.f18 (2284 bytes, hash=0x6994f1f1d567e163) + [p] v4:rom:math.f18 (5108 bytes, hash=0x9be63ad87934622f) + [p] v4:rom:dir.f18 (5112 bytes, hash=0x51b069f0623ded16) + [p] v4:rom:num.f18 (2634 bytes, hash=0x08b76f1b058cac17) + [p] v4:rom:pack.f18 (4583 bytes, hash=0x65a944d8eb7de7f2) + [p] v4:rom:word.f18 (12966 bytes, hash=0x9210d6c2ac424d11) + [p] v4:rom:in.f18 (4230 bytes, hash=0x65798bed38a09f0f) + [p] v4:rom:mesh.f18 (449 bytes, hash=0x83723d76b9620c2c) + [p] v4:centre.4th (4140 bytes, hash=0x53b1e3df644e8e25) + [p] README.md (2305 bytes, hash=0x09a684ebdfbeb01c) + [p] block-acl.4th (980 bytes, hash=0xf6cc2a59e3a6734e) + [p] sdk.4th (2295 bytes, hash=0x008fdbbb62c94a3a) + [p] pki:starshipos-intermediate.der (408 bytes, hash=0xb40aab540c19f877) + [p] init-l8-omni.4th (1986 bytes, hash=0x5979e314d6452045) + [p] acl-std79.4th (5040 bytes, hash=0x773bf9209df191d1) + [p] doe-campaign.4th (2369 bytes, hash=0x26fb485e5c9dc6ff) + [p] init-l8-volatile.4th (718 bytes, hash=0x98caabbbd92abac4) + [p] doe.4th (3244 bytes, hash=0xf154616d248e861f) + [p] fabric.4th (10359 bytes, hash=0x9d9489cbeca4099b) + [p] workload-4.4th (469 bytes, hash=0x099619264e650b1c) + [p] init-l8-temporal.4th (363 bytes, hash=0x51abd4c138246651) + [p] workload-5.4th (480 bytes, hash=0x526964c7c9506a11) + [p] fonts:README.md (1846 bytes, hash=0xf628c2b7a49f4d46) + [p] fonts:JetBrainsMono-Regular.ttf (270224 bytes, hash=0xf4b7077dab274e6b) + [p] init-l8-transition.4th (529 bytes, hash=0xbcc1a81976f0a4c9) + [p] workload-2.4th (1321 bytes, hash=0xf113b3d0bcccae47) + [p] workload-1.4th (1041 bytes, hash=0x63e251adb0a03613) + [p] workload-5-lite.4th (468 bytes, hash=0xea0303f38824f254) + [p] workload-0.4th (290 bytes, hash=0x93f86f60aeba8feb) + [p] artemis:init.4th (16782 bytes, hash=0x7ba120e2a6aab239) + [p] MANIFEST.md (35813 bytes, hash=0x9d3a6fdb7415d224) + [p] workload-7.4th (206 bytes, hash=0x02862291387eb7ac) + [p] BLOCK_MAP.md (22886 bytes, hash=0x86df913cdae857c6) + [p] turtle.4th (3254 bytes, hash=0x4d470418ca543365) + [p] workload-8.4th (172 bytes, hash=0x56b7f2f0efa000df) + [p] workload-6.4th (1986 bytes, hash=0x06fc0ce1e369ef5a) +mkcapsule: 76 capsule(s) collected +CC (loader) v3/src/blkio_ram.c +CC (loader) v3/src/block_subsystem.c +CC (loader) v3/src/compudynamics.c +mkcapsule: wrote build/amd64/kernel/capsule_generated.c + MKCAP capsules -> capsules/BLOCK_MAP.md +mkcapsule: manifest written to capsules/BLOCK_MAP.md (42 capsule(s)) +CC (loader) v3/src/dictionary_heat_optimization.c +CC (loader) v3/src/dictionary_management.c +CC (loader) v3/src/heartbeat_export.c +CC (loader) v3/src/inference_engine.c +CC (loader) v3/src/io.c +CC (loader) v3/src/math_portable.c +CC (loader) v3/src/memory_management.c +CC (loader) v3/src/physics_execution_hooks.c +CC (loader) v3/src/physics_hotwords_cache.c +CC (loader) v3/src/physics_metadata.c +CC (loader) v3/src/physics_pipelining_metrics.c +CC (loader) v3/src/physics_runtime.c +CC (loader) v3/src/profiler.c +CC (loader) v3/src/rolling_window_of_truth.c +CC (loader) v3/src/ssm_jacquard.c +CC (loader) v3/src/stack_management.c +CC (loader) v3/src/vm_api.c +CC (loader) v3/src/vm_debug.c +CC (loader) v3/src/word_registry.c +CC (loader) v3/src/word_source/acl_words.c +CC (loader) v3/src/word_source/arithmetic_words.c +CC (loader) v3/src/word_source/block_words.c +CC (loader) v3/src/word_source/control_words.c +CC (loader) v3/src/word_source/defer_words.c +CC (loader) v3/src/word_source/defining_words.c +CC (loader) v3/src/word_source/dictionary_heat_diagnostic_words.c +CC (loader) v3/src/word_source/dictionary_manipulation_words.c +CC (loader) v3/src/word_source/dictionary_words.c +CC (loader) v3/src/word_source/double_words.c +CC (loader) v3/src/word_source/editor_words.c +CC (loader) v3/src/word_source/format_words.c +CC (loader) v3/src/word_source/framebuffer_words.c +CC (loader) v3/src/word_source/inference_words.c +CC (loader) v3/src/word_source/io_words.c +CC (loader) v3/src/word_source/keyboard_words.c +CC (loader) v3/src/word_source/lifecycle_words_hosted.c +CC (loader) v3/src/word_source/log_words.c +CC (loader) v3/src/word_source/logical_words.c +CC (loader) v3/src/word_source/memory_words.c +CC (loader) v3/src/word_source/mixed_arithmetic_words.c +CC (loader) v3/src/word_source/physics_benchmark_words.c +CC (loader) v3/src/word_source/physics_diagnostic_words.c +CC (loader) v3/src/word_source/physics_freeze_words.c +CC (loader) v3/src/word_source/physics_pipelining_diagnostic_words.c +CC (loader) v3/src/word_source/q48_words.c +CC (loader) v3/src/word_source/return_stack_words.c +CC (loader) v3/src/word_source/scroll_words.c +CC (loader) v3/src/word_source/stack_words.c +CC (loader) v3/src/word_source/starforth_words.c +CC (loader) v3/src/word_source/string_words.c +CC (loader) v3/src/word_source/system_words.c +CC (loader) v3/src/word_source/ttf_words.c +CC (loader) v3/src/word_source/vocabulary_words.c +CC (loader) v3/src/test_runner/test_common.c +CC (loader) v3/src/test_runner/test_contracts.c +CC (loader) v3/src/test_runner/test_runner.c +CC (loader) v3/src/test_runner/modules/acl_words_test.c +CC (loader) v3/src/test_runner/modules/arithmetic_words_test.c +CC (loader) v3/src/test_runner/modules/block_words_test.c +CC (loader) v3/src/test_runner/modules/control_words_test.c +CC (loader) v3/src/test_runner/modules/defining_words_tests.c +CC (loader) v3/src/test_runner/modules/dictionary_manipulation_words_test.c +CC (loader) v3/src/test_runner/modules/dictionary_words_test.c +CC (loader) v3/src/test_runner/modules/double_words_test.c +CC (loader) v3/src/test_runner/modules/format_words_test.c +CC (loader) v3/src/test_runner/modules/inference_words_test.c +CC (loader) v3/src/test_runner/modules/integration_tests.c +CC (loader) v3/src/test_runner/modules/io_words_test.c +CC (loader) v3/src/test_runner/modules/logical_words_test.c +CC (loader) v3/src/test_runner/modules/mama_forth_words_test.c +CC (loader) v3/src/test_runner/modules/memory_words_test.c +CC (loader) v3/src/test_runner/modules/mixed_arithmetic_words_test.c +CC (loader) v3/src/test_runner/modules/physics_freeze_words_test.c +CC (loader) v3/src/test_runner/modules/q48_words_test.c +CC (loader) v3/src/test_runner/modules/return_stack_words_test.c +CC (loader) v3/src/test_runner/modules/stack_words_test.c +CC (loader) v3/src/test_runner/modules/starforth_words_test.c +CC (loader) v3/src/test_runner/modules/stress_tests.c +CC (loader) v3/src/test_runner/modules/string_words_test.c +CC (loader) v3/src/test_runner/modules/system_words_test.c +CC (loader) v3/src/test_runner/modules/vocabulary_words_test.c +CC (loader) build/amd64/kernel/v4_map_64.c + CC build/amd64/kernel/capsule_generated.c + CC (kernel) build/amd64/kernel/capsule_generated.c +LD (kernel) build/amd64/kernel/starkernel_kernel.elf +ld: warning: build/amd64/kernel/obj/kernel/arch/amd64/switch.o: missing .note.GNU-stack section implies executable stack +ld: NOTE: This behaviour is deprecated and will be removed in a future version of the linker +Kernel built: build/amd64/kernel/starkernel_kernel.elf +LD (loader PE) build/amd64/kernel/starkernel_loader.efi +Loader built: build/amd64/kernel/starkernel_loader.efi +StarKernel built successfully for amd64 + Loader: build/amd64/kernel/starkernel_loader.efi + Kernel: build/amd64/kernel/starkernel_kernel.elf +rc=0 diff --git a/logs/20261119-acl-at-call/san-mesh-boot.log b/logs/20261119-acl-at-call/san-mesh-boot.log new file mode 100644 index 00000000..26a17b9b --- /dev/null +++ b/logs/20261119-acl-at-call/san-mesh-boot.log @@ -0,0 +1,4 @@ + [ASan+UBSan mesh boot, V4_CELL_BITS=64] +v4 mesh boot: V4_CELL_BITS=64 + PARITY:V4_POST tests=990 pass=990 fail=0 + 120 checks, 0 failures diff --git a/logs/20261119-acl-at-call/sanitize.log b/logs/20261119-acl-at-call/sanitize.log new file mode 100644 index 00000000..c2ed974c --- /dev/null +++ b/logs/20261119-acl-at-call/sanitize.log @@ -0,0 +1,2 @@ + 3112 checks, 0 failures + 1360 checks, 0 failures diff --git a/logs/20261119-acl-at-call/test-32.log b/logs/20261119-acl-at-call/test-32.log new file mode 100644 index 00000000..88b6930c --- /dev/null +++ b/logs/20261119-acl-at-call/test-32.log @@ -0,0 +1,272 @@ + [V4_CELL_BITS=32 run-32-test_asm.c] +v4 asm tests: V4_CELL_BITS=32 + 32 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_cells.c] +v4 single-cell word tests: V4_CELL_BITS=32 + code: 99 of 1024 words + NIP headroom: data 7 below canary, return 7 below its return address + SWAP headroom: data 6 below canary, return 6 below its return address + ROT headroom: data 5 below canary, return 4 below its return address + -ROT headroom: data 5 below canary, return 5 below its return address + ?DUP headroom: data 7 below canary, return 8 below its return address + +! headroom: data 7 below canary, return 8 below its return address + -! headroom: data 7 below canary, return 8 below its return address + 2@ headroom: data 7 below canary, return 8 below its return address + 2! headroom: data 6 below canary, return 6 below its return address + - headroom: data 6 below canary, return 8 below its return address + MIN headroom: data 3 below canary, return 6 below its return address + MAX headroom: data 3 below canary, return 6 below its return address + OR headroom: data 6 below canary, return 8 below its return address + 0> headroom: data 8 below canary, return 8 below its return address + <> headroom: data 7 below canary, return 8 below its return address + < headroom: data 5 below canary, return 7 below its return address + > headroom: data 5 below canary, return 6 below its return address + <= headroom: data 5 below canary, return 6 below its return address + >= headroom: data 5 below canary, return 6 below its return address + U< headroom: data 5 below canary, return 7 below its return address + WITHIN headroom: data 3 below canary, return 5 below its return address + 21420 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_console.c] +v4 console tests: V4_CELL_BITS=32, capture 4096 characters + 312 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_dump.c] +test_dump: 15 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_exec.c] +v4 exec tests: V4_CELL_BITS=32 + 3109 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_fabric.c] +v4 fabric tests: V4_CELL_BITS=32, 8 ports to a node + 334 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_fabric_walk.c] +v4 fabric walk tests + 13 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_foundation.c] +v4 foundation tests: V4_CELL_BITS=32 + code: 949 of 1024 words + Q.+ random cases that overflow Q48.16: 2682 of 20000 + Q.> as written (SWAP D<): 11702 wrong of 20169 + (UQ/) cases run: 8687 + UM* headroom: data 5 below canary, return 6 below its return address + UM/MOD headroom: data 5 below canary, return 6 below its return address + ABS headroom: data 7 below canary, return 7 below its return address + U> headroom: data 5 below canary, return 5 below its return address + D+ headroom: data 5 below canary, return 5 below its return address + DNEGATE headroom: data 6 below canary, return 7 below its return address + DABS headroom: data 6 below canary, return 6 below its return address + M+ headroom: data 5 below canary, return 4 below its return address + M- headroom: data 4 below canary, return 5 below its return address + M* headroom: data 5 below canary, return 4 below its return address + M/MOD headroom: data 4 below canary, return 3 below its return address + MOD headroom: data 4 below canary, return 2 below its return address + */MOD headroom: data 4 below canary, return 2 below its return address + */ headroom: data 4 below canary, return 2 below its return address + D0< headroom: data 7 below canary, return 7 below its return address + D2* headroom: data 6 below canary, return 7 below its return address + D2/ headroom: data 7 below canary, return 7 below its return address + 2ROT headroom: data 2 below canary, return 1 below its return address + D- headroom: data 4 below canary, return 4 below its return address + D0= headroom: data 6 below canary, return 7 below its return address + D= headroom: data 4 below canary, return 3 below its return address + < headroom: data 5 below canary, return 7 below its return address + = headroom: data 7 below canary, return 7 below its return address + D< headroom: data 3 below canary, return 3 below its return address + (D<) headroom: data 2 below canary, return 5 below its return address + 2SWAP headroom: data 4 below canary, return 4 below its return address + 2OVER headroom: data 2 below canary, return 3 below its return address + DMAX headroom: data 2 below canary, return 4 below its return address + DMIN headroom: data 2 below canary, return 4 below its return address + Q.> (2SWAP D<) headroom: data 3 below canary, return 2 below its return address + Q.* headroom: data 2 below canary, return 3 below its return address + (UQ/) headroom: data 3 below canary, return 4 below its return address + Q./ headroom: data 2 below canary, return 3 below its return address + Q.EXP headroom: data 2 below canary, return 2 below its return address + Q.SQRT headroom: data 2 below canary, return 2 below its return address + Q.LOG headroom: data 2 below canary, return 2 below its return address + (Q.REDUCE) headroom: data 4 below canary, return 5 below its return address + Q.SIN headroom: data 2 below canary, return 2 below its return address + Q.COS headroom: data 2 below canary, return 2 below its return address + LSHIFT headroom: data 6 below canary, return 5 below its return address + RSHIFT headroom: data 6 below canary, return 5 below its return address + C@ headroom: data 7 below canary, return 7 below its return address + C! headroom: data 6 below canary, return 7 below its return address + SM/REM headroom: data 4 below canary, return 3 below its return address + /MOD headroom: data 4 below canary, return 2 below its return address + / headroom: data 4 below canary, return 2 below its return address + * headroom: data 5 below canary, return 5 below its return address + 1023754 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_guard.c] +v4 guard tests: V4_CELL_BITS=32, data bound 1, return bound 1 + 60 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_heat.c] +v4 heat tests: V4_CELL_BITS=32 + 67 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_blocks.c] +v4 block request tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + 52 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_codegen.c] +v4 host code generator tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + code: 1728 words + 856 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_compile.c] +v4 host compiler tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + capsule: 4562 words + a line may have 270 values on the stack while the interpreter reads its next word + a word run from the interpreter has 29 return entries to itself + defining and running a word leaves 1017 data cells under it untouched + 1096 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_depth.c] +v4 mesh depth tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + a text that prints 1012..1024 values: works to 1020, then a stack error and nothing else; calls: works to 23 deep; 19 worked, 14 clean errors, 0 failures + SEND 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 26 deep; 20 worked, 13 clean errors, 0 failures + SEND with no way 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 27 deep; 21 worked, 12 clean errors, 0 failures + AWAIT answered 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + AWAIT ended by a GONE 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + passing on while its text waits for room 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + AWAIT broken by a line from the console 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + a refusal while its text waits for room 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + GONE 1012..1024 values: works to 1019, then a stack error and nothing else; calls: works to 26 deep; 21 worked, 12 clean errors, 0 failures + a spent message refused while its text waits 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + 330 runs: 168 worked, 162 ended in a stack error and nothing else, 0 did neither + 397 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_dict.c] +v4 host dictionary tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + code: 1633 words + 300 entries in 2218 cells + FIND headroom: data 1020 below canary, return 28 below its return address + (') headroom: data 1020 below canary, return 28 below its return address + MAKE headroom: data 1020 below canary, return 28 below its return address + , headroom: data 1020 below canary, return 31 below its return address + ALLOT headroom: data 1020 below canary, return 30 below its return address + 708 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_input.c] +v4 host input tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + code: 1108 words + WORD headroom: data 1020 below canary, return 29 below its return address + NUMBER headroom: data 1016 below canary, return 25 below its return address + EXPECT headroom: data 1020 below canary, return 30 below its return address + ENCLOSE headroom: data 1017 below canary, return 28 below its return address + 6569 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_mesh.c] +v4 mesh tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + the flood: 268 sends tried: 2 refused at once, 121 let go on the way, 145 done; 1 of the two texts that set a node sending let go; (LOST) 122, (REFUSED) 124 + between texts the nucleus used at most 3 cells of the data stack and 4 entries of the return stack + a node removed or a wire cut: 19983 times in all + 244 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_node.c] +v4 host node tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + 45 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_quit.c] +v4 host prompt tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + capsule: 7426 words + from the prompt, words may call each other 30 deep + 1020 values may wait on the stack while the next line is typed and interpreted + defining and running a word from the prompt leaves 1017 data cells under it untouched + .S prints a stack of up to 1018 values; it needs 6 cells free + WORDS: 318 names, longest line 74 columns + 1356 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_asm.c] +test_host_rom_asm: 466 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_in.c] +test_host_rom_in: 26 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_math.c] +v4 ROM math tests: V4_CELL_BITS=32 + the host ROM: 2383 words; the mesh ROM: 265 words + 156 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_nucleus.c] + the ROM assembled the system: 63854391 instructions, 16656301 instruction words, 1.14 s (32-bit cells) +test_host_rom_nucleus: 6 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_num.c] +test_host_rom_num: 31 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_pack.c] +test_host_rom_pack: 7 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_range.c] +test_host_rom_range: 19 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_rom_sym.c] +test_host_rom_sym: 81 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_host_unit.c] +v4 unit tests: V4_CELL_BITS=32, V4_NODE_WORDS=32768 + not run at this width: the capsules are the 64-bit products' + [V4_CELL_BITS=32 run-32-test_iword.c] +v4 iword tests: V4_CELL_BITS=32 + 1763 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_loops.c] +v4 loop tests: V4_CELL_BITS=32 + code: 298 of 1024 words + loops run against C: 3008 (1696 more would run past 63 times and were left out) + DO .. LOOP headroom: data 5 below canary, return 6 below its return address + DO .. +LOOP headroom: data 5 below canary, return 6 below its return address + ?DO .. LOOP headroom: data 5 below canary, return 6 below its return address + DO .. LEAVE .. LOOP headroom: data 5 below canary, return 6 below its return address + nested DO, I and J headroom: data 5 below canary, return 4 below its return address + 3104 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_manage.c] +v4 manage tests: V4_CELL_BITS=32 + 78 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_node.c] +v4 node tests: V4_CELL_BITS=32, 1024 words + node: 1024 words + 52 head + 52 tail boundary (10.2% overhead) + 1078 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_numout.c] +v4 number-output tests: V4_CELL_BITS=32 + code: 382 of 1024 words + SPACES headroom: data 6 below canary, return 7 below its return address + . headroom: data 3 below canary, return 2 below its return address + .R headroom: data 3 below canary, return 2 below its return address + U. headroom: data 3 below canary, return 3 below its return address + U.R headroom: data 3 below canary, return 3 below its return address + D. headroom: data 3 below canary, return 2 below its return address + D.R headroom: data 3 below canary, return 2 below its return address + 25242 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_pictured.c] +v4 pictured-output tests: V4_CELL_BITS=32 + <# #S #> headroom: data 3 below canary, return 3 below its return address + signed picture headroom: data 3 below canary, return 2 below its return address + 4716 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_port.c] +v4 port tests: V4_CELL_BITS=32 + 25 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_printing.c] +v4 printing tests (? Q.PRINT DUMP BASE HLD): V4_CELL_BITS=32 + code: 506 of 1024 words + DECIMAL headroom: data 7 below canary, return 8 below its return address + ? headroom: data 3 below canary, return 2 below its return address + Q.PRINT headroom: data 3 below canary, return 3 below its return address + DUMP headroom: data 3 below canary, return 4 below its return address + 13439 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_stack.c] +v4 stack tests: V4_CELL_BITS=32, data depth 10, return depth 9 + exhaustive: 2046 sequences of length <= 10 + differential: 200000 ops + 730137 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_strings.c] +v4 string tests: V4_CELL_BITS=32 + code: 234 of 1024 words + COUNT headroom: data 6 below canary, return 6 below its return address + CMOVE headroom: data 4 below canary, return 5 below its return address + CMOVE> headroom: data 3 below canary, return 5 below its return address + MOVE headroom: data 5 below canary, return 6 below its return address + FILL headroom: data 4 below canary, return 5 below its return address + BLANK headroom: data 4 below canary, return 5 below its return address + -TRAILING headroom: data 5 below canary, return 6 below its return address + COMPARE headroom: data 3 below canary, return 5 below its return address + SEARCH headroom: data 2 below canary, return 5 below its return address + SCAN headroom: data 4 below canary, return 5 below its return address + SKIP headroom: data 4 below canary, return 5 below its return address + 16729 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_terminal.c] +v4 terminal-output tests: V4_CELL_BITS=32 + KEY headroom: data 8 below canary + EMIT headroom: data 7 below canary, return 8 below its return address + CR headroom: data 7 below canary, return 8 below its return address + TYPE headroom: data 5 below canary, return 6 below its return address + 1212 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_text.c] +v4 text assembler tests: V4_CELL_BITS=32 + 240 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_umul.c] +v4 umul tests: V4_CELL_BITS=32 + 2009 checks, 0 failures + [V4_CELL_BITS=32 run-32-test_wire.c] +v4 wire tests: V4_CELL_BITS=32, 1024 cells to a queue + 112 checks, 0 failures +rc=0 diff --git a/logs/20261119-acl-at-call/test-64.log b/logs/20261119-acl-at-call/test-64.log new file mode 100644 index 00000000..fb1a688a --- /dev/null +++ b/logs/20261119-acl-at-call/test-64.log @@ -0,0 +1,281 @@ + [V4_CELL_BITS=64 run-64-test_asm.c] +v4 asm tests: V4_CELL_BITS=64 + 32 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_cells.c] +v4 single-cell word tests: V4_CELL_BITS=64 + code: 99 of 1024 words + NIP headroom: data 7 below canary, return 7 below its return address + SWAP headroom: data 6 below canary, return 6 below its return address + ROT headroom: data 5 below canary, return 4 below its return address + -ROT headroom: data 5 below canary, return 5 below its return address + ?DUP headroom: data 7 below canary, return 8 below its return address + +! headroom: data 7 below canary, return 8 below its return address + -! headroom: data 7 below canary, return 8 below its return address + 2@ headroom: data 7 below canary, return 8 below its return address + 2! headroom: data 6 below canary, return 6 below its return address + - headroom: data 6 below canary, return 8 below its return address + MIN headroom: data 3 below canary, return 6 below its return address + MAX headroom: data 3 below canary, return 6 below its return address + OR headroom: data 6 below canary, return 8 below its return address + 0> headroom: data 8 below canary, return 8 below its return address + <> headroom: data 7 below canary, return 8 below its return address + < headroom: data 5 below canary, return 7 below its return address + > headroom: data 5 below canary, return 6 below its return address + <= headroom: data 5 below canary, return 6 below its return address + >= headroom: data 5 below canary, return 6 below its return address + U< headroom: data 5 below canary, return 7 below its return address + WITHIN headroom: data 3 below canary, return 5 below its return address + 21420 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_console.c] +v4 console tests: V4_CELL_BITS=64, capture 4096 characters + 312 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_dump.c] +test_dump: 15 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_exec.c] +v4 exec tests: V4_CELL_BITS=64 + 3112 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_fabric.c] +v4 fabric tests: V4_CELL_BITS=64, 8 ports to a node + 334 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_fabric_walk.c] +v4 fabric walk tests + 13 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_foundation.c] +v4 foundation tests: V4_CELL_BITS=64 + code: 949 of 1024 words + Q.+ random cases that overflow Q48.16: 2682 of 20000 + Q.> as written (SWAP D<): 12834 wrong of 20169 + (UQ/) cases run: 9000 + UM* headroom: data 5 below canary, return 6 below its return address + UM/MOD headroom: data 5 below canary, return 6 below its return address + ABS headroom: data 7 below canary, return 7 below its return address + U> headroom: data 5 below canary, return 5 below its return address + D+ headroom: data 5 below canary, return 5 below its return address + DNEGATE headroom: data 6 below canary, return 7 below its return address + DABS headroom: data 6 below canary, return 6 below its return address + M+ headroom: data 5 below canary, return 4 below its return address + M- headroom: data 4 below canary, return 5 below its return address + M* headroom: data 5 below canary, return 4 below its return address + M/MOD headroom: data 4 below canary, return 3 below its return address + MOD headroom: data 4 below canary, return 2 below its return address + */MOD headroom: data 4 below canary, return 2 below its return address + */ headroom: data 4 below canary, return 2 below its return address + D0< headroom: data 7 below canary, return 7 below its return address + D2* headroom: data 6 below canary, return 7 below its return address + D2/ headroom: data 7 below canary, return 7 below its return address + 2ROT headroom: data 2 below canary, return 1 below its return address + D- headroom: data 4 below canary, return 4 below its return address + D0= headroom: data 6 below canary, return 7 below its return address + D= headroom: data 4 below canary, return 3 below its return address + < headroom: data 5 below canary, return 7 below its return address + = headroom: data 7 below canary, return 7 below its return address + D< headroom: data 3 below canary, return 3 below its return address + (D<) headroom: data 2 below canary, return 5 below its return address + 2SWAP headroom: data 4 below canary, return 4 below its return address + 2OVER headroom: data 2 below canary, return 3 below its return address + DMAX headroom: data 2 below canary, return 4 below its return address + DMIN headroom: data 2 below canary, return 4 below its return address + Q.> (2SWAP D<) headroom: data 3 below canary, return 2 below its return address + Q.* headroom: data 2 below canary, return 3 below its return address + (UQ/) headroom: data 3 below canary, return 4 below its return address + Q./ headroom: data 2 below canary, return 3 below its return address + Q.EXP headroom: data 2 below canary, return 2 below its return address + Q.SQRT headroom: data 2 below canary, return 2 below its return address + Q.LOG headroom: data 2 below canary, return 2 below its return address + (Q.REDUCE) headroom: data 4 below canary, return 5 below its return address + Q.SIN headroom: data 2 below canary, return 2 below its return address + Q.COS headroom: data 2 below canary, return 2 below its return address + LSHIFT headroom: data 6 below canary, return 5 below its return address + RSHIFT headroom: data 6 below canary, return 5 below its return address + C@ headroom: data 7 below canary, return 7 below its return address + C! headroom: data 6 below canary, return 7 below its return address + SM/REM headroom: data 4 below canary, return 3 below its return address + /MOD headroom: data 4 below canary, return 2 below its return address + / headroom: data 4 below canary, return 2 below its return address + * headroom: data 5 below canary, return 5 below its return address + 1024904 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_guard.c] +v4 guard tests: V4_CELL_BITS=64, data bound 1, return bound 1 + 60 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_heat.c] +v4 heat tests: V4_CELL_BITS=64 + 67 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_blocks.c] +v4 block request tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + 54 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_codegen.c] +v4 host code generator tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + code: 1728 words + 856 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_compile.c] +v4 host compiler tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + capsule: 4562 words + a line may have 270 values on the stack while the interpreter reads its next word + a word run from the interpreter has 29 return entries to itself + defining and running a word leaves 1017 data cells under it untouched + 1096 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_depth.c] +v4 mesh depth tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + a text that prints 1012..1024 values: works to 1020, then a stack error and nothing else; calls: works to 23 deep; 19 worked, 14 clean errors, 0 failures + SEND 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 26 deep; 20 worked, 13 clean errors, 0 failures + SEND with no way 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 27 deep; 21 worked, 12 clean errors, 0 failures + AWAIT answered 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + AWAIT ended by a GONE 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + passing on while its text waits for room 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + AWAIT broken by a line from the console 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 24 deep; 18 worked, 15 clean errors, 0 failures + a refusal while its text waits for room 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + GONE 1012..1024 values: works to 1019, then a stack error and nothing else; calls: works to 26 deep; 21 worked, 12 clean errors, 0 failures + a spent message refused while its text waits 1012..1024 values: works to 1018, then a stack error and nothing else; calls: works to 17 deep; 11 worked, 22 clean errors, 0 failures + 330 runs: 168 worked, 162 ended in a stack error and nothing else, 0 did neither + 397 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_dict.c] +v4 host dictionary tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + code: 1633 words + 300 entries in 2218 cells + FIND headroom: data 1020 below canary, return 28 below its return address + (') headroom: data 1020 below canary, return 28 below its return address + MAKE headroom: data 1020 below canary, return 28 below its return address + , headroom: data 1020 below canary, return 31 below its return address + ALLOT headroom: data 1020 below canary, return 30 below its return address + 708 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_input.c] +v4 host input tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + code: 1108 words + WORD headroom: data 1020 below canary, return 29 below its return address + NUMBER headroom: data 1016 below canary, return 25 below its return address + EXPECT headroom: data 1020 below canary, return 30 below its return address + ENCLOSE headroom: data 1017 below canary, return 28 below its return address + 6569 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_mesh.c] +v4 mesh tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + the flood: 268 sends tried: 2 refused at once, 121 let go on the way, 145 done; 1 of the two texts that set a node sending let go; (LOST) 122, (REFUSED) 124 + between texts the nucleus used at most 3 cells of the data stack and 4 entries of the return stack + a node removed or a wire cut: 26895 times in all + 244 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_node.c] +v4 host node tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + 45 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_quit.c] +v4 host prompt tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + capsule: 7426 words + got: "B ok\nok> A ok\nok> 5 ok\nok> " + wanted: "WARN: ACL: denied 'FOO'\n ERROR\nok> UNKNOWN WORD: 'BAR'\n ERROR\nok> 4 ok\nok> " +FAIL /home/user/LithosAnanke/v4/tests/test_host_quit.c:976: session 187 + from the prompt, words may call each other 30 deep + 1020 values may wait on the stack while the next line is typed and interpreted + defining and running a word from the prompt leaves 1017 data cells under it untouched + .S prints a stack of up to 1018 values; it needs 6 cells free + got: "B ok\nok> " + wanted: "BWARN: ACL: denied 'FOO'\n ERROR\nok> " +FAIL /home/user/LithosAnanke/v4/tests/test_host_quit.c:1654: that word is refused, interpreted or compiled, and nothing else is + WORDS: 318 names, longest line 74 columns + 1360 checks, 2 failures +make: *** [Makefile:358: run-64-test_host_quit.c] Error 1 +RC-FAIL test_host_quit.c + [V4_CELL_BITS=64 run-64-test_host_rom_asm.c] +test_host_rom_asm: 472 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_in.c] +test_host_rom_in: 26 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_math.c] +v4 ROM math tests: V4_CELL_BITS=64 + the host ROM: 2383 words; the mesh ROM: 265 words + 156 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_nucleus.c] + the ROM assembled the system: 63864013 instructions, 16659023 instruction words, 0.98 s (64-bit cells) +test_host_rom_nucleus: 6 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_num.c] +test_host_rom_num: 31 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_pack.c] +test_host_rom_pack: 7 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_range.c] +test_host_rom_range: 19 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_rom_sym.c] +test_host_rom_sym: 81 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_host_unit.c] +v4 unit tests: V4_CELL_BITS=64, V4_NODE_WORDS=32768 + after POST and COLD: 212 of the 8302 cells below HERE differ from before POST (the first at 25); dict_hash differs + the four outer nodes: dict_hash=0xc8c659cdee409171 + 126 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_iword.c] +v4 iword tests: V4_CELL_BITS=64 + 1763 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_loops.c] +v4 loop tests: V4_CELL_BITS=64 + code: 298 of 1024 words + loops run against C: 3008 (1696 more would run past 63 times and were left out) + DO .. LOOP headroom: data 5 below canary, return 6 below its return address + DO .. +LOOP headroom: data 5 below canary, return 6 below its return address + ?DO .. LOOP headroom: data 5 below canary, return 6 below its return address + DO .. LEAVE .. LOOP headroom: data 5 below canary, return 6 below its return address + nested DO, I and J headroom: data 5 below canary, return 4 below its return address + 3104 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_manage.c] +v4 manage tests: V4_CELL_BITS=64 + 78 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_node.c] +v4 node tests: V4_CELL_BITS=64, 1024 words + node: 1024 words + 52 head + 52 tail boundary (10.2% overhead) + 1078 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_numout.c] +v4 number-output tests: V4_CELL_BITS=64 + code: 382 of 1024 words + SPACES headroom: data 6 below canary, return 7 below its return address + . headroom: data 3 below canary, return 2 below its return address + .R headroom: data 3 below canary, return 2 below its return address + U. headroom: data 3 below canary, return 3 below its return address + U.R headroom: data 3 below canary, return 3 below its return address + D. headroom: data 3 below canary, return 2 below its return address + D.R headroom: data 3 below canary, return 2 below its return address + 25242 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_pictured.c] +v4 pictured-output tests: V4_CELL_BITS=64 + <# #S #> headroom: data 3 below canary, return 3 below its return address + signed picture headroom: data 3 below canary, return 2 below its return address + 4716 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_port.c] +v4 port tests: V4_CELL_BITS=64 + 25 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_printing.c] +v4 printing tests (? Q.PRINT DUMP BASE HLD): V4_CELL_BITS=64 + code: 506 of 1024 words + DECIMAL headroom: data 7 below canary, return 8 below its return address + ? headroom: data 3 below canary, return 2 below its return address + Q.PRINT headroom: data 3 below canary, return 3 below its return address + DUMP headroom: data 3 below canary, return 4 below its return address + 13439 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_stack.c] +v4 stack tests: V4_CELL_BITS=64, data depth 10, return depth 9 + exhaustive: 2046 sequences of length <= 10 + differential: 200000 ops + 730137 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_strings.c] +v4 string tests: V4_CELL_BITS=64 + code: 234 of 1024 words + COUNT headroom: data 6 below canary, return 6 below its return address + CMOVE headroom: data 4 below canary, return 5 below its return address + CMOVE> headroom: data 3 below canary, return 5 below its return address + MOVE headroom: data 5 below canary, return 6 below its return address + FILL headroom: data 4 below canary, return 5 below its return address + BLANK headroom: data 4 below canary, return 5 below its return address + -TRAILING headroom: data 5 below canary, return 6 below its return address + COMPARE headroom: data 3 below canary, return 5 below its return address + SEARCH headroom: data 2 below canary, return 5 below its return address + SCAN headroom: data 4 below canary, return 5 below its return address + SKIP headroom: data 4 below canary, return 5 below its return address + 16729 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_terminal.c] +v4 terminal-output tests: V4_CELL_BITS=64 + KEY headroom: data 8 below canary + EMIT headroom: data 7 below canary, return 8 below its return address + CR headroom: data 7 below canary, return 8 below its return address + TYPE headroom: data 5 below canary, return 6 below its return address + 1212 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_text.c] +v4 text assembler tests: V4_CELL_BITS=64 + 240 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_umul.c] +v4 umul tests: V4_CELL_BITS=64 + 2808 checks, 0 failures + [V4_CELL_BITS=64 run-64-test_wire.c] +v4 wire tests: V4_CELL_BITS=64, 1024 cells to a queue + 112 checks, 0 failures diff --git a/logs/20261119-acl-at-call/test_exec-after.log b/logs/20261119-acl-at-call/test_exec-after.log new file mode 100644 index 00000000..62e7cf4e --- /dev/null +++ b/logs/20261119-acl-at-call/test_exec-after.log @@ -0,0 +1,3 @@ + [V4_CELL_BITS=64 run-64-test_exec.c] +v4 exec tests: V4_CELL_BITS=64 + 3112 checks, 0 failures diff --git a/logs/20261119-acl-at-call/test_exec-before.log b/logs/20261119-acl-at-call/test_exec-before.log new file mode 100644 index 00000000..948fe455 --- /dev/null +++ b/logs/20261119-acl-at-call/test_exec-before.log @@ -0,0 +1,9 @@ +/home/user/LithosAnanke/v4/tests/test_exec.c: In function 'test_call_hook_sees_every_call': +/home/user/LithosAnanke/v4/tests/test_exec.c:616:16: error: assignment to 'v4_call_hook' {aka 'void (*)(void *, v4_node *, long int)'} from incompatible pointer type 'v4_cell (*)(void *, v4_node *, v4_cell)' {aka 'long int (*)(void *, v4_node *, long int)'} [-Werror=incompatible-pointer-types] + 616 | es.on_call = record_call; es.on_call_ctx = (void *)&seen; + | ^ +/home/user/LithosAnanke/v4/tests/test_exec.c:637:16: error: assignment to 'v4_call_hook' {aka 'void (*)(void *, v4_node *, long int)'} from incompatible pointer type 'v4_cell (*)(void *, v4_node *, v4_cell)' {aka 'long int (*)(void *, v4_node *, long int)'} [-Werror=incompatible-pointer-types] + 637 | es.on_call = redirect_call; es.on_call_ctx = 0; + | ^ +cc1: all warnings being treated as errors +make: *** [Makefile:357: /home/user/LithosAnanke/v4/build/64-test_exec.c] Error 1 diff --git a/logs/20261119-acl-at-call/test_mesh_boot-after.log b/logs/20261119-acl-at-call/test_mesh_boot-after.log new file mode 100644 index 00000000..3ea00026 --- /dev/null +++ b/logs/20261119-acl-at-call/test_mesh_boot-after.log @@ -0,0 +1,83 @@ +mkcapsule: scanning /home/user/LithosAnanke/capsules + [p] zuse.4th (1684 bytes, hash=0x490ded9be257a90b) + [p] font.4th (17688 bytes, hash=0x3f305911500c78f6) + [p] MANIFEST_AUTO.md (11687 bytes, hash=0xe022545a0755960f) + [p] multiuser-doe.4th (3942 bytes, hash=0x22140588ee7c39e6) + [p] hestia:init.4th (891 bytes, hash=0x64e111990fbc45ff) + [p] contrib:README.md (1855 bytes, hash=0x4212e52b927793e7) + [p] ACL.4th (4318 bytes, hash=0xf8890c05c0d8f921) + [p] workload-3.4th (2189 bytes, hash=0x62b7a71576ad1041) + [p] init-l8-diverse.4th (430 bytes, hash=0xaa293201a6c91838) + [p] user-font-demo.4th (1674 bytes, hash=0xce1fd7d1b581a56d) + [p] workload-9.4th (1321 bytes, hash=0x3f2bec73142aa424) + [p] lib.4th (619 bytes, hash=0x4b216635c359ef73) + [p] workload-calib1.4th (304 bytes, hash=0x3b9f2d17b554fabc) + [m] init.4th (669 bytes, hash=0xd09db9461b336431) + [p] workload-1-lite.4th (540 bytes, hash=0x44a7a7e3176dcc8d) + [p] init-l8-stable.4th (278 bytes, hash=0xdc3830f189063a9a) + [p] v4:physics.4th (2953 bytes, hash=0x5b0195fc30828bde) + [p] v4:forth79.4th (1216 bytes, hash=0x4609d6ef54166ef8) + [p] v4:ACL.4th (2103 bytes, hash=0xdba5690fb0ee12a4) + [p] v4:init.4th (756 bytes, hash=0x13fe8932fa4d2934) + [p] v4:sys:log.f18 (4535 bytes, hash=0x544cd004233dff62) + [p] v4:sys:qmath.f18 (8607 bytes, hash=0xa93783c2c8f9b7db) + [p] v4:sys:map-32.f18 (3215 bytes, hash=0x17ad313814d028ff) + [p] v4:sys:blocks.f18 (6112 bytes, hash=0x09d361dbe6174236) + [p] v4:sys:input.f18 (10692 bytes, hash=0x0f13c3f9d5fd07fc) + [p] v4:sys:dict.f18 (13816 bytes, hash=0xe3453808afd5a0af) + [p] v4:sys:forth.f18 (12617 bytes, hash=0xc4c0ad315c95eda4) + [p] v4:sys:quit.f18 (32141 bytes, hash=0x7fa7a7668b6bf1ed) + [p] v4:sys:map-64.f18 (3254 bytes, hash=0x81bda2bfcf496f6a) + [p] v4:sys:codegen.f18 (4999 bytes, hash=0x36d2ae84d2911b90) + [p] v4:sys:acl.f18 (5303 bytes, hash=0x5ceb5b43b0c5fbb1) + [p] v4:sys:core.f18 (24370 bytes, hash=0x0f415502fccc3fba) + [p] v4:sys:system.f18 (10189 bytes, hash=0xfe257eb084c43a5d) + [p] v4:sys:numout.f18 (6641 bytes, hash=0xca0fb0f9c1589e20) + [p] v4:sys:words.f18 (9642 bytes, hash=0x2f4e5f7f3e7f736f) + [p] v4:sys:compile.f18 (23381 bytes, hash=0xbef95acf00cb404a) + [p] v4:sys:end.f18 (1604 bytes, hash=0x22eea18b132f8faf) + [p] v4:starshipos.4th (706 bytes, hash=0x1734a8f4fe7483a5) + [p] v4:hera.4th (1376 bytes, hash=0x78730b1d6effe892) + [p] v4:rom:sym.f18 (5610 bytes, hash=0xbbad5748f5bbf863) + [p] v4:rom:main.f18 (2284 bytes, hash=0x6994f1f1d567e163) + [p] v4:rom:math.f18 (5108 bytes, hash=0x9be63ad87934622f) + [p] v4:rom:dir.f18 (5112 bytes, hash=0x51b069f0623ded16) + [p] v4:rom:num.f18 (2634 bytes, hash=0x08b76f1b058cac17) + [p] v4:rom:pack.f18 (4583 bytes, hash=0x65a944d8eb7de7f2) + [p] v4:rom:word.f18 (12966 bytes, hash=0x9210d6c2ac424d11) + [p] v4:rom:in.f18 (4230 bytes, hash=0x65798bed38a09f0f) + [p] v4:rom:mesh.f18 (449 bytes, hash=0x83723d76b9620c2c) + [p] v4:centre.4th (4140 bytes, hash=0x53b1e3df644e8e25) + [p] README.md (2305 bytes, hash=0x09a684ebdfbeb01c) + [p] block-acl.4th (980 bytes, hash=0xf6cc2a59e3a6734e) + [p] sdk.4th (2295 bytes, hash=0x008fdbbb62c94a3a) + [p] pki:starshipos-intermediate.der (408 bytes, hash=0xb40aab540c19f877) + [p] init-l8-omni.4th (1986 bytes, hash=0x5979e314d6452045) + [p] acl-std79.4th (5040 bytes, hash=0x773bf9209df191d1) + [p] doe-campaign.4th (2369 bytes, hash=0x26fb485e5c9dc6ff) + [p] init-l8-volatile.4th (718 bytes, hash=0x98caabbbd92abac4) + [p] doe.4th (3244 bytes, hash=0xf154616d248e861f) + [p] fabric.4th (10359 bytes, hash=0x9d9489cbeca4099b) + [p] workload-4.4th (469 bytes, hash=0x099619264e650b1c) + [p] init-l8-temporal.4th (363 bytes, hash=0x51abd4c138246651) + [p] workload-5.4th (480 bytes, hash=0x526964c7c9506a11) + [p] fonts:README.md (1846 bytes, hash=0xf628c2b7a49f4d46) + [p] fonts:JetBrainsMono-Regular.ttf (270224 bytes, hash=0xf4b7077dab274e6b) + [p] init-l8-transition.4th (529 bytes, hash=0xbcc1a81976f0a4c9) + [p] workload-2.4th (1321 bytes, hash=0xf113b3d0bcccae47) + [p] workload-1.4th (1041 bytes, hash=0x63e251adb0a03613) + [p] workload-5-lite.4th (468 bytes, hash=0xea0303f38824f254) + [p] workload-0.4th (290 bytes, hash=0x93f86f60aeba8feb) + [p] artemis:init.4th (16782 bytes, hash=0x7ba120e2a6aab239) + [p] MANIFEST.md (35813 bytes, hash=0x9d3a6fdb7415d224) + [p] workload-7.4th (206 bytes, hash=0x02862291387eb7ac) + [p] BLOCK_MAP.md (22886 bytes, hash=0x86df913cdae857c6) + [p] turtle.4th (3254 bytes, hash=0x4d470418ca543365) + [p] workload-8.4th (172 bytes, hash=0x56b7f2f0efa000df) + [p] workload-6.4th (1986 bytes, hash=0x06fc0ce1e369ef5a) +mkcapsule: 76 capsule(s) collected +mkcapsule: wrote /home/user/LithosAnanke/v4/build/capsule_generated.c + [mesh boot, V4_CELL_BITS=64] +v4 mesh boot: V4_CELL_BITS=64 + PARITY:V4_POST tests=990 pass=990 fail=0 + 120 checks, 0 failures diff --git a/logs/20261119-acl-at-call/test_mesh_boot-before.log b/logs/20261119-acl-at-call/test_mesh_boot-before.log new file mode 100644 index 00000000..ed7c4627 --- /dev/null +++ b/logs/20261119-acl-at-call/test_mesh_boot-before.log @@ -0,0 +1,12 @@ + [mesh boot, V4_CELL_BITS=64] +v4 mesh boot: V4_CELL_BITS=64 + PARITY:V4_POST tests=990 pass=990 fail=0 +FAIL /home/user/LithosAnanke/v4/tests/test_mesh_boot.c:171: a word called from a definition is checked at the call, and counted down: "A256 A256 " +FAIL /home/user/LithosAnanke/v4/tests/test_mesh_boot.c:173: a denied word called from a definition is refused at the call, by its own name: "A" +FAIL /home/user/LithosAnanke/v4/tests/test_mesh_boot.c:175: and does not run: "A" +FAIL /home/user/LithosAnanke/v4/tests/test_mesh_boot.c:177: a denied word can be compiled into a definition, as v3: "WARN: ACL: denied 'F1' +" (2) +FAIL /home/user/LithosAnanke/v4/tests/test_mesh_boot.c:179: and it is refused when the definition runs: "UNKNOWN WORD: 'G2' +" + 120 checks, 5 failures +make: *** [Makefile:380: mesh-boot] Error 1 diff --git a/logs/20261119-acl-at-call/timing.txt b/logs/20261119-acl-at-call/timing.txt new file mode 100644 index 00000000..c896aa26 --- /dev/null +++ b/logs/20261119-acl-at-call/timing.txt @@ -0,0 +1,10 @@ +OLD 1 15.194 s V4_POST tests=990 pass=990 114 checks, 0 failures +NEW 1 15.501 s V4_POST tests=990 pass=990 120 checks, 0 failures +OLD 2 15.057 s V4_POST tests=990 pass=990 114 checks, 0 failures +NEW 2 15.051 s V4_POST tests=990 pass=990 120 checks, 0 failures +OLD 3 15.618 s V4_POST tests=990 pass=990 114 checks, 0 failures +NEW 3 15.288 s V4_POST tests=990 pass=990 120 checks, 0 failures +OLD 4 15.227 s V4_POST tests=990 pass=990 114 checks, 0 failures +NEW 4 16.558 s V4_POST tests=990 pass=990 120 checks, 0 failures +OLD 5 15.989 s V4_POST tests=990 pass=990 114 checks, 0 failures +NEW 5 15.439 s V4_POST tests=990 pass=990 120 checks, 0 failures diff --git a/v4/include/v4/exec.h b/v4/include/v4/exec.h index f5ad86eb..f2826125 100644 --- a/v4/include/v4/exec.h +++ b/v4/include/v4/exec.h @@ -41,8 +41,11 @@ #include "v4/node.h" /* Called at `call` once the return address is pushed and before P moves to the - * target (so P is still the return address). NULL: no hook. */ -typedef void (*v4_call_hook)(void *ctx, v4_node *n, v4_cell target); + * target (so P is still the return address). It returns where P goes: the + * target, or another address the call is sent to instead, which returns to the + * caller as the target would (the ACL's check at call, docs/v4.0.0/plans/ + * 2026-11-19-acl-at-call.md). NULL: no hook, and P goes to the target. */ +typedef v4_cell (*v4_call_hook)(void *ctx, v4_node *n, v4_cell target); /* Called when an instruction retires, after HEAT-OP counts it, with its opcode (0..31): compudynamics on the * opcodes (#189 Phase 7, ruling 7). NULL: no hook. */ diff --git a/v4/include/v4/image.h b/v4/include/v4/image.h index 6d003dd4..6c599264 100644 --- a/v4/include/v4/image.h +++ b/v4/include/v4/image.h @@ -83,6 +83,10 @@ typedef struct { * defined at run time, from which a call is a word run; and where INTERPRET and EXECUTE make their calls */ v4_cell tokens, dict_lo, dict_hi, runx, exec; + /* the ACL's check at call (docs/v4.0.0/plans/2026-11-19-acl-at-call.md): the cell that holds (ACL-CALL)'s address, + * and the cell that is 1 while the policy rechecks a word */ + v4_cell acl_call, acl_busy; + /* the block window: the word address of the slots the kernel copies * blocks into (v4/blocks.h) */ v4_cell block_window; diff --git a/v4/src/exec.c b/v4/src/exec.c index 02f828d6..42736027 100644 --- a/v4/src/exec.c +++ b/v4/src/exec.c @@ -137,7 +137,7 @@ void v4_exec_op(v4_node *n, v4_exec_state *es, v4_heat *h, case V4_OP_CALL: x = v4_iword_branch(n->p, w, slot); v4_rstack_push(rs, n->p); - if (es->on_call) es->on_call(es->on_call_ctx, n, x); + if (es->on_call) x = es->on_call(es->on_call_ctx, n, x); n->p = x; break; case V4_OP_UNEXT: diff --git a/v4/system/mesh.c b/v4/system/mesh.c index 5f2bfd19..6b762b7a 100644 --- a/v4/system/mesh.c +++ b/v4/system/mesh.c @@ -695,7 +695,28 @@ static void heartbeat_cycle(unsigned place, v4_mesh_physics *p) /* at `call` (exec.h), on a word -- any other target, nothing -- in v3's order (physics_pre_execute, * V3-PARITY.md 2.1; Captain Bob, 2026-11-13: "Every call, as v3"): decay by the ticks since, heat +1, * the count the Stadium is charged by, the temperature, the rolling window */ -static void on_call(void *ctx, v4_node *n, v4_cell target) +/* The ACL's check at a call from code defined at run time (docs/v4.0.0/plans/2026-11-19-acl-at-call.md), as v3's + * inner interpreter: the word's flags cell (compile.f18: bit 5 denied, bits 16 .. 31 the TTL). An allowed word + * with TTL left is counted down here, and the call goes on; at a TTL of 0, or a denied word, the call is sent to + * (ACL-CALL), the target on the data stack, which rechecks or refuses it in FORTH and goes on to the word. While + * the policy rechecks a word ((ACL-BUSY) 1) nothing is checked, as v3 runs its policy with the check off. */ +static v4_cell acl_at_call(v4_node *n, const v4_image *im, v4_cell target) +{ + v4_cell flags, to; + if (im->acl_call <= 0 || im->acl_busy <= 0 || n->mem[im->acl_busy] != 0) return target; + to = n->mem[im->acl_call]; + if (to <= 0 || to >= (v4_cell)V4_NODE_WORDS || target < 4) return target; + flags = n->mem[target - 3]; + if ((flags & (v4_cell)0xFFFF0000) != 0 && (flags & 32) == 0) { + n->mem[target - 3] = flags - (v4_cell)0x10000; /* one use fewer */ + return target; + } + if (n->ds.depth >= V4_DATA_RING + 2u) return target; /* no room for the target: as no check */ + v4_dstack_push(&n->ds, target); + return to; +} + +static v4_cell on_call(void *ctx, v4_node *n, v4_cell target) { unsigned place = place_of_device(ctx); v4_cell id, ret = n->p; /* P is still the return address (exec.h) */ @@ -706,9 +727,9 @@ static void on_call(void *ctx, v4_node *n, v4_cell target) * system's own calls among its words (v3's are C) */ from_code = (ret >= im->dict_lo && ret < im->dict_hi) || ret == im->exec + 1; dispatched = ret == im->runx + 1; - if ((!from_code && !dispatched) || !is_word(place, target)) return; + if ((!from_code && !dispatched) || !is_word(place, target)) return target; id = n->mem[target - 4]; - if (id < 0 || id >= (v4_cell)V4_MESH_WORD_IDS) return; + if (id < 0 || id >= (v4_cell)V4_MESH_WORD_IDS) return target; a = &accounts_of(place)[id]; if (the->physics) { v4_mesh_physics *p = &the->physics[place]; @@ -731,6 +752,8 @@ static void on_call(void *ctx, v4_node *n, v4_cell target) } a->calls++; a->since++; + /* INTERPRET's own dispatch is checked by (ACL?) before it is made: only calls from code are checked here */ + return from_code ? acl_at_call(n, im, target) : target; } void v4_mesh_set_tick(v4_mesh *ms, uint64_t tick) diff --git a/v4/tests/host_map.h b/v4/tests/host_map.h index 2e770538..9706cf1d 100644 --- a/v4/tests/host_map.h +++ b/v4/tests/host_map.h @@ -127,8 +127,14 @@ #define ROM_IMG (BUF0_W - 119) /* idle, fault table, KEY, the word after KEY: 4 cells */ #define EXEC_W (BUF0_W - 22) /* (EXEC): EXECUTE's `call xt`, and the ; after it (compile.f18; #189) */ #define RUNX_W (BUF0_W - 115) /* (RUNX): INTERPRET's `call xt`, and the jump back (compile.f18; #189) */ -/* FREE, plain memory: BUF0_W - 113; BUF0_W - 144 .. - 141 (what a flush makes zero after - * a full output buffer); and OUT_W - 144 .. OUT_W - 65. They and +/* The ACL's check at call (docs/v4.0.0/plans/2026-11-19-acl-at-call.md): where (ACL-CALL) is, which the kernel sends + * a call to when the word's TTL is 0 or it is denied; and 1 while the policy rechecks a word, when the kernel checks + * nothing (v3's acl_recheck runs its policy so). A full output buffer's flush zeroes BUF0_W - 144 .. - 141: (ACL-BUSY) + * zeroed is only its default, and costs one more level of recheck at most. */ +#define ACL_CALL_W (BUF0_W - 113) /* (ACL-CALLX): the code address of (ACL-CALL), stored by end.f18 */ +#define ACL_BUSY_W (BUF0_W - 144) /* (ACL-BUSY): 1 while (ACL-RECHECK) runs the policy */ +/* FREE, plain memory: BUF0_W - 143 .. - 141 (what a flush makes zero after + * a full output buffer). They and * the cells above held the messages waiting, the refusals owed and what went with them (MESH.md 7a, 7b), which a * node no longer keeps. */ #define AWAIT_FROM (BUF0_W - 39) /* the node whose word of how text ended is waited for */ @@ -384,6 +390,8 @@ static unsigned host_branch_slots(void) X("HEAT-OP", HEAT_REG) \ X("(EXEC)", EXEC_W) \ X("(RUNX)", RUNX_W) \ + X("(ACL-CALLX)", ACL_CALL_W) \ + X("(ACL-BUSY)", ACL_BUSY_W) \ X("ANTICLOCK", HEAT_REG + 32) \ X("CFBASE", CFS_W) \ X("CFEND", CFS_W + CFS_CELLS) diff --git a/v4/tests/test_exec.c b/v4/tests/test_exec.c index c677b145..04eadfc7 100644 --- a/v4/tests/test_exec.c +++ b/v4/tests/test_exec.c @@ -575,12 +575,21 @@ static void test_address_faults(void) * is pushed and before P moves; with no hook the node runs exactly as before. */ static v4_cell seen[8]; static unsigned nseen, hook_bad; -static void record_call(void *ctx, v4_node *nd, v4_cell target) +static v4_cell record_call(void *ctx, v4_node *nd, v4_cell target) { if (ctx != (void *)&seen || nd != &n) hook_bad++; if (nd->p != nd->rs.r) hook_bad++; /* P not moved yet: still the return address */ if (nseen < 8) seen[nseen] = target; nseen++; + return target; /* the call goes where it was going */ +} +/* a hook that sends the call to 300 instead, when it is for 200 (the ACL's redirect, 2026-11-19) */ +static v4_cell redirect_call(void *ctx, v4_node *nd, v4_cell target) +{ + (void)ctx; (void)nd; + if (nseen < 8) seen[nseen] = target; + nseen++; + return target == 200 ? 300 : target; } static void call_programme(void) /* 100, 200, 100 again, 300; then a halt loop */ @@ -620,6 +629,21 @@ static void test_call_hook_sees_every_call(void) "with no hook the node runs the same (P %ld/%ld, depth %u/%u, retired %u/%u)", (long)p_plain, (long)p_hooked, depth_plain, depth_hooked, retired_plain, retired_hooked); CHECK(es.on_call == 0, "v4_exec_reset leaves no hook"); + + /* the hook may send the call elsewhere: where it returns is where P goes, and the return address is + * the one the call pushed, so the place it is sent to returns to the caller */ + call_programme(); + n.mem[300] = word6(V4_OP_SEMI, NOP, NOP, NOP, NOP, NOP); + es.on_call = redirect_call; es.on_call_ctx = 0; + nseen = 0; + v4_exec_step_word(&n, &es, &h); /* call 100, ; */ + v4_exec_step_word(&n, &es, &h); + v4_exec_step_word(&n, &es, &h); /* call 200 -- sent to 300 */ + CHECK(n.p == 300 && n.rs.depth == 1 && n.rs.r == 12, "a hook that returns 300 for a call to 200 sends it to 300 (P %ld, R %ld)", + (long)n.p, (long)n.rs.r); + v4_exec_step_word(&n, &es, &h); /* 300's ; */ + CHECK(n.p == 12 && n.rs.depth == 0, " which returns to the caller, after the call (P %ld)", (long)n.p); + v4_exec_reset(&es); } /* the hook at retire (#189 Phase 7, ruling 7: compudynamics on the opcodes): every retired instruction, its opcode, diff --git a/v4/tests/test_host_compile.c b/v4/tests/test_host_compile.c index 4b0dc6b8..00aed0b4 100644 --- a/v4/tests/test_host_compile.c +++ b/v4/tests/test_host_compile.c @@ -72,11 +72,12 @@ static void new_session(void) static int watching; static v4_cell called[4096]; static unsigned ncalled; -static void record_call(void *ctx, v4_node *nd, v4_cell target) +static v4_cell record_call(void *ctx, v4_node *nd, v4_cell target) { (void)ctx; (void)nd; if (ncalled < sizeof called / sizeof called[0]) called[ncalled] = target; ncalled++; + return target; } static unsigned times_called(v4_cell xt) { diff --git a/v4/tests/test_host_quit.c b/v4/tests/test_host_quit.c index c44b0830..19c598db 100644 --- a/v4/tests/test_host_quit.c +++ b/v4/tests/test_host_quit.c @@ -735,10 +735,12 @@ static const transcript script[] = { { "' DUP ACL-TTL@ . ' DUP ACL-MODE@ . ' DUP ACL-ALLOW@ . ' DUP ACL-PINNED? .\n", "0 0 -1 0 ok\nok> ", 1 }, { ": FOO 65 EMIT ; 5 ' FOO ACL-TTL! 0 ' FOO ACL-ALLOW! 1 2 FOO 66 EMIT\n.S ' FOO ACL-TTL@ .\n", "\033[33mWARN: \033[0mACL: denied 'FOO'\n ERROR\nok> <0> \n4 ok\nok> ", 1 }, - /* v4's own: the TTL is sixteen bits; a denied word cannot be compiled; with no policy a recheck allows */ + /* v4's own: the TTL is sixteen bits; with no policy a recheck allows. A denied word can be compiled, as v3 + * (2026-11-19): the check is at its call, which is the kernel's (v4/system/mesh.c; test_mesh_boot.c checks it), + * and this host node has no kernel watching its calls -- so here the definition runs it */ { ": BAZ 67 EMIT ; 0 ' BAZ ACL-ALLOW! BAZ ' BAZ ACL-TTL@ . ' BAZ ACL-ALLOW@ .\n", "C65535 -1 ok\nok> ", 0 }, { ": FOO 65 EMIT ; 5 ' FOO ACL-TTL! 0 ' FOO ACL-ALLOW! : BAR FOO ; 66 EMIT\nBAR\n' FOO ACL-TTL@ .\n", - "\033[33mWARN: \033[0mACL: denied 'FOO'\n ERROR\nok> UNKNOWN WORD: 'BAR'\n ERROR\nok> 4 ok\nok> ", 0 }, + "B ok\nok> A ok\nok> 5 ok\nok> ", 0 }, { ": FOO 65 EMIT ; : BAR FOO ; 5 ' FOO ACL-TTL! 0 ' FOO ACL-ALLOW! BAR\n", "A ok\nok> ", 0 }, { "99999 ' DUP ACL-TTL! ' DUP ACL-TTL@ . 65535 ' DUP ACL-TTL! ' DUP ACL-TTL@ .\n", "65535 65535 ok\nok> ", 0 }, { "258 ' DUP ACL-MODE! ' DUP ACL-MODE@ . 0 ' DUP ACL-ALLOW! ' DUP ACL-ALLOW@ .\n7 ' DUP ACL-ALLOW! ' DUP ACL-ALLOW@ . ' DUP ACL-TTL@ .\n", "2 0 ok\nok> -1 0 ok\nok> ", 0 }, @@ -1651,8 +1653,8 @@ int main(void) CHECK(is(say("0 ' FOO ACL-TTL! FOO\n"), "A ok\nok> "), "and when its TTL runs out the policy is asked again: this one allows"); CHECK(is(say(": NOFOO DUP ['] FOO = IF 0 SWAP ACL-ALLOW! ELSE ACL-RECHECK THEN ;\n"), " ok\nok> ") && is(say("' NOFOO ACL-HOOK ! 0 ' FOO ACL-TTL!\n"), " ok\nok> "), "a policy that denies one word"); - CHECK(is(say("69 EMIT FOO\n"), "E\033[33mWARN: \033[0mACL: denied 'FOO'\n ERROR\nok> ") && is(say("SFOO : G FOO ;\n"), "B\033[33mWARN: \033[0mACL: denied 'FOO'\n ERROR\nok> ") - && is(say("1 2 + . SFOO\n"), "3 B ok\nok> "), "that word is refused, interpreted or compiled, and nothing else is"); + CHECK(is(say("69 EMIT FOO\n"), "E\033[33mWARN: \033[0mACL: denied 'FOO'\n ERROR\nok> ") && is(say("SFOO : G FOO ;\n"), "B ok\nok> ") + && is(say("1 2 + . SFOO\n"), "3 B ok\nok> "), "that word is refused when it is interpreted, and nothing else is; compiling it is not checked, as v3"); CHECK(is(say("1 2 HERMES-CHANNEL-OPEN? . ACL-CA-KEY-LO . ' DUP ACL-ENTRY ' DUP = .\n"), "1 0 -1 ok\nok> "), "the rest of v3's policy file is there"); CHECK(is(say("COLD\n"), "FORTH-79 Cold Start\nSystem initialized.\n ok\nok> ") && n.mem[ACL_HOOK] == 0 && is(say("ACL-BOOT\n"), "UNKNOWN WORD: 'ACL-BOOT'\n ERROR\nok> "), "COLD takes the policy away with everything else that was loaded"); diff --git a/v4/tests/test_mesh_boot.c b/v4/tests/test_mesh_boot.c index 4b39b8cf..d5205553 100644 --- a/v4/tests/test_mesh_boot.c +++ b/v4/tests/test_mesh_boot.c @@ -164,6 +164,24 @@ int main(void) } CHECK(all, "init.4th pinned the %u words that create or end nodes", (unsigned)(sizeof pinned / sizeof pinned[0])); } + { /* the ACL countdown at call, as v3's inner interpreter (docs/v4.0.0/plans/2026-11-19-acl-at-call.md) */ + long t1 = -1, t2 = -1; + r = line(V4_MESH_HERA, ": F1 65 EMIT ; : G1 F1 ; G1 ' F1 ACL-TTL@ . G1 ' F1 ACL-TTL@ .", &how); + if (how == V4_TEXT_COMPLETED) (void)sscanf(r, "A%ld A%ld", &t1, &t2); + CHECK(t1 >= 256 && t2 == t1 - 1, "a word called from a definition is checked at the call, and counted down: \"%s\"", r); + r = line(V4_MESH_HERA, "0 ' F1 ACL-ALLOW! G1", &how); + CHECK(how == V4_TEXT_ERROR && strstr(r, "ACL: denied 'F1'"), + "a denied word called from a definition is refused at the call, by its own name: \"%s\"", r); + CHECK(strstr(r, "denied 'F1'") && strncmp(r, "A", 1) != 0, " and does not run: \"%s\"", r); + r = line(V4_MESH_HERA, ": G2 F1 ;", &how); + CHECK(how == V4_TEXT_COMPLETED, "a denied word can be compiled into a definition, as v3: \"%s\" (%d)", r, how); + r = line(V4_MESH_HERA, "G2", &how); + CHECK(how == V4_TEXT_ERROR && strstr(r, "ACL: denied 'F1'"), " and it is refused when the definition runs: \"%s\"", r); + t1 = t2 = -1; + r = line(V4_MESH_HERA, ": F3 66 EMIT ; F3 ' F3 ACL-TTL@ . F3 ' F3 ACL-TTL@ .", &how); + if (how == V4_TEXT_COMPLETED) (void)sscanf(r, "B%ld B%ld", &t1, &t2); + CHECK(t1 >= 256 && t2 == t1 - 1, "a word at the prompt is counted once a use, not twice: \"%s\"", r); + } r = line(V4_MESH_HERA, "1900 BLOCK 16 TYPE", &how); CHECK(how == V4_TEXT_COMPLETED && strncmp(r, "( forth79.4th --", 16) == 0, "forth79.4th's lowest block is in RAM block 1900: \"%.20s\" (%d)", r, how); /* starshipos.4th, a system capsule loaded before POST (MACHINE.md 3, step 3; ruled 2026-11-18) */ diff --git a/v4/tools/mkmap.c b/v4/tools/mkmap.c index 03710f27..aedd77e8 100644 --- a/v4/tools/mkmap.c +++ b/v4/tools/mkmap.c @@ -53,11 +53,12 @@ static int image_description(void) printf("#include \"v4/image.h\"\n\nconst v4_image v4_map_image = {\n"); printf(" %uu, %uu, %uu, %uu,\n", (unsigned)V4_CELL_BITS, (unsigned)V4_NODE_WORDS, (unsigned)V4_DATA_RING, (unsigned)V4_RET_RING); printf(" -1,\n -1, %ld,\n -1, -1,\n", (long)PORT); - printf(" %ld, %ld, %ld,\n %ld, %ld,\n %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld,\n %ld,\n %ld, %ld, %ld, %ld, %ld,\n %ld,\n", + printf(" %ld, %ld, %ld,\n %ld, %ld,\n %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld, %ld,\n %ld,\n %ld,\n %ld, %ld, %ld, %ld, %ld,\n %ld, %ld,\n %ld,\n", (long)CONSOLE_TX, (long)CONSOLE_RX, (long)CONSOLE_ST, (long)DSTACK_REG, (long)RSTACK_REG, (long)NODE_ERROR, (long)HEAT_REG, (long)ME, (long)DP, (long)LATEST, (long)BOOT_CELLS, (long)FENCE, (long)NEXT_ID, (long)BOOT_ID, (long)WORD_DEFINED, (long)WORD_FORGOTTEN, (long)HOTVARS, (long)CONTEXT, - (long)TOKENS, (long)DICT_W, (long)DICT_END_W, (long)RUNX_W, (long)EXEC_W, (long)BUF0_W); + (long)TOKENS, (long)DICT_W, (long)DICT_END_W, (long)RUNX_W, (long)EXEC_W, (long)ACL_CALL_W, (long)ACL_BUSY_W, + (long)BUF0_W); printf(" %ld, %ld, %ld\n};\n", (long)ROM_IMG, (long)ROM_FAILED, (long)ROM_ERRLINE); return 0; }