nx_pack_rules_vet_gate.nx source
↩ module page · 251 lines · 9037 B
1// nx_pack_rules_vet_gate.nx -- THE RULES VET GATE (compare-plane pattern for the pack rules).
2// Walks knowledge/forge/pack_rules_vet_v1.txt; for every RULE row with a witness it forks the
3// SOVEREIGN LANE on that witness (fork+execve _offc/nx_sov_build_run.elf, exit decoded) and
4// enforces status <-> measured behavior:
5// ACTIVE -> witness must FIRE (lane exit nonzero). Passing instead = RETIRABLE -> RED
6// (the language grew; the registry is FORCED to shed the restriction).
7// GUARD / RETIRED -> witness must PASS (exit 0). Firing instead = REGRESSED -> RED
8// (the compiler regressed; the witnesses double as regression sentinels).
9// witness none -> WHY= and COST= must be non-empty (no reasonless rules).
10// NEG-CONTROL: a fixture row claiming RETIRED for a live trap must be flagged (REGRESSED>0).
11// license_tier: ORIGINAL expect_exit: 0
12import "nx_forge_ctx.nx"
13
14// start index of pipe-separated field n within [ls,le); -1 if absent
15func pv_fstart(buf: *u8, ls: i64, le: i64, n: i64) -> i64 {
16 if n == 0 { return ls }
17 var i: i64 = ls
18 var seen: i64 = 0
19 while i < le {
20 let c: i64 = buf[i] as i64
21 if c == 124 {
22 seen = seen + 1
23 if seen == n {
24 let r: i64 = i + 1
25 return r
26 }
27 }
28 i = i + 1
29 }
30 let neg: i64 = 0 - 1
31 return neg
32}
33
34func pv_fend(buf: *u8, fs: i64, le: i64) -> i64 {
35 var i: i64 = fs
36 while i < le {
37 let c: i64 = buf[i] as i64
38 if c == 124 { return i }
39 i = i + 1
40 }
41 return le
42}
43
44// fork the sovereign lane on witness wname; return 1 if it FIRED (build/run failed), 0 if clean
45func pv_run_witness(wname: *u8, av: *i64, envp: *i64, st: *i64) -> i64 {
46 let pid: i64 = sys_fork()
47 if pid == 0 {
48 let ofd: i64 = sys_openat_wr("/tmp/rwvet.out" as *u8, 420)
49 if ofd >= 0 {
50 sys_dup3(ofd, 1, 0)
51 sys_dup3(ofd, 2, 0)
52 }
53 let elf: *u8 = "_offc/nx_sov_build_run.elf" as *u8
54 av[0] = elf as i64
55 av[1] = wname as i64
56 av[2] = 0
57 sys_execve(elf, av, envp)
58 sys_exit(127)
59 }
60 st[0] = 0
61 sys_wait4(pid, st, 0)
62 let crashed: i64 = st[0] % 128
63 let ec: i64 = (st[0] >> 8) & 255
64 var fired: i64 = 0
65 if crashed != 0 { fired = 1 }
66 if ec != 0 { fired = 1 }
67 return fired
68}
69
70// walk all RULE rows; returns mismatch count; row count via nout[0]
71func pv_walk(buf: *u8, n: i64, wbuf: *u8, av: *i64, envp: *i64, st: *i64, nout: *i64) -> i64 {
72 var mm: i64 = 0
73 var nrows: i64 = 0
74 var i: i64 = 0
75 while i < n {
76 var e: i64 = i
77 var scan: i64 = 1
78 while scan == 1 {
79 if e >= n { scan = 0 }
80 if scan == 1 {
81 let c: i64 = buf[e] as i64
82 if c == 10 { scan = 0 }
83 if c != 10 { e = e + 1 }
84 }
85 }
86 let ll: i64 = e - i
87 var isrule: i64 = 0
88 if ll > 5 {
89 let c0: i64 = buf[i] as i64
90 let i1: i64 = i + 1
91 let c1: i64 = buf[i1] as i64
92 let i2: i64 = i + 2
93 let c2: i64 = buf[i2] as i64
94 let i3: i64 = i + 3
95 let c3: i64 = buf[i3] as i64
96 let i4: i64 = i + 4
97 let c4: i64 = buf[i4] as i64
98 if c0 == 82 {
99 if c1 == 85 {
100 if c2 == 76 {
101 if c3 == 69 {
102 if c4 == 124 { isrule = 1 }
103 }
104 }
105 }
106 }
107 }
108 if isrule == 1 {
109 nrows = nrows + 1
110 let ids: i64 = pv_fstart(buf, i, e, 1)
111 let ide: i64 = pv_fend(buf, ids, e)
112 let sts: i64 = pv_fstart(buf, i, e, 2)
113 let wfs: i64 = pv_fstart(buf, i, e, 3)
114 let wfe: i64 = pv_fend(buf, wfs, e)
115 std_puts("ROW " as *u8)
116 let idp: *u8 = buf + ids
117 let idl: i64 = ide - ids
118 sys_write(1, idp, idl)
119 var rowbad: i64 = 0
120 if sts < 0 { rowbad = 1 }
121 if wfs < 0 { rowbad = 1 }
122 if rowbad == 0 {
123 let sb: i64 = buf[sts] as i64
124 let wl: i64 = wfe - wfs
125 var hasw: i64 = 1
126 if wl == 4 {
127 let w0: i64 = buf[wfs] as i64
128 let wi1: i64 = wfs + 1
129 let w1: i64 = buf[wi1] as i64
130 let wi2: i64 = wfs + 2
131 let w2: i64 = buf[wi2] as i64
132 let wi3: i64 = wfs + 3
133 let w3: i64 = buf[wi3] as i64
134 if w0 == 110 {
135 if w1 == 111 {
136 if w2 == 110 {
137 if w3 == 101 { hasw = 0 }
138 }
139 }
140 }
141 }
142 if hasw == 1 {
143 if wl > 0 {
144 if wl < 200 {
145 let wsrc: *u8 = buf + wfs
146 std_memcpy(wbuf, wsrc, wl)
147 wbuf[wl] = 0 as u8
148 let fired: i64 = pv_run_witness(wbuf, av, envp, st)
149 std_puts(" fired=" as *u8)
150 std_pdec(fired)
151 var want: i64 = 0
152 if sb == 65 { want = 1 }
153 if fired == want {
154 std_putln(" OK" as *u8)
155 }
156 if fired != want {
157 mm = mm + 1
158 if sb == 65 { std_putln(" RETIRABLE (trap no longer fires -- shed the restriction)" as *u8) }
159 if sb != 65 { std_putln(" REGRESSED (tactic broke -- compiler regression)" as *u8) }
160 }
161 }
162 }
163 }
164 if hasw == 0 {
165 let whys: i64 = pv_fstart(buf, i, e, 5)
166 let whye: i64 = pv_fend(buf, whys, e)
167 let costs: i64 = pv_fstart(buf, i, e, 6)
168 let coste: i64 = pv_fend(buf, costs, e)
169 var meta: i64 = 1
170 if whys < 0 { meta = 0 }
171 if costs < 0 { meta = 0 }
172 if meta == 1 {
173 let whyl: i64 = whye - whys
174 let costl: i64 = coste - costs
175 if whyl <= 4 { meta = 0 }
176 if costl <= 5 { meta = 0 }
177 }
178 if meta == 1 { std_putln(" meta OK" as *u8) }
179 if meta == 0 {
180 mm = mm + 1
181 std_putln(" meta MISSING (reasonless rule)" as *u8)
182 }
183 }
184 }
185 if rowbad == 1 {
186 mm = mm + 1
187 std_putln(" MALFORMED" as *u8)
188 }
189 }
190 i = e + 1
191 }
192 nout[0] = nrows
193 return mm
194}
195
196func main(argc: i64, argv: *i64) -> i64 {
197 let buf: *u8 = sys_mmap(65536) as *u8
198 let wbuf: *u8 = sys_mmap(256) as *u8
199 let av: *i64 = sys_mmap(64) as *i64
200 let envp: *i64 = sys_mmap(32) as *i64
201 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64
202 envp[1] = 0
203 let st: *i64 = sys_mmap(64) as *i64
204 let cnt: *i64 = sys_mmap(64) as *i64
205 let n: i64 = fc_read("knowledge/forge/pack_rules_vet_v1.txt" as *u8, buf, 65536)
206 if n <= 0 {
207 std_putln("PACK-RULES-VET verdict=RED no-registry" as *u8)
208 sys_exit(1)
209 return 1
210 }
211 let mm: i64 = pv_walk(buf, n, wbuf, av, envp, st, cnt)
212 let nrows: i64 = cnt[0]
213 // NEG-CONTROL: a fixture claiming RETIRED for a live trap must be flagged REGRESSED
214 let fixrow: *u8 = "RULE|NX-FIX|RETIRED|nx_rw_staticarr|planted wrong status|WHY=x|COST=x|RETIRE=x\n" as *u8
215 let fl: i64 = std_slen(fixrow)
216 let ffd: i64 = sys_openat_wr("/tmp/pv_fix.txt" as *u8, 420)
217 var mmfix: i64 = 0
218 var nfix: i64 = 0
219 if ffd >= 0 {
220 let wr: i64 = fc_wb(ffd, fixrow, fl)
221 sys_close(ffd)
222 if wr == 0 {
223 let fbuf: *u8 = sys_mmap(4096) as *u8
224 let fn: i64 = fc_read("/tmp/pv_fix.txt" as *u8, fbuf, 4096)
225 if fn > 0 {
226 mmfix = pv_walk(fbuf, fn, wbuf, av, envp, st, cnt)
227 nfix = cnt[0]
228 }
229 }
230 }
231 std_puts("PACK-RULES-VET rows=" as *u8)
232 std_pdec(nrows)
233 std_puts(" mismatches=" as *u8)
234 std_pdec(mm)
235 std_puts(" negctl-flagged=" as *u8)
236 std_pdec(mmfix)
237 if nrows >= 12 {
238 if mm == 0 {
239 if mmfix >= 1 {
240 if nfix == 1 {
241 std_putln(" verdict=GREEN" as *u8)
242 sys_exit(0)
243 return 0
244 }
245 }
246 }
247 }
248 std_putln(" verdict=RED" as *u8)
249 sys_exit(1)
250 return 1
251}