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

↩ module page · 277 lines · 14867 B
1// nx_res_census.nx -- THE RUNTIME RESOURCE WITNESS (per-daemon + system, trend-logged). 2026-07-05 OOM arc +
2// operator: "efficiency in our resource use across ALL the nishi ecosystems ... live resources and storage and
3// all the other axes" + "measured every poll, not discovered at OOM".
4//
5// WHY THIS ORGAN EXISTS (no-tool-proliferation: consolidation-check DONE, justified NEW): nx_explore for
6// VmRSS / proc_status / resource_census / diskspace = 0 files -- NOTHING reads per-process memory anywhere in
7// the ecosystem; the 26GiB health_eval leak + the 2.5TB clock commit were discovered AT OOM, and the leak
8// diagnosis lived only in a memory note. This is the RUNTIME half of the two-witness law: the static half
9// (nx_antipattern_catalog leaksweep) catches the DIRECT mmap-in-loop shape but proved BLIND to the
10// helper-indirection tier (nx_seed_announce_all: 199MB grown, ZERO static sites) -- only a per-daemon
11// RSS/VmSize GROWTH TREND catches that class. Single responsibility (Cardinal 9): MEASURE + LOG + show DELTA.
12// It is a WITNESS, not a judge -- no thresholds baked in (Cardinal 11); the judge tier composes later
13// (nx_metric_ledger BETTER/WORSE, mgmt_snapshot surface, clock-registry cadence = OWNER wiring on the NAS;
14// hardware-up honesty: this run proves the mechanism on the dev substrate, the target wiring is hostctl/clock).
15//
16// SIGNATURE TABLE (banked by the OOM workstream): huge VmSize = commit-leak / fork-wedge class; huge anon-RSS
17// = the OOM-killer class. Both columns logged so the trend separates them.
18//
19// MMAP DISCIPLINE: every buffer HOISTED once in main -- this organ must scan CLEAN under the leaksweep it
20// complements (practice the law). license_tier: ORIGINAL   lineage_id: nishi_res_census_v1   expect_exit: 0
21import "nx_sovjson_lib.nx"
22import "nx_syscalls.nx"
23import "nx_dir.nx"
24
25const RC_LOG: *u8 = "knowledge/status/res_census.log\x00"
26const RC_PIDCAP: i64 = 8192            // /proc numeric entries enumerated (dir rows)
27const RC_FBUF: i64 = 65536             // one proc-file read buffer (status/cmdline/meminfo), reused
28const RC_LOGBUF: i64 = 4194304         // prior trend-log window for delta lookup (TRUNC honestly noted)
29
30func rc_slen(s: *u8) -> i64 { return sj_vlen(s) }
31func rc_w(fd: i64, s: *u8) -> i64 { sys_write(fd, s, rc_slen(s)); return 0 }
32// digits writer via caller-provided scratch (NO per-call mmap -- the whole point of this arc)
33func rc_wn(fd: i64, v: i64, scr: *u8) -> i64 {
  var m: i64 = v
  if m < 0 { sys_write(fd, "-\x00" as *u8, 1); m = 0 - m }
  var k: i64 = 0
  if m == 0 { scr[0] = 48 as u8; k = 1 }
  while m > 0 { scr[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { scr[24 + i] = scr[k - 1 - i]; i = i + 1 }
  sys_write(fd, (scr as i64 + 24) as *u8, k)
  return 0
43}
44func rc_cat(dst: *u8, o: i64, s: *u8) -> i64 { return sj_cat(dst, o, s) }
45func rc_catn(dst: *u8, o: i64, v: i64, scr: *u8) -> i64 {
  var x: i64 = o; var m: i64 = v
  if m < 0 { dst[x] = 45 as u8; x = x + 1; m = 0 - m }
  var k: i64 = 0
  if m == 0 { scr[0] = 48 as u8; k = 1 }
  while m > 0 { scr[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var j: i64 = 0
  while j < k { dst[x] = scr[k - 1 - j]; x = x + 1; j = j + 1 }
  return x
54}
55// substring find in buf[0..n) -> first index or -1
56func rc_find(buf: *u8, n: i64, needle: *u8) -> i64 {
  let nl: i64 = rc_slen(needle)
  if nl == 0 { return 0 - 1 }
  var i: i64 = 0
  while i + nl <= n {
      var m: i64 = 0; var ok: i64 = 1
      while m < nl { if buf[i + m] != needle[m] { ok = 0; m = nl } else { m = m + 1 } }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
67}
68// parse the first decimal run at/after buf[i..n) -> value (skips non-digits first); -1 if none
69func rc_num_after(buf: *u8, n: i64, i0: i64) -> i64 {
  var i: i64 = i0
  while i < n { if buf[i] >= (48 as u8) { if buf[i] <= (57 as u8) { break } } i = i + 1 }
  if i >= n { return 0 - 1 }
  var v: i64 = 0
  while i < n { if buf[i] < (48 as u8) { break } if buf[i] > (57 as u8) { break } v = v * 10 + ((buf[i] - (48 as u8)) as i64); i = i + 1 }
  return v
76}
77// "Label:   12345 kB" -> 12345; -1 when label absent
78func rc_kb(buf: *u8, n: i64, label: *u8) -> i64 {
  let p: i64 = rc_find(buf, n, label)
  if p < 0 { return 0 - 1 }
  return rc_num_after(buf, n, p + rc_slen(label))
82}
83func rc_all_digits(nm: *u8, len: i64) -> i64 {
  if len <= 0 { return 0 }
  var i: i64 = 0
  while i < len { if nm[i] < (48 as u8) { return 0 } if nm[i] > (57 as u8) { return 0 } i = i + 1 }
  return 1
88}
89// open + read whole small file into caller buffer -> bytes (0 on open fail). NO allocation here.
90func rc_readf(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var total: i64 = 0; var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, (buf as i64 + total) as *u8, cap - total)
      if r <= 0 { go = 0 } else { total = total + r; if total >= cap { go = 0 } }
  }
  sys_close(fd)
  return total
100}
101func rc_openat_append(path: *u8) -> i64 { return __syscall(257, AT_FDCWD, path, 0x441, 0x1a4, 0, 0) }   // O_WRONLY|O_CREAT|O_APPEND 0644 (same idiom as nx_tools_api revocation list)
102
103// last prior sample for `name` in the trend log: find the LAST "RESC <epoch> <name> " line, pull field after
104// tag ("rss_kb=" or "vm_kb="). -1 when no history. (Scan is linear over the window; ~60B/line -> 4MB window
105// ~= 70k samples; when the log outgrows the window we TRUNC-note rather than silently mis-trend.)
106func rc_prev(logbuf: *u8, ln: i64, name: *u8, tag: *u8) -> i64 {
  var best: i64 = 0 - 1
  var i: i64 = 0
  let nl: i64 = rc_slen(name)
  while i < ln {
      // line starts here; must begin "RESC "
      if i + 5 < ln {
          if logbuf[i] == (82 as u8) {           // 'R'
              if rc_find((logbuf as i64 + i) as *u8, 5, "RESC \x00" as *u8) == 0 {
                  // name is the 3rd space-separated field: skip "RESC ", skip epoch digits, skip one space
                  var j: i64 = i + 5
                  while j < ln { if logbuf[j] == (32 as u8) { break } j = j + 1 }
                  j = j + 1
                  // compare [j..j+nl) == name and next char is ' '
                  if j + nl < ln {
                      var m: i64 = 0; var ok: i64 = 1
                      while m < nl { if logbuf[j + m] != name[m] { ok = 0; m = nl } else { m = m + 1 } }
                      if ok == 1 { if logbuf[j + nl] != (32 as u8) { ok = 0 } }
                      if ok == 1 {
                          // find tag within THIS line only
                          var e: i64 = j
                          while e < ln { if logbuf[e] == (10 as u8) { break } e = e + 1 }
                          let rel: i64 = rc_find((logbuf as i64 + j) as *u8, e - j, tag)
                          if rel >= 0 { let v: i64 = rc_num_after((logbuf as i64 + j) as *u8, e - j, rel + rc_slen(tag)); if v >= 0 { best = v } }
                      }
                  }
              }
          }
      }
      while i < ln { if logbuf[i] == (10 as u8) { break } i = i + 1 }
      i = i + 1
  }
  return best
139}
140
141func main(argc: i64, argv: *i64) -> i64 {
  var procroot: *u8 = "/proc\x00" as *u8
  if argc >= 2 { procroot = argv[1] as *u8 }   // override = the LIAR-KILL lever (bogus root must yield 0)
144
  // ---- ALL buffers hoisted ONCE (this organ must pass the leaksweep it complements) ----
  let rows: *NxDirRow = (sys_mmap(NX_DIR_ROW_BYTES * RC_PIDCAP)) as *NxDirRow
  let arena: *u8 = sys_mmap(RC_PIDCAP * 32)
  let res: *NxDirResult = (sys_mmap(64)) as *NxDirResult
  let fbuf: *u8 = sys_mmap(RC_FBUF)          // one proc-file buffer, reused for every read
  let logbuf: *u8 = sys_mmap(RC_LOGBUF)      // prior trend window
  let path: *u8 = sys_mmap(512)
  let name: *u8 = sys_mmap(128)
  let line: *u8 = sys_mmap(512)
  let scr: *u8 = sys_mmap(64)                // shared digits scratch (rc_wn/rc_catn)
155
  rc_w(1, "=== nx_res_census -- RUNTIME resource witness (per-nishi-daemon RSS/VmSize + system; trend vs last) ===\n\x00" as *u8)
157
  // prior log window (for deltas)
  let ln: i64 = rc_readf(RC_LOG, logbuf, RC_LOGBUF)
  if ln >= RC_LOGBUF { rc_w(1, "  ⚠ trend window FULL (4MB) -- oldest history beyond window not consulted (no silent lie; rotate the log)\n\x00" as *u8) }
161
  let epoch: i64 = sys_now_realtime_sec()
  let logfd: i64 = rc_openat_append(RC_LOG)
164
  // ---- SYSTEM axes first: MemAvailable / SwapFree (meminfo) + load1 (loadavg) ----
  var o: i64 = 0
  o = rc_cat(path, 0, procroot); o = rc_cat(path, o, "/meminfo\x00" as *u8); path[o] = 0 as u8
  let mn: i64 = rc_readf(path, fbuf, RC_FBUF)
  let memavail: i64 = rc_kb(fbuf, mn, "MemAvailable:\x00" as *u8)
  let swapfree: i64 = rc_kb(fbuf, mn, "SwapFree:\x00" as *u8)
  o = rc_cat(path, 0, procroot); o = rc_cat(path, o, "/loadavg\x00" as *u8); path[o] = 0 as u8
  let ldn: i64 = rc_readf(path, fbuf, RC_FBUF)
  // load1 as reported text (first token verbatim -- no float math needed for a witness)
  var l1e: i64 = 0
  while l1e < ldn { if fbuf[l1e] == (32 as u8) { break } l1e = l1e + 1 }
  if mn > 0 {
      var lo: i64 = rc_cat(line, 0, "RESC \x00" as *u8)
      lo = rc_catn(line, lo, epoch, scr)
      lo = rc_cat(line, lo, " SYSTEM memavail_kb=\x00" as *u8); lo = rc_catn(line, lo, memavail, scr)
      lo = rc_cat(line, lo, " swapfree_kb=\x00" as *u8); lo = rc_catn(line, lo, swapfree, scr)
      lo = rc_cat(line, lo, " load1=\x00" as *u8)
      var t: i64 = 0
      while t < l1e { if lo < 500 { line[lo] = fbuf[t]; lo = lo + 1 } t = t + 1 }
      line[lo] = 10 as u8; lo = lo + 1
      sys_write(1, "  \x00" as *u8, 2); sys_write(1, line, lo)
      if logfd >= 0 { sys_write(logfd, line, lo) }
  }
188
  // ---- per-daemon axes: every /proc/<pid> whose cmdline names an nx_ organ ----
  let rc: i64 = nx_dir_list(procroot, rows, RC_PIDCAP, arena, RC_PIDCAP * 32, 0, res)
  var found: i64 = 0
  var grew: i64 = 0
  if res.n_filled > 0 {
      var i: i64 = 0
      while i < res.n_filled {
          let row: *NxDirRow = ((rows as i64) + i * NX_DIR_ROW_BYTES) as *NxDirRow
          i = i + 1
          if rc_all_digits(row.name_ptr, row.name_len) != 1 { continue }
          // cmdline -> is it ours? (argv0 contains "nx_")
          var po: i64 = rc_cat(path, 0, procroot); path[po] = 47 as u8; po = po + 1
          var k: i64 = 0
          while k < row.name_len { path[po] = row.name_ptr[k]; po = po + 1; k = k + 1 }
          let pidend: i64 = po
          po = rc_cat(path, po, "/cmdline\x00" as *u8); path[po] = 0 as u8
          let cn: i64 = rc_readf(path, fbuf, RC_FBUF)
          if cn <= 0 { continue }
          if rc_find(fbuf, cn, "nx_\x00" as *u8) < 0 { continue }
          // short name = basename of argv0 (argv0 ends at first NUL)
          var a0e: i64 = 0
          while a0e < cn { if fbuf[a0e] == (0 as u8) { break } a0e = a0e + 1 }
          var bs: i64 = 0
          var s: i64 = 0
          while s < a0e { if fbuf[s] == (47 as u8) { bs = s + 1 } s = s + 1 }
          var nn: i64 = 0
          while bs < a0e { if nn < 120 { name[nn] = fbuf[bs]; nn = nn + 1 } bs = bs + 1 }
          name[nn] = 0 as u8
          // status -> VmRSS / VmSize
          po = pidend
          po = rc_cat(path, po, "/status\x00" as *u8); path[po] = 0 as u8
          let sn: i64 = rc_readf(path, fbuf, RC_FBUF)
          if sn <= 0 { continue }
          let rss: i64 = rc_kb(fbuf, sn, "VmRSS:\x00" as *u8)
          let vsz: i64 = rc_kb(fbuf, sn, "VmSize:\x00" as *u8)
          if rss < 0 { continue }   // kernel thread / no VM -- not a daemon we account
          found = found + 1
          // trend vs last sample of the SAME name
          let prss: i64 = rc_prev(logbuf, ln, name, "rss_kb=\x00" as *u8)
          let pvsz: i64 = rc_prev(logbuf, ln, name, "vm_kb=\x00" as *u8)
          var lo2: i64 = rc_cat(line, 0, "RESC \x00" as *u8)
          lo2 = rc_catn(line, lo2, epoch, scr)
          lo2 = rc_cat(line, lo2, " \x00" as *u8)
          lo2 = rc_cat(line, lo2, name)
          lo2 = rc_cat(line, lo2, " pid=\x00" as *u8)
          var pi: i64 = 0
          while pi < row.name_len { line[lo2] = row.name_ptr[pi]; lo2 = lo2 + 1; pi = pi + 1 }
          lo2 = rc_cat(line, lo2, " rss_kb=\x00" as *u8); lo2 = rc_catn(line, lo2, rss, scr)
          lo2 = rc_cat(line, lo2, " vm_kb=\x00" as *u8); lo2 = rc_catn(line, lo2, vsz, scr)
          line[lo2] = 10 as u8
          if logfd >= 0 { sys_write(logfd, line, lo2 + 1) }
          // stdout adds the delta view (the WITNESS: growth is visible per run, at +kb not at OOM)
          sys_write(1, "  \x00" as *u8, 2); sys_write(1, line, lo2)
          if prss >= 0 {
              rc_w(1, "   [d_rss=\x00" as *u8); rc_wn(1, rss - prss, scr)
              rc_w(1, "kb d_vm=\x00" as *u8); rc_wn(1, vsz - pvsz, scr)
              rc_w(1, "kb since last]\x00" as *u8)
              if rss - prss > 0 { grew = grew + 1 }
          } else {
              rc_w(1, "   [first sample -- baseline]\x00" as *u8)
          }
          rc_w(1, "\n\x00" as *u8)
      }
  }
  if logfd >= 0 { sys_close(logfd) }
254
  // ---- GATE (prove-not-assert): [pos] the census must find >=1 nishi process -- ITSELF (self-witness:
  // our own cmdline names nx_res_census). [neg/liar-kill] a bogus proc root must enumerate NOTHING. ----
  let bres: *NxDirResult = res   // reuse the hoisted result struct for the control
  let brc: i64 = nx_dir_list("/proc_bogus_rc_zzz9\x00" as *u8, rows, RC_PIDCAP, arena, RC_PIDCAP * 32, 0, bres)
  var neg_ok: i64 = 0
  if bres.n_filled <= 0 { neg_ok = 1 }
261
  rc_w(1, "  ---- RES-CENSUS GATE ----\n\x00" as *u8)
  rc_w(1, "  nishi processes witnessed=\x00" as *u8); rc_wn(1, found, scr)
  rc_w(1, " (self-witness expected>=1)  grew_since_last=\x00" as *u8); rc_wn(1, grew, scr)
  rc_w(1, "  liar-kill(bogus /proc -> 0)=\x00" as *u8)
  if neg_ok == 1 { rc_w(1, "PASS\n\x00" as *u8) } else { rc_w(1, "FAIL\n\x00" as *u8) }
  rc_w(1, "  trend log -> knowledge/status/res_census.log (append-only; the judge tier composes nx_metric_ledger / mgmt_snapshot; NAS cadence = clock-registry wiring, owner-gated)\n\x00" as *u8)
  var ok: i64 = 1
  if found < 1 { ok = 0 }
  if neg_ok != 1 { ok = 0 }
  if ok == 1 {
      rc_w(1, "NX-RES-CENSUS GREEN: runtime witness live (per-daemon rss/vm + system axes, delta vs last) -- the 2nd witness the leaksweep cannot be\n\x00" as *u8)
      sys_exit(0); return 0
  }
  rc_w(1, "NX-RES-CENSUS RED: witness failed its controls\n\x00" as *u8)
  sys_exit(1); return 1
277}
nx_res_census.nx source

`nx_res_census.nx` source
