nx_fsops_conditional_gate_t77.nx source
↩ module page · 112 lines · 8547 B
1// nx_fsops_conditional_gate_t77.nx -- Implements conditional gate operations for file system scanning and data validation in the Nishi ecosystem.
2import "nx_fsops_lib_t77.nx"
3import "nx_gate_verdict.nx"
4import "nx_fcntl.nx"
5const CG_SOURCE_SIZE:i64=128275
6const CG_WINDOW:i64=64
7const CG_SENTINEL:i64=165
8func cg_all(b:*u8,n:i64,v:i64)->i64{var i:i64=0;while i<n{if b[i]!=(v as u8){return 0};i=i+1};return 1}
9func cg_scan(mode:i64)->i64{
10 let total:i64=fsx_cworkspace_bytes(CG_WINDOW)
11 let ws:*u8=sys_mmap_shared(total)
12 if (ws as i64)<=0{return 0}
13 if sha256_init_workspace(ws,sha256_workspace_bytes())!=0{sys_munmap(ws,total);return 0}
14 let m:*i64=((ws as i64)+sha256_workspace_bytes()) as *i64
15 let block:*u8=((m as i64)+FSX_CREAD_META) as *u8
16 let dig:*u8=((block as i64)+FSX_DENT_BUF) as *u8
17 let hex:*u8=((dig as i64)+FSX_CREAD_DIGEST) as *u8
18 let view:*u8=((hex as i64)+FSX_CREAD_HEXBUF+SF_STATBUF) as *u8
19 m[FSX_CREAD_SIZE]=CG_SOURCE_SIZE;m[FSX_CREAD_OFFSET]=0;m[FSX_CREAD_BUDGET]=CG_WINDOW
20 m[FSX_CREAD_SCANNED]=0;m[FSX_CREAD_KEPT]=0;m[FSX_CREAD_ERROR]=0;m[FSX_CREAD_CALLS]=0
21 var j:i64=0;while j<FSX_CREAD_DIGEST{dig[j]=CG_SENTINEL as u8;j=j+1}
22 var fd:i64=0 - 1
23 if mode!=1{fd=sys_openat_rd("runtime/nx_cast_shader_src.nx" as *u8);if fd<0{sys_munmap(ws,total);return 0}}
24 if mode==2{m[FSX_CREAD_SIZE]=CG_SOURCE_SIZE+1}
25 if mode==3{m[FSX_CREAD_SIZE]=CG_SOURCE_SIZE-1}
26 if mode==4{m[FSX_CREAD_SIZE]=0}
27 let rc:i64=fsx_cscan(fd,m,block,view,dig,ws as *Sha256)
28 var ok:i64=0
29 if mode==0{
30 sf_hex32(dig,hex)
31 ok=rc==0&&m[FSX_CREAD_SCANNED]==CG_SOURCE_SIZE&&m[FSX_CREAD_CALLS]==3&&m[FSX_CREAD_KEPT]==CG_WINDOW&&fsx_seq(hex,"1f11de1c8fe2c2f0a5d7c6c2a705873081754ab48d739c6d5f69215cda565ba9" as *u8)==1
32 if sys_lseek(fd,0,0)!=0{ok=0}
33 if sys_read(fd,block,CG_WINDOW)!=CG_WINDOW{ok=0}
34 var p:i64=0;while p<CG_WINDOW{if block[p]!=view[p]{ok=0};p=p+1}
35 }
36 if mode==1{ok=rc==FSX_CREAD_IO&&m[FSX_CREAD_ERROR]<0&&m[FSX_CREAD_SCANNED]==0&&cg_all(dig,FSX_CREAD_DIGEST,CG_SENTINEL)}
37 if mode==2{ok=rc==FSX_CREAD_IO&&m[FSX_CREAD_ERROR]==0&&m[FSX_CREAD_SCANNED]==CG_SOURCE_SIZE&&cg_all(dig,FSX_CREAD_DIGEST,CG_SENTINEL)}
38 if mode==3{ok=rc==FSX_CREAD_MOVED&&m[FSX_CREAD_SCANNED]==CG_SOURCE_SIZE-1&&cg_all(dig,FSX_CREAD_DIGEST,CG_SENTINEL)}
39 if mode==4{ok=rc==FSX_CREAD_MOVED&&m[FSX_CREAD_SCANNED]==0&&cg_all(dig,FSX_CREAD_DIGEST,CG_SENTINEL)}
40 if fd>=0{if sys_close(fd)!=0{ok=0}}
41 if sys_munmap(ws,total)!=0{ok=0};return ok
42}
43const CG_PIPE_FDMASK:i64=4294967295
44const CG_PIPE_FDSHIFT:i64=4294967296
45const CG_EAGAIN:i64=11
46// Linux UAPI F_GETPIPE_SZ = F_LINUX_SPECIFIC_BASE(1024)+8.
47const CG_GETPIPE_SZ:i64=1032
48func cg_output(ctr:*i64)->i64{
49 let meta:*u8=sys_mmap_shared(FSX_CREAD_META+CG_WINDOW)
50 if (meta as i64)<=0{gv_check("output fixture metadata allocated" as *u8,0,ctr);return 0}
51 let m:*i64=meta as *i64;let readbuf:*u8=((meta as i64)+FSX_CREAD_META) as *u8
52 if sys_pipe2(m,0)!=0{sys_munmap(meta,FSX_CREAD_META+CG_WINDOW);gv_check("output fixture pipe created" as *u8,0,ctr);return 0}
53 let rfd:i64=m[0]&CG_PIPE_FDMASK;let wfd:i64=(m[0]/CG_PIPE_FDSHIFT)&CG_PIPE_FDMASK
54 let rset:i64=nx_fcntl_set_nonblock(rfd);let wset:i64=nx_fcntl_set_nonblock(wfd)
55 let rf:i64=nx_fcntl(rfd,NX_F_GETFL,0);let wf:i64=nx_fcntl(wfd,NX_F_GETFL,0)
56 let capacity:i64=nx_fcntl(wfd,CG_GETPIPE_SZ,0)
57 let admitted:i64=rset==0&&wset==0&&rf>=0&&wf>=0&&(rf&NX_O_NONBLOCK)!=0&&(wf&NX_O_NONBLOCK)!=0&&capacity>=CG_WINDOW&&capacity<=FSX_READ_CAP
58 gv_check("actual nonblocking flags and bounded queried pipe capacity" as *u8,admitted,ctr)
59 if admitted==0{sys_close(rfd);sys_close(wfd);sys_munmap(meta,FSX_CREAD_META+CG_WINDOW);return 0}
60 let requested:i64=capacity+1;let b:*u8=sys_mmap_shared(requested)
61 if (b as i64)<=0{sys_close(rfd);sys_close(wfd);sys_munmap(meta,FSX_CREAD_META+CG_WINDOW);gv_check("queried-capacity fixture allocation" as *u8,0,ctr);return 0}
62 var i:i64=0;while i<requested{b[i]=(i%256) as u8;i=i+1}
63 let bad:i64=fsx_cwrite(0 - 1,b,CG_WINDOW,m)
64 gv_check("invalid descriptor preserves zero delivery and error" as *u8,bad==FSX_CREAD_IO&&m[FSX_CREAD_WRITTEN]==0&&m[FSX_CREAD_WRITE_ERROR]<0,ctr)
65 let rd:i64=sys_openat_rd("runtime/nx_cast_shader_src.nx" as *u8)
66 var read_only_ok:i64=0
67 if rd>=0{let rr:i64=fsx_cwrite(rd,b,CG_WINDOW,m);read_only_ok=rr==FSX_CREAD_IO&&m[FSX_CREAD_WRITTEN]==0&&m[FSX_CREAD_WRITE_ERROR]<0;sys_close(rd)}
68 gv_check("actual read-only descriptor refuses output" as *u8,read_only_ok,ctr)
69 let binary_rc:i64=fsx_cwrite(wfd,b,CG_WINDOW,m)
70 var binary_ok:i64=binary_rc==0&&m[FSX_CREAD_WRITTEN]==CG_WINDOW
71 if sys_read(rfd,readbuf,CG_WINDOW)!=CG_WINDOW{binary_ok=0}
72 i=0;while i<CG_WINDOW{if readbuf[i]!=b[i]{binary_ok=0};i=i+1}
73 gv_check("binary NUL-containing payload roundtrips exact bytes" as *u8,binary_ok,ctr)
74 let rc:i64=fsx_cwrite(wfd,b,requested,m)
75 let delivered:i64=m[FSX_CREAD_WRITTEN];let write_error:i64=m[FSX_CREAD_WRITE_ERROR];let calls:i64=m[FSX_CREAD_WRITE_CALLS]
76 gv_check("capacity-plus-one actual partial write retains EAGAIN progress" as *u8,rc==FSX_CREAD_IO&&delivered>0&&delivered<requested&&write_error==(0 - CG_EAGAIN)&&calls>=2,ctr)
77 var received:i64=0;var n:i64=1;var bytes_ok:i64=1
78 while n>0{n=sys_read(rfd,readbuf,CG_WINDOW);if n>0{var j:i64=0;while j<n{if readbuf[j]!=(((received+j)%256) as u8){bytes_ok=0};j=j+1};received=received+n}}
79 gv_check("reported partial count equals independently drained bytes" as *u8,bytes_ok&&received==delivered&&n==(0 - CG_EAGAIN),ctr)
80 gv_puts("pipe_capacity=" as *u8);gv_num(capacity);gv_puts(" requested=" as *u8);gv_num(requested);gv_puts(" partial_bytes=" as *u8);gv_num(delivered);gv_puts(" drained_bytes=" as *u8);gv_num(received);gv_puts(" write_calls=" as *u8);gv_num(calls);gv_puts("\n" as *u8)
81 let rclose:i64=sys_close(rfd);let wclose:i64=sys_close(wfd)
82 let brelease:i64=sys_munmap(b,requested);let mrelease:i64=sys_munmap(meta,FSX_CREAD_META+CG_WINDOW)
83 gv_check("owned pipe descriptors and scratch released" as *u8,rclose==0&&wclose==0&&brelease==0&&mrelease==0,ctr)
84 return 0
85}
86func main(argc:i64,argv:*i64)->i64{
87 let ctr:*i64=gv_ctr()
88 gv_head("FS-CONDITIONAL / bounded streaming evidence" as *u8)
89 cg_output(ctr)
90 gv_check("actual two-block source SHA and raw window equal independent bytes" as *u8,cg_scan(0),ctr)
91 gv_check("actual invalid descriptor read preserves unknown digest" as *u8,cg_scan(1),ctr)
92 gv_check("extent longer than file reports premature EOF and no digest" as *u8,cg_scan(2),ctr)
93 gv_check("extent shorter than file detects extra byte and no digest" as *u8,cg_scan(3),ctr)
94 gv_check("zero declared extent on nonempty file detects extra byte" as *u8,cg_scan(4),ctr)
95 let path:*u8="runtime/nx_game_surface_prepare_t132.nx"
96 let sha:*u8="64b26eb6e39e5234ddcdd988a42da10a84a73e315e6c40b1e1ea494cf6c0fbd6"
97 gv_check("matching complete source suppresses raw replay" as *u8,fsx_read_if_changed(path,sha,CG_WINDOW,0)==FSX_CREAD_SAME,ctr)
98 gv_check("mismatched source emits bounded raw window" as *u8,fsx_read_if_changed(path,"0000000000000000000000000000000000000000000000000000000000000000" as *u8,CG_WINDOW,0)==FSX_CREAD_CHANGED,ctr)
99 gv_check("window at EOF accepted as zero raw bytes" as *u8,fsx_read_if_changed(path,sha,CG_WINDOW,17740)==FSX_CREAD_SAME,ctr)
100 gv_check("window beyond EOF refused" as *u8,fsx_read_if_changed(path,sha,CG_WINDOW,17741)==FSX_CREAD_ARGUMENT,ctr)
101 gv_check("invalid SHA refused" as *u8,fsx_read_if_changed(path,"bad" as *u8,CG_WINDOW,0)==FSX_CREAD_ARGUMENT,ctr)
102 gv_check("zero budget refused" as *u8,fsx_read_if_changed(path,sha,0,0)==FSX_CREAD_ARGUMENT,ctr)
103 gv_check("oversized budget refused" as *u8,fsx_read_if_changed(path,sha,FSX_CREAD_MAX+1,0)==FSX_CREAD_ARGUMENT,ctr)
104 gv_check("negative offset refused" as *u8,fsx_read_if_changed(path,sha,CG_WINDOW,0 - 1)==FSX_CREAD_ARGUMENT,ctr)
105 gv_check("missing source is unknown not unchanged" as *u8,fsx_read_if_changed("runtime/ct77-definitely-absent-source.nx" as *u8,sha,CG_WINDOW,0)==(0 - 1),ctr)
106 gv_check("existing secret deny-list preserved" as *u8,fsx_read_if_changed("secret-ct77-denied" as *u8,sha,CG_WINDOW,0)==(0 - 2),ctr)
107 gv_check("strict decimal overflow refused" as *u8,fsx_cdecimal("9223372036854775808" as *u8)==(0 - 1),ctr)
108 gv_check("strict decimal rejects suffix" as *u8,fsx_cdecimal("64junk" as *u8)==(0 - 1),ctr)
109 let failed:i64=sys_mmap_shared(0) as i64
110 gv_check("actual allocator refusal remains structured incomplete" as *u8,failed<=0&&fsx_cmapped(path,sha,CG_WINDOW,0,failed)==FSX_CREAD_IO,ctr)
111 return gv_verdict("FS-CONDITIONAL" as *u8,ctr,"native x86-64; no concurrent-mutation, ENOMEM, or semantic-verdict claim" as *u8)
112}