code wiki / _hdl_build / nx_gateorder.nx
`nx_gateorder.nx` source

↩ module page · 254 lines · 9860 B
1// nx_gateorder.nx -- sweeps a source tree asking ONE question it can actually answer:
2// DOES THIS GATE LEAVE A DURABLE VERDICT RECORD AT ALL?
3//
4// The standing form of a one-off /tmp shell sweep. A finding not wired into a standing instrument
5// decays, so the check lives here: repeatable by any seat, on any tree, with no shell.
6//
7// ⚠⚠ORDERING IS DELIBERATELY NOT JUDGED. An earlier version of this organ also reported EMIT-EARLY by
8// comparing the first emit-token offset against the last tooth offset. It was WRONG ON ALL SEVEN gates
9// it flagged, and I filed a sev7 debt against other lanes before checking: the token's first textual
10// occurrence lands on HELPER DEFINITIONS (`func g_log`), on TEST FIXTURES, and on /tmp scratch writes --
11// and this organ's own gate self-flagged, because the pattern appears in its test-data string literals.
12// ★★★★★TEXTUAL POSITION CANNOT DECIDE EXECUTION ORDER. The one genuine ordering defect in this arc was
13// caught by READING THE LOG (gate printed 41/41 while its log said 23/23), which grep could never do.
14//
15// nx_gateorder [root]     default root = runtime      exit 0 always (a report, not a verdict)
16// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
17import "nx_gateorder_lib.nx"
18
19const GOW_FCAP: i64 = 262144
20const GOW_DBUF: i64 = 65536
21const GOW_PATH: i64 = 1024
22const GOW_MAXDEPTH: i64 = 12
23const GOW_MAXLIVE: i64 = 512
24const GOW_NAMEW: i64 = 64
25
26static gow_fbuf: *u8
27static gow_noemit: i64
28static gow_present: i64
29static gow_total: i64
30static gow_noemit_live: i64
31static gow_noemit_srconly: i64
32static gow_elfpath: *u8
33static gow_livenames: *u8
34static gow_nlive: i64
35static gow_listmode: i64
36
37func gow_init() {
  gow_fbuf = sys_mmap(GOW_FCAP + 64) as *u8
  gow_elfpath = sys_mmap(GOW_PATH + 64) as *u8
  gow_noemit = 0
  gow_present = 0
  gow_total = 0
  gow_noemit_live = 0
  gow_noemit_srconly = 0
  gow_livenames = sys_mmap(GOW_MAXLIVE * GOW_NAMEW + 64) as *u8
  gow_nlive = 0
  gow_listmode = 0
48}
49
50// A bare COUNT of no-emit gates is too blunt to act on: 2239 reads as hopeless and hides the part that
51// matters. A gate with a PROMOTED BINARY runs and records nothing -- a real, live gap. A source-only
52// gate has never run at all, so its silence is expected. Splitting them turns one scary number into a
53// prioritised one. Existence check only: open the promoted elf beside the organ's cwd and close it.
54func gow_has_binary(srcname: *u8) -> i64 {
  var w: i64 = 0
  var i: i64 = 0
  while srcname[i] != (0 as u8) {
      if w < GOW_PATH - 5 {
          gow_elfpath[w] = srcname[i]
          w = w + 1
      }
      i = i + 1
  }
  if w < 3 { return 0 }
  w = w - 3
  gow_elfpath[w] = 46 as u8
  gow_elfpath[w + 1] = 101 as u8
  gow_elfpath[w + 2] = 108 as u8
  gow_elfpath[w + 3] = 102 as u8
  gow_elfpath[w + 4] = 0 as u8
  let fd: i64 = sys_openat_rd(gow_elfpath)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
75}
76
77func gow_join(dir: *u8, name: *u8, out: *u8) {
  var w: i64 = 0
  var i: i64 = 0
  while dir[i] != (0 as u8) {
      if w < GOW_PATH - 2 {
          out[w] = dir[i]
          w = w + 1
      }
      i = i + 1
  }
  if w > 0 {
      if out[w - 1] != (47 as u8) {
          out[w] = 47 as u8
          w = w + 1
      }
  }
  var j: i64 = 0
  while name[j] != (0 as u8) {
      if w < GOW_PATH - 1 {
          out[w] = name[j]
          w = w + 1
      }
      j = j + 1
  }
  out[w] = 0 as u8
102}
103
104func gow_is_dot(name: *u8) -> i64 {
  if name[0] != (46 as u8) { return 0 }
  if name[1] == (0 as u8) { return 1 }
  if name[1] == (46 as u8) {
      if name[2] == (0 as u8) { return 1 }
  }
  return 0
111}
112
113func gow_read_file(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var total: i64 = 0
  var done: i64 = 0
  while done == 0 {
      let want: i64 = GOW_FCAP - total
      if want <= 0 { done = 1 }
      else {
          let got: i64 = sys_read(fd, ((gow_fbuf as i64) + total) as *u8, want)
          if got <= 0 { done = 1 }
          else { total = total + got }
      }
  }
  sys_close(fd)
  return total
129}
130
131func gow_record(cls: i64, srcname: *u8) {
  gow_total = gow_total + 1
  if cls == GO_NOEMIT {
      gow_noemit = gow_noemit + 1
      if gow_has_binary(srcname) == 1 {
          gow_noemit_live = gow_noemit_live + 1
          // NAME THEM. A count without its members cannot be acted on or disproved -- my own lesson,
          // and this very number (317) was the last place in my work still violating it.
          if gow_nlive < GOW_MAXLIVE {
              var w: i64 = 0
              let slot: i64 = (gow_livenames as i64) + gow_nlive * GOW_NAMEW
              while srcname[w] != (0 as u8) {
                  if w < GOW_NAMEW - 1 {
                      let d: *u8 = (slot + w) as *u8
                      d[0] = srcname[w]
                  }
                  w = w + 1
              }
              if w > GOW_NAMEW - 1 { w = GOW_NAMEW - 1 }
              let term: *u8 = (slot + w) as *u8
              term[0] = 0 as u8
              gow_nlive = gow_nlive + 1
          }
      }
      else { gow_noemit_srconly = gow_noemit_srconly + 1 }
  }
  else { gow_present = gow_present + 1 }
158}
159
160func gow_scan_dir(dir: *u8, depth: i64) {
  if depth > GOW_MAXDEPTH { return }
  let dfd: i64 = sys_openat_rd(dir)
  if dfd < 0 { return }
  let dbuf: *u8 = sys_mmap(GOW_DBUF + 64) as *u8
  let cpath: *u8 = sys_mmap(GOW_PATH + 64) as *u8
  var looping: i64 = 1
  while looping == 1 {
      let nread: i64 = sys_getdents64(dfd, dbuf, GOW_DBUF)
      if nread <= 0 { looping = 0 }
      else {
          var off: i64 = 0
          while off < nread {
              let lo: i64 = dbuf[off + 16] as i64
              let hi: i64 = dbuf[off + 17] as i64
              let reclen: i64 = lo + hi * 256
              let dtype: i64 = dbuf[off + 18] as i64
              let nm: *u8 = ((dbuf as i64) + off + 19) as *u8
              if gow_is_dot(nm) == 0 {
                  gow_join(dir, nm, cpath)
                  if dtype == 4 { gow_scan_dir(cpath, depth + 1) }
                  if dtype == 8 {
                      if go_ends_gate_nx(nm) == 1 {
                          let n: i64 = gow_read_file(cpath)
                          if n > 0 { gow_record(go_classify(gow_fbuf, n), nm) }
                      }
                  }
              }
              if reclen <= 0 { off = nread }
              else { off = off + reclen }
          }
      }
  }
  sys_close(dfd)
194}
195
196func main(argc: i64, argv: *i64) -> i64 {
  gow_init()
  var root: *u8 = "runtime" as *u8
  var ai: i64 = 1
  while ai < argc {
      let a: *u8 = argv[ai] as *u8
      if go_match_at(a, 0, go_strlen(a), "--list" as *u8) == 1 { gow_listmode = 1 }
      else { root = a }
      ai = ai + 1
  }
  go_puts("=== NX-GATEORDER: do gates leave a DURABLE VERDICT RECORD? ===\n" as *u8)
  go_puts("root=" as *u8)
  go_puts(root)
  go_puts("\n\n" as *u8)
  gow_scan_dir(root, 0)
211
  go_kv("gates_scanned" as *u8, gow_total)
  go_kv("NO_EMIT_no_durable_verdict" as *u8, gow_noemit)
  go_puts("\n" as *u8)
  go_kv("  of_those_LIVE_have_a_promoted_binary" as *u8, gow_noemit_live)
  go_kv("  source_only_never_promoted" as *u8, gow_noemit_srconly)
  go_puts("\n" as *u8)
  go_kv("emit_present" as *u8, gow_present)
  var permil: i64 = 0
  if gow_total > 0 { permil = gow_present * 1000 / gow_total }
  go_kv("emit_coverage_permil" as *u8, permil)
  if gow_listmode == 1 {
      go_puts("\n\n-- THE ACTIONABLE SET: gates that RUN (promoted binary) and record NOTHING --\n" as *u8)
      go_puts("   these are the ones a ruler cannot see. Source-only gates are excluded on purpose.\n\n" as *u8)
      var li: i64 = 0
      while li < gow_nlive {
          go_puts("  " as *u8)
          go_puts(((gow_livenames as i64) + li * GOW_NAMEW) as *u8)
          go_puts("\n" as *u8)
          li = li + 1
      }
      // A SILENT CAP READS AS "THAT IS ALL". Declare what was withheld.
      if gow_noemit_live > gow_nlive {
          go_puts("\n  ⚠LIST CAPPED at " as *u8)
          go_puti(gow_nlive)
          go_puts(" -- " as *u8)
          go_puti(gow_noemit_live - gow_nlive)
          go_puts(" MORE not shown. A silent cap would read as 'that is all'.\n" as *u8)
      }
  }
  go_puts("\n\n-- WHAT THIS DOES AND DOES NOT SAY --\n" as *u8)
  go_puts("  NO-EMIT: the source carries no verdict-emit token, so it leaves no durable record in\n" as *u8)
  go_puts("  knowledge/status. A ruler reading that channel cannot see these gates at all.\n" as *u8)
  go_puts("  It does NOT mean unevidenced: /api/gate_run and nx_swcompare_evidence run a gate and read\n" as *u8)
  go_puts("  its EXIT CODE live. The gap is the PERSISTENT channel, consulted when nobody is watching.\n" as *u8)
  go_puts("  It also cannot see an emit reaching a gate through an IMPORTED helper -- so NO-EMIT is an\n" as *u8)
  go_puts("  UPPER BOUND on the gap, never a proven count.\n\n" as *u8)
  go_puts("  ORDERING IS NOT JUDGED, ON PURPOSE. Deriving it from textual position flagged SEVEN\n" as *u8)
  go_puts("  innocent gates (helper definitions, test fixtures, /tmp writes) and this organ's own gate.\n" as *u8)
  go_puts("  A WRONG ANSWER IS WORSE THAN AN ABSENT ONE, and a sev7 built on a bad detector sends other\n" as *u8)
  go_puts("  seats to edit correct code. Catch ordering by READING THE LOG against the gate output.\n" as *u8)
  go_puts("  classifier gate: nx_gateorder_gate (carries a revert-detector for the ordering verdict).\n" as *u8)
  return 0
254}
nx_gateorder.nx source

`nx_gateorder.nx` source
