nx_clock_reserved_fault_native_v2_ar.nx source
↩ module page · 439 lines · 24048 B
1// Local-only V2 real-process scheduler harness. Positive closure uses production seams;
2// ownership selectors require the explicitly instrumented test-only scheduler closure.
3import "nx_clock_sched_reserved_fault_v2_ar.nx"
4import "nx_gate_verdict.nx"
5import "nx_tool_run.nx"
6import "nx_build_canon_input_lib.nx"
7import "nx_rank_refresh_lib.nx"
8const RIG_PATH: i64 = 4096
9const RIG_PTR: i64 = 8
10const RIG_FILE_MODE: i64 = 384
11const RIG_DIR_MODE: i64 = 448
12const RIG_EINVAL: i64 = 0 - 22
13const RIG_SETUP: i64 = 90
14const RIG_GUARD: *u8 = "NISHI-CLOCK-RESERVE-FIXTURE\n"
15const CRG_EXCLUSIVE: i64 = 2
16const CRG_UNLOCK: i64 = 8
17const CRG_ROLES: i64 = 4
18const CRG_SLOW: i64 = 0
19const CRG_ESSENTIAL: i64 = 1
20const CRG_ORDINARY: i64 = 2
21const CRG_WINDOW: i64 = 3
22const CRG_START: i64 = 1
23const CRG_END: i64 = 0
24const CRG_MS_PER_SEC: i64 = 1000
25const CRG_MIN_COMPLETIONS: i64 = 2
26const CRG_FAULT_ROLE: i64 = 4
27const CRG_FAULT_POINT: i64 = 2
28const CRG_TEST_ECHILD: i64 = 0 - 10
29func rig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
30func rig_eq(a: *u8, b: *u8) -> i64 {
31 var i: i64 = 0
32 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
33 if b[i] != (0 as u8) { return 0 }
34 return 1
35}
36func rig_num(p: *u8) -> i64 {
37 let n: i64 = rig_len(p)
38 if n == 0 { return 0 - 1 }
39 var i: i64 = 0; var v: i64 = 0
40 while i < n {
41 let c: i64 = p[i] as i64
42 if c < BCI_ZERO { return 0 - 1 }
43 if c > BCI_NINE { return 0 - 1 }
44 let d: i64 = c - BCI_ZERO
45 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
46 v = v*BCI_DECIMAL_BASE+d; i = i + 1
47 }
48 return v
49}
50func rig_join(root: *u8, rel: *u8) -> *u8 {
51 if rig_len(root)+rig_len(rel)+2 > RIG_PATH { return 0 as *u8 }
52 let p: *u8 = sys_mmap(RIG_PATH)
53 var o: i64 = gv_cat(p, 0, root)
54 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
55 return p
56}
57func rig_exists(path: *u8) -> i64 {
58 if (path as i64) == 0 { return 0 }
59 let f: i64 = sys_openat_rd(path)
60 if f < 0 { return 0 }
61 sys_close(f); return 1
62}
63// Reject symlinks in every supplied parent component. No descendant is reused.
64func rig_parent(path: *u8) -> i64 {
65 let n: i64 = rig_len(path)
66 if n <= 1 { return 0 }
67 if n >= RIG_PATH { return 0 }
68 if path[0] != (BCI_SLASH as u8) { return 0 }
69 if bci_relative_path(path, 1, n-1, RIG_PATH-2) != 1 { return 0 }
70 let part: *u8 = sys_mmap(RIG_PATH)
71 let probe: *u8 = sys_mmap(RIG_PATH)
72 var i: i64 = 0
73 while i <= n {
74 var edge: i64 = 0
75 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
76 if edge == 1 {
77 part[i] = 0 as u8
78 if sys_readlinkat(part, probe, RIG_PATH) != RIG_EINVAL { return 0 }
79 }
80 if i < n { part[i] = path[i] }
81 i = i + 1
82 }
83 return 1
84}
85func rig_write(path: *u8, buf: *u8, n: i64) -> i64 {
86 if (path as i64) == 0 { return 0 }
87 let fd: i64 = sys_openat_wr(path, RIG_FILE_MODE)
88 if fd < 0 { return 0 }
89 var w: i64 = 0
90 while w < n {
91 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
92 if got <= 0 { sys_close(fd); return 0 }
93 w = w + got
94 }
95 // Fixture visibility check only; persistence barriers belong to the subject under test.
96 let close: i64 = sys_close(fd)
97 if close != 0 { return 0 }
98 return rrf_file_equal(path, buf, n)
99}
100func rig_file(root: *u8, rel: *u8, val: *u8) -> i64 { return rig_write(rig_join(root,rel),val,rig_len(val)) }
101func rig_dir(root: *u8, rel: *u8) -> i64 {
102 let p: *u8 = rig_join(root, rel)
103 if (p as i64) == 0 { return 0 }
104 if sys_mkdir(p,RIG_DIR_MODE) != 0 { return 0 }
105 return 1
106}
107func rig_link(root: *u8, rel: *u8, target: *u8) -> i64 {
108 let p: *u8 = rig_join(root,rel)
109 if (p as i64) == 0 { return 0 }
110 if sys_symlinkat(target,p) != 0 { return 0 }
111 return 1
112}
113func rig_guard() -> i64 { return rrf_file_equal("fixture-root.guard" as *u8,RIG_GUARD,rig_len(RIG_GUARD)) }
114
115func crg_event(role: i64, phase: i64) -> i64 {
116 let lock: i64 = sys_openat_append("events.lock" as *u8,RIG_FILE_MODE)
117 if lock < 0 { return 0 }
118 if sys_flock(lock,CRG_EXCLUSIVE) != 0 { sys_close(lock); return 0 }
119 let b: *u8 = sys_mmap(RIG_PATH)
120 var o: i64 = gv_catn(b,0,role); o = gv_cat(b,o," " as *u8)
121 o = gv_catn(b,o,phase); o = gv_cat(b,o," " as *u8)
122 o = gv_catn(b,o,sys_now_ms()); o = gv_cat(b,o,"\n" as *u8)
123 let fd: i64 = sys_openat_append("events.tsv" as *u8,RIG_FILE_MODE)
124 var ok: i64 = 0
125 if fd >= 0 { if sys_write(fd,b,o) == o { ok = 1 }; if sys_close(fd) != 0 { ok = 0 } }
126 if sys_flock(lock,CRG_UNLOCK) != 0 { ok = 0 }; if sys_close(lock) != 0 { ok = 0 }
127 return ok
128}
129func crg_child(argc: i64, argv: *i64) -> i64 {
130 if argc != 4 { return RIG_SETUP }
131 if rig_guard() != 1 { return RIG_SETUP }
132 let role: i64 = rig_num(argv[2] as *u8); let duration: i64 = rig_num(argv[3] as *u8)
133 if role < 0 { return RIG_SETUP }; if role >= CRG_WINDOW { return RIG_SETUP }; if duration <= 0 { return RIG_SETUP }
134 if crg_event(role,CRG_START) != 1 { return RIG_SETUP }
135 let start: i64 = sys_now_ms()
136 var remaining: i64 = duration
137 while remaining > 0 { sys_sleep_ms(remaining); remaining = duration-(sys_now_ms()-start) }
138 if crg_event(role,CRG_END) != 1 { return RIG_SETUP }
139 return 0
140}
141func crg_command(dst: *u8, role: i64, duration: *u8) -> i64 {
142 var o: i64 = gv_cat(dst,0,"./child.elf child " as *u8)
143 o = gv_catn(dst,o,role); o = gv_cat(dst,o," " as *u8); o = gv_cat(dst,o,duration)
144 return o
145}
146// Subject runs the real scheduler entrypoints in an isolated cwd.
147func crg_subject(argc: i64, argv: *i64) -> i64 {
148 if argc != 9 { return RIG_SETUP }
149 if rig_guard() != 1 { return RIG_SETUP }
150 let mode: *u8 = argv[2] as *u8
151 let period: i64 = rig_num(argv[5] as *u8)
152 let budget: i64 = rig_num(argv[6] as *u8)
153 let tick: i64 = rig_num(argv[7] as *u8)
154 let ordinary: *u8 = argv[8] as *u8
155 let names: *u8 = sys_mmap(CLK_NAMEW*3)
156 let organs: *u8 = sys_mmap(CLK_NAMEW*3)
157 let intervals: *i64 = sys_mmap(3*8) as *i64
158 let due: *i64 = sys_mmap(3*8) as *i64
159 let out: *i64 = sys_mmap(CLKRS_OUT_N*8) as *i64
160 gv_cat(clk_slot(names,0),0,"slow" as *u8)
161 gv_cat(clk_slot(names,1),0,"essential" as *u8)
162 gv_cat(clk_slot(names,2),0,"ordinary" as *u8)
163 crg_command(clk_slot(organs,0),0,argv[3] as *u8)
164 crg_command(clk_slot(organs,1),1,argv[4] as *u8)
165 crg_command(clk_slot(organs,2),2,ordinary)
166 if rig_eq(mode,"alias" as *u8) == 1 { crg_command(clk_slot(organs,2),1,argv[4] as *u8) }
167 if rig_eq(mode,"ownership-foreground" as *u8) == 1 { if rig_file("." as *u8,"fault.mode" as *u8,"F" as *u8) != 1 { return RIG_SETUP } }
168 if rig_eq(mode,"ownership-essential" as *u8) == 1 { if rig_file("." as *u8,"fault.mode" as *u8,"E" as *u8) != 1 { return RIG_SETUP } }
169 let conf: *u8 = sys_mmap(CLK_NAMEW+RIG_PATH)
170 var co: i64 = gv_cat(conf,0,"essential\t" as *u8)
171 co = gv_cat(conf,co,clk_slot(organs,1)); co = gv_cat(conf,co,"\n" as *u8)
172 if rig_file("." as *u8,"knowledge/status/clock_reserved.conf" as *u8,conf) != 1 { return RIG_SETUP }
173 let now: i64 = sys_now_realtime_sec()
174 intervals[0] = budget; intervals[1] = period; intervals[2] = budget
175 due[0] = now-1; due[1] = now+period; due[2] = now-1
176 if crg_event(CRG_WINDOW,CRG_START) != 1 { return RIG_SETUP }
177 var window_rc: i64 = 0
178 if rig_eq(mode,"serial" as *u8) == 1 {
179 window_rc = clk_run_edf(organs,names,intervals,due,3,1,budget,tick,out)
180 } else { window_rc = clk_run_edf_reserved(organs,names,intervals,due,3,1,budget,tick,out) }
181 if crg_event(CRG_WINDOW,CRG_END) != 1 { return RIG_SETUP }
182 if crg_negative_mode(mode) == 1 {
183 if rig_write("subject.metrics" as *u8,out as *u8,CLKRS_OUT_N*8) != 1 { return RIG_SETUP }
184 let scalar: *i64 = sys_mmap(8) as *i64; scalar[0] = window_rc
185 if rig_write("subject.rc" as *u8,scalar as *u8,8) != 1 { return RIG_SETUP }
186 scalar[0] = clk_reserved_halt_required(out)
187 if rig_write("subject.halt" as *u8,scalar as *u8,8) != 1 { return RIG_SETUP }
188 if rig_eq(mode,"alias" as *u8) == 1 { return 0 }
189 // Same pure halt decision the real driver uses; no simulated second-window success.
190 if clk_reserved_halt_required(out) == 1 { return 0 }
191 }
192 gv_puts("window1_dispatch=" as *u8); gv_num(out[0]); gv_puts(" assisted=" as *u8); gv_num(out[11]); gv_puts("\n" as *u8)
193 // Drain-only boundary test: deadlines are explicitly reset. This does not test
194 // nx_clock_tickless persistence, state reload, or supervisor restart behavior.
195 let next: i64 = sys_now_realtime_sec()
196 due[0] = next+budget; due[1] = next+budget; due[2] = next-1
197 if crg_event(CRG_WINDOW,CRG_START) != 1 { return RIG_SETUP }
198 if rig_eq(mode,"serial" as *u8) == 1 {
199 clk_run_edf(organs,names,intervals,due,3,1,budget,tick,out)
200 } else { clk_run_edf_reserved(organs,names,intervals,due,3,1,budget,tick,out) }
201 if crg_event(CRG_WINDOW,CRG_END) != 1 { return RIG_SETUP }
202 return 0
203}
204func crg_setup(root: *u8, self: *u8) -> i64 {
205 if sys_mkdir(root,RIG_DIR_MODE) != 0 { return 0 }
206 if rig_dir(root,"knowledge" as *u8) != 1 { return 0 }
207 if rig_dir(root,"knowledge/status" as *u8) != 1 { return 0 }
208 if rig_dir(root,"sites" as *u8) != 1 { return 0 }
209 if rig_dir(root,"sites/nishifamily" as *u8) != 1 { return 0 }
210 if rig_dir(root,"logs" as *u8) != 1 { return 0 }
211 if rig_file(root,"fixture-root.guard" as *u8,RIG_GUARD) != 1 { return 0 }
212 if rig_file(root,"knowledge/status/actlog.jrnl" as *u8,"" as *u8) != 1 { return 0 }
213 if rig_file(root,"knowledge/status/clock_heavy.conf" as *u8,"" as *u8) != 1 { return 0 }
214 if rig_file(root,"events.lock" as *u8,"" as *u8) != 1 { return 0 }
215 if rig_file(root,"events.tsv" as *u8,"" as *u8) != 1 { return 0 }
216 let len: *i64 = sys_mmap(8) as *i64
217 let executable: *u8 = sys_read_file(self,len)
218 if (executable as i64) == 0 { return 0 }; if len[0] <= 0 { return 0 }
219 // A copy is required: scheduler chmod must never follow a symlink to the supplied binary.
220 let path: *u8 = rig_join(root,"child.elf" as *u8)
221 if rig_write(path,executable,len[0]) != 1 { return 0 }
222 if sys_fchmodat(path,MODE_0755) != 0 { return 0 }
223 return 1
224}
225func crg_analyze(root: *u8, mode: *u8, period: i64, ctr: *i64) -> i64 {
226 let size: *i64 = sys_mmap(8) as *i64
227 let buf: *u8 = sys_read_file(rig_join(root,"events.tsv" as *u8),size)
228 gv_check("event journal readable" as *u8,((buf as i64) != 0) as i64,ctr)
229 if (buf as i64) == 0 { return 0 }
230 let active: *i64 = sys_mmap(CRG_ROLES*8) as *i64
231 let starts: *i64 = sys_mmap(CRG_ROLES*8) as *i64
232 let ends: *i64 = sys_mmap(CRG_ROLES*8) as *i64
233 let val: *i64 = sys_mmap(3*8) as *i64
234 var p: i64 = 0; var valid: i64 = 1; var total: i64 = 0; var maximum: i64 = 0
235 var duplicate: i64 = 0; var ordinaryoverlap: i64 = 0; var boundarybusy: i64 = 0
236 var completions: i64 = 0; var slowended: i64 = 0; var drain: i64 = 0; var previous: i64 = 0
237 var slowstart: i64 = 0; var slowend: i64 = 0
238 while p < size[0] {
239 var f: i64 = 0
240 while f < 3 {
241 var v: i64 = 0; var digits: i64 = 0
242 while p < size[0] {
243 let c: i64 = buf[p] as i64
244 if c < BCI_ZERO { break }; if c > BCI_NINE { break }
245 if v > (BCI_I64_MAX-(c-BCI_ZERO))/BCI_DECIMAL_BASE { valid = 0; break }
246 v = v*BCI_DECIMAL_BASE+c-BCI_ZERO; p = p+1; digits = digits+1
247 }
248 val[f] = v
249 if digits == 0 { valid = 0 }
250 var separator: i64 = 32; if f == 2 { separator = 10 }
251 if p >= size[0] { valid = 0 } else { if buf[p] != (separator as u8) { valid = 0 } }
252 if valid == 0 { break }; p = p+1; f = f+1
253 }
254 if valid == 0 { break }
255 let role: i64 = val[0]; let phase: i64 = val[1]; let time: i64 = val[2]
256 if role >= CRG_ROLES { valid = 0; break }; if phase > 1 { valid = 0; break }
257 if time < previous { valid = 0; break }; previous = time
258 if role == CRG_WINDOW {
259 if total != 0 { boundarybusy = boundarybusy+1 }
260 }
261 if phase == CRG_START {
262 if role == CRG_SLOW { slowstart = time }
263 if active[role] != 0 { duplicate = duplicate+1 }
264 active[role] = active[role]+1; starts[role] = starts[role]+1
265 if role != CRG_WINDOW {
266 total = total+1
267 if total > maximum { maximum = total }
268 if role != CRG_ESSENTIAL { if active[CRG_SLOW]+active[CRG_ORDINARY] > 1 { ordinaryoverlap = ordinaryoverlap+1 } }
269 }
270 } else {
271 if active[role] <= 0 { valid = 0; break }
272 if role == CRG_ESSENTIAL { if active[CRG_SLOW] > 0 { completions = completions+1 }; if slowended == 1 { if ends[CRG_WINDOW] == 0 { drain = drain+1 } } }
273 if role == CRG_SLOW { slowended = 1; slowend = time }
274 active[role] = active[role]-1; ends[role] = ends[role]+1
275 if role != CRG_WINDOW { total = total-1 }
276 }
277 }
278 gv_check("strict complete monotonic event records" as *u8,(valid == 1) as i64,ctr)
279 gv_check("one slow child completed" as *u8,(ends[CRG_SLOW] == 1) as i64,ctr)
280 gv_check("slow child spans essential eligibility" as *u8,(slowend-slowstart > period*CRG_MS_PER_SEC) as i64,ctr)
281 gv_check("second window ordinary child completed" as *u8,(ends[CRG_ORDINARY] == 1) as i64,ctr)
282 gv_check("two window completions" as *u8,(ends[CRG_WINDOW] == 2) as i64,ctr)
283 gv_check("no duplicate role active" as *u8,(duplicate == 0) as i64,ctr)
284 gv_check("no ordinary overlap" as *u8,(ordinaryoverlap == 0) as i64,ctr)
285 gv_check("window entry and return have no live witnessed children" as *u8,(boundarybusy == 0) as i64,ctr)
286 gv_check("all witnessed children ended" as *u8,(total == 0) as i64,ctr)
287 gv_check("all windows ended" as *u8,(active[CRG_WINDOW] == 0) as i64,ctr)
288 gv_check("maximum two active child lifetimes" as *u8,(maximum <= 2) as i64,ctr)
289 if rig_eq(mode,"serial" as *u8) == 1 {
290 gv_check("serial baseline no essential progress during foreground" as *u8,(completions == 0) as i64,ctr)
291 gv_check("serial baseline maximum one child" as *u8,(maximum == 1) as i64,ctr)
292 } else {
293 gv_check("reserved path overlaps real child lifetimes" as *u8,(maximum == 2) as i64,ctr)
294 if rig_eq(mode,"drain" as *u8) == 1 {
295 gv_check("essential finishes after slow before first window returns" as *u8,(drain > 0) as i64,ctr)
296 } else { gv_check("repeated essential completions before slow ends" as *u8,(completions >= CRG_MIN_COMPLETIONS) as i64,ctr) }
297 }
298 gv_puts("max_active_child_lifetimes=" as *u8); gv_num(maximum)
299 gv_puts(" essential_completed_during_slow=" as *u8); gv_num(completions)
300 gv_puts(" drain_completions=" as *u8); gv_num(drain); gv_puts("\n" as *u8)
301 return valid
302}
303
304func crg_negative_mode(mode: *u8) -> i64 {
305 if rig_eq(mode,"alias" as *u8) == 1 { return 1 }
306 if rig_eq(mode,"ownership-foreground" as *u8) == 1 { return 1 }
307 if rig_eq(mode,"ownership-essential" as *u8) == 1 { return 1 }
308 return 0
309}
310func crg_number_file(path: *u8) -> i64 {
311 let n: *i64 = sys_mmap(8) as *i64; let p: *u8 = sys_read_file(path,n)
312 if (p as i64) == 0 { return BCI_I64_MAX }; if n[0] != 8 { return BCI_I64_MAX }
313 return (p as *i64)[0]
314}
315func crg_negative_analyze(root: *u8, mode: *u8, ctr: *i64) -> i64 {
316 let size: *i64 = sys_mmap(8) as *i64; let buf: *u8 = sys_read_file(rig_join(root,"events.tsv" as *u8),size)
317 gv_check("negative event journal readable" as *u8,((buf as i64) != 0) as i64,ctr)
318 if (buf as i64) == 0 { return 0 }
319 let active: *i64 = sys_mmap(CRG_ROLES*8) as *i64
320 let ends: *i64 = sys_mmap(CRG_ROLES*8) as *i64
321 let val: *i64 = sys_mmap(3*8) as *i64
322 var p: i64 = 0; var valid: i64 = 1; var total: i64 = 0; var maximum: i64 = 0
323 var fault: i64 = 0; var after: i64 = 0; var duplicate: i64 = 0; var busy: i64 = 0; var previous: i64 = 0
324 while p < size[0] {
325 var f: i64 = 0
326 while f < 3 {
327 var v: i64 = 0; var digits: i64 = 0
328 while p < size[0] {
329 let c: i64 = buf[p] as i64
330 if c < BCI_ZERO { break }; if c > BCI_NINE { break }
331 if v > (BCI_I64_MAX-(c-BCI_ZERO))/BCI_DECIMAL_BASE { valid = 0; break }
332 v = v*BCI_DECIMAL_BASE+c-BCI_ZERO; p = p+1; digits = digits+1
333 }
334 val[f] = v
335 if digits == 0 { valid = 0 }
336 var separator: i64 = 32; if f == 2 { separator = 10 }
337 if p >= size[0] { valid = 0 } else { if buf[p] != (separator as u8) { valid = 0 } }
338 if valid == 0 { break }; p = p+1; f = f+1
339 }
340 if valid == 0 { break }
341 let role: i64 = val[0]; let phase: i64 = val[1]; let time: i64 = val[2]
342 if time < previous { valid = 0; break }; previous = time
343 if role == CRG_FAULT_ROLE {
344 if phase != CRG_FAULT_POINT { valid = 0; break }
345 fault = fault+1
346 } else {
347 if role >= CRG_ROLES { valid = 0; break }; if phase > 1 { valid = 0; break }
348 if role == CRG_WINDOW { if total != 0 { busy = busy+1 } }
349 if phase == CRG_START {
350 if active[role] != 0 { duplicate = duplicate+1 }; active[role] = active[role]+1
351 if role != CRG_WINDOW {
352 if fault > 0 { after = after+1 }
353 total = total+1; if total > maximum { maximum = total }
354 }
355 } else {
356 if active[role] <= 0 { valid = 0; break }; active[role] = active[role]-1; ends[role] = ends[role]+1
357 if role != CRG_WINDOW { total = total-1 }
358 }
359 }
360 }
361 gv_check("negative journal complete and monotonic" as *u8,(valid == 1) as i64,ctr)
362 gv_check("no start after ownership loss marker" as *u8,(after == 0) as i64,ctr)
363 gv_check("no duplicate role" as *u8,(duplicate == 0) as i64,ctr)
364 gv_check("observed at most two children" as *u8,(maximum <= 2) as i64,ctr)
365 gv_check("all fixture children ended" as *u8,(total == 0) as i64,ctr)
366 gv_check("window drained witnessed children" as *u8,(busy == 0) as i64,ctr)
367 gv_check("exactly one window returned" as *u8,(ends[CRG_WINDOW] == 1) as i64,ctr)
368 gv_check("no second ordinary child" as *u8,(ends[CRG_ORDINARY] == 0) as i64,ctr)
369 gv_check("real foreground completed" as *u8,(ends[CRG_SLOW] == 1) as i64,ctr)
370 let mn: *i64 = sys_mmap(8) as *i64; let metrics: *u8 = sys_read_file(rig_join(root,"subject.metrics" as *u8),mn)
371 var ready: i64 = 0; if (metrics as i64) != 0 { if mn[0] == CLKRS_OUT_N*8 { ready = 1 } }
372 gv_check("complete actual scheduler outputs persisted" as *u8,ready,ctr)
373 if ready != 1 { return 0 }; let out: *i64 = metrics as *i64
374 let alias: i64 = rig_eq(mode,"alias" as *u8)
375 if alias == 1 {
376 gv_check_eq("alias refused reservation with diagnostic error" as *u8,out[CLKRS_OUT_ERRORS],1,ctr)
377 gv_check_eq("alias not an ownership failure" as *u8,out[CLKRS_OUT_FATAL],0,ctr)
378 gv_check_eq("alias serial fallback no essential run" as *u8,ends[CRG_ESSENTIAL],0,ctr)
379 gv_check_eq("alias no assisted dispatch" as *u8,out[11],0,ctr)
380 gv_check_eq("alias no injected fault" as *u8,fault,0,ctr)
381 gv_check_eq("alias serial foreground result" as *u8,crg_number_file(rig_join(root,"subject.rc" as *u8)),1,ctr)
382 } else {
383 gv_check_eq("exactly one post-reap injected ECHILD" as *u8,fault,1,ctr)
384 gv_check_eq("instrumented seam actually ran" as *u8,crg_number_file(rig_join(root,"fault.seam-active" as *u8)),1,ctr)
385 gv_check_eq("no forbidden wait attempt" as *u8,rig_exists(rig_join(root,"fault.forbidden-wait" as *u8)),0,ctr)
386 gv_check_eq("no forbidden signal attempt" as *u8,rig_exists(rig_join(root,"fault.forbidden-signal" as *u8)),0,ctr)
387 gv_check_eq("one explicit propagated error" as *u8,out[CLKRS_OUT_ERRORS],1,ctr)
388 gv_check_eq("fatal state reaches caller" as *u8,out[CLKRS_OUT_FATAL],1,ctr)
389 gv_check_eq("fatal return code reaches caller" as *u8,crg_number_file(rig_join(root,"subject.rc" as *u8)),CLKRS_FATAL_RC,ctr)
390 gv_check_eq("driver halt decision true" as *u8,crg_number_file(rig_join(root,"subject.halt" as *u8)),1,ctr)
391 gv_check_eq("actual ECHILD evidence preserved" as *u8,out[CLKRS_OUT_LOST_WAIT],CRG_TEST_ECHILD,ctr)
392 gv_check_eq("actual lost PID evidence preserved" as *u8,out[CLKRS_OUT_LOST_PID],crg_number_file(rig_join(root,"fault.lostpid" as *u8)),ctr)
393 gv_check_eq("only known-owned child drained" as *u8,out[CLKRS_OUT_KNOWN_OWNED],0,ctr)
394 gv_check("real essential completed" as *u8,(ends[CRG_ESSENTIAL] > 0) as i64,ctr)
395 var index: i64 = CRG_ESSENTIAL
396 if rig_eq(mode,"ownership-foreground" as *u8) == 1 { index = CRG_SLOW }
397 gv_check_eq("correct ownership-loss job index" as *u8,out[CLKRS_OUT_LOST_INDEX],index,ctr)
398 }
399 return valid
400}
401
402func main(argc: i64, argv: *i64) -> i64 {
403 if argc > 1 {
404 if rig_eq(argv[1] as *u8,"child" as *u8) == 1 { let rc: i64 = crg_child(argc,argv); sys_exit(rc); return rc }
405 if rig_eq(argv[1] as *u8,"subject" as *u8) == 1 { let rc: i64 = crg_subject(argc,argv); sys_exit(rc); return rc }
406 }
407 if argc != 12 { gv_puts("usage: gate self existing-parent serial|reserved|drain|alias|ownership-foreground|ownership-essential slow-ms essential-ms period-sec window-sec tick-ms ordinary-ms timeout-ms capture-bytes\n" as *u8); return RIG_SETUP }
408 let self: *u8 = argv[1] as *u8; let parent: *u8 = argv[2] as *u8; let mode: *u8 = argv[3] as *u8
409 if rig_eq(mode,"serial" as *u8)+rig_eq(mode,"reserved" as *u8)+rig_eq(mode,"drain" as *u8)+crg_negative_mode(mode) != 1 { return RIG_SETUP }
410 if rig_parent(parent) != 1 { return RIG_SETUP }; if self[0] != (BCI_SLASH as u8) { return RIG_SETUP }
411 var i: i64 = 4
412 while i < 12 { if rig_num(argv[i] as *u8) <= 0 { return RIG_SETUP }; i = i+1 }
413 let tag: *u8 = sys_mmap(RIG_PATH)
414 var o: i64 = gv_cat(tag,0,"clock-reserve-" as *u8); o = gv_catn(tag,o,sys_now_ms())
415 let root: *u8 = rig_join(parent,tag)
416 if (root as i64) == 0 { return RIG_SETUP }
417 let ctr: *i64 = gv_ctr()
418 gv_head("CLOCK RESERVED ACTUAL PROCESS INTEGRATION" as *u8)
419 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\n" as *u8)
420 let setup: i64 = crg_setup(root,self); gv_check("isolated fixture complete with local actlog" as *u8,(setup == 1) as i64,ctr)
421 if setup != 1 { return RIG_SETUP }
422 if sys_chdir(root) != 0 { return RIG_SETUP }
423 let av: *i64 = sys_mmap(10*8) as *i64
424 av[0] = self as i64; av[1] = "subject" as *u8 as i64; av[2] = mode as i64
425 av[3] = argv[4]; av[4] = argv[5]; av[5] = argv[6]; av[6] = argv[7]; av[7] = argv[8]; av[8] = argv[9]; av[9] = 0
426 let cap: i64 = rig_num(argv[11] as *u8)
427 let output: *u8 = sys_mmap(cap); let olen: *i64 = sys_mmap(8) as *i64
428 let start: i64 = sys_now_ms()
429 let rc: i64 = tr_run_capture_cwd(self,av,output,cap,olen,rig_num(argv[10] as *u8),root)
430 gv_puts("subject_rc=" as *u8); gv_num(rc); gv_puts(" elapsed_ms=" as *u8); gv_num(sys_now_ms()-start); gv_puts("\n" as *u8)
431 gv_check("subject exited successfully" as *u8,(rc == 0) as i64,ctr)
432 gv_check("capture not full" as *u8,(olen[0] < cap-1) as i64,ctr)
433 gv_check("subject capture persisted and read back" as *u8,(rig_write(rig_join(root,"subject.out" as *u8),output,olen[0]) == 1) as i64,ctr)
434 // Timeout cannot prove drain; partial events remain evidence, never a passing verdict.
435 if crg_negative_mode(mode) == 1 { crg_negative_analyze(root,mode,ctr) }
436 else { crg_analyze(root,mode,rig_num(argv[6] as *u8),ctr) }
437 return gv_verdict("CLOCK-RESERVED-INTEGRATION",ctr,"real children; event-derived liveness; no live estate dispatch" as *u8)
438}
439