`nx_drv_bind.nx` source

↩ module page · 279 lines · 14136 B
1// nx_drv_bind.nx -- AUTONOMOUS DRIVER BRING-UP (X-DRV-W2), the driver registry binder.
2//
3// Composes X-DRV-W0 (HWMAP probe) + X-DRV-W1 (driver-protocol-from-spec emit) into a hands-off
4// loop that brings up ANY iron with NO per-device code:
5//   PROBE   -- read the device manifest (emu_devmap.tsv = the emu's MMIO bus probe output, the
6//              analog of hwmap.tsv for PCI): each row = (base, DeviceID).
7//   LOOK UP -- for each device, find its DeviceID in driver_registry.tsv -> a driver SPEC (an
8//              X-DRV-W1 op-list).  Unknown DeviceID -> UNBOUND (honest: no driver for that iron,
9//              never a false bind).
10//   EMIT    -- run nx_drv_proto_emit <spec> <probed-base> <out> : the SAME spec is BOUND to the
11//              address the probe found (the base override) -> bring up the device wherever it is.
12//   RUN     -- run the emitted driver on the SOVEREIGN rv64 emu; if the serial contains the
13//              driver's golden + a clean halt, the device is BOUND + WORKING.
14//
15// A NEW device class = a NEW registry row + a NEW op-list spec; THIS organ and the emitter never
16// change.  Evidence -> knowledge/status/driver_bind.log.  argv[1]=devmap path (default
17// emu_devmap.tsv), argv[2]=registry path (default driver_registry.tsv) -- scratch lanes for the
18// gate's adversarial manifests.  Sovereign (fork/dup3/execve/wait4), no gcc/.sh.
19// license_tier: ORIGINAL
20import "nx_syscalls.nx"
21const NB_MAGIC_65536: i64 = 65536
22const NB_MAGIC_2048: i64 = 2048
23
24const NB_EMIT_ELF: *u8 = "_offc/nx_drv_proto_emit.elf"
25const NB_SOV_ELF:  *u8 = "_offc/nx_boot_run_sov.elf"
26const NB_MAXDEV:   i64 = 64
27const NB_MAXREG:   i64 = 64
28
29func nb_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
30func nb_fp(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
31func nb_fn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
32func nb_n(v: i64) -> i64 { nb_fn(1, v); return 0 }
33
34// write decimal string of v into out (NUL-term); return length.
35func nb_itoa(v: i64, out: *u8) -> i64 {
  var m: i64 = v
  if m < 0 { m = 0 - m }
  let t: *u8 = sys_mmap(28); var k: i64 = 0
  if m == 0 { t[0] = 48; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { out[i] = t[k-1-i]; i = i + 1 }
  out[k] = 0 as u8
  return k
45}
46
47func nb_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap - 1 { go = 0 } }
  sys_close(fd)
  return n
55}
56
57// parse a hex (0x..) or decimal token at p in [.,le); returns value; *endp = next.
58func nb_parse_num(buf: *u8, p: i64, le: i64, endp: *i64) -> i64 {
  var q: i64 = p
  var val: i64 = 0
  if q + 1 < le { if buf[q] == (48 as u8) { if buf[q+1] == (120 as u8) {
      q = q + 2
      var go: i64 = 1
      while go == 1 {
          if q >= le { go = 0 } else {
              let c: i64 = buf[q] as i64
              var d: i64 = 0 - 1
              if c >= 48 { if c <= 57 { d = c - 48 } }
              if c >= 97 { if c <= 102 { d = c - 87 } }
              if c >= 65 { if c <= 70 { d = c - 55 } }
              if d < 0 { go = 0 } else { val = (val * 16) + d; q = q + 1 }
          }
      }
      endp[0] = q
      return val
  }}}
  var go2: i64 = 1
  while go2 == 1 {
      if q >= le { go2 = 0 } else {
          let c: i64 = buf[q] as i64
          if c >= 48 { if c <= 57 { val = (val * 10) + (c - 48); q = q + 1 } else { go2 = 0 } } else { go2 = 0 }
      }
  }
  endp[0] = q
  return val
86}
87
88// return the start offset of the idx-th TAB-separated field in line [ls,le), or -1 if absent.
89func nb_field_start(buf: *u8, ls: i64, le: i64, idx: i64) -> i64 {
  if idx == 0 { return ls }
  var f: i64 = 0
  var p: i64 = ls
  while p < le {
      if buf[p] == (9 as u8) {
          f = f + 1
          if f == idx { return p + 1 }
      }
      p = p + 1
  }
  return 0 - 1
101}
102
103// run prog with up to 3 args (any may be null after the first null); stdout/stderr -> outpath;
104// return WEXITSTATUS (or 128+sig).
105func nb_run(prog: *u8, a1: *u8, a2: *u8, a3: *u8, outpath: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      if outpath != (0 as *u8) { let ofd: i64 = sys_openat_wr(outpath, 0x1a4); if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) } }
      else { let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4); if dn >= 0 { sys_dup3(dn, 1, 0) } }
      let argv: *i64 = sys_mmap(64) as *i64
      argv[0] = prog as i64
      var k: i64 = 1
      if a1 != (0 as *u8) { argv[k] = a1 as i64; k = k + 1 }
      if a2 != (0 as *u8) { argv[k] = a2 as i64; k = k + 1 }
      if a3 != (0 as *u8) { argv[k] = a3 as i64; k = k + 1 }
      argv[k] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
      sys_execve(prog, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
127}
128
129// does buf[0,n) contain pat (length pl)?  1/0
130func nb_has(buf: *u8, n: i64, pat: *u8, pl: i64) -> i64 {
  if pl <= 0 { return 0 }
  var i: i64 = 0
  while i + pl <= n {
      var k: i64 = 0; var hit: i64 = 1
      while k < pl { if buf[i+k] != pat[k] { hit = 0; k = pl } else { k = k + 1 } }
      if hit == 1 { return 1 }
      i = i + 1
  }
  return 0
140}
141
142func main(argc: i64, argv: *i64) -> i64 {
  var devmap_path: *u8 = "knowledge/registry/emu_devmap.tsv" as *u8
  var reg_path:    *u8 = "knowledge/registry/driver_registry.tsv" as *u8
  if argc >= 2 { devmap_path = argv[1] as *u8 }
  if argc >= 3 { reg_path = argv[2] as *u8 }
147
  nb_p("=== nx_drv_bind: autonomous driver bring-up (probe -> registry lookup -> emit-bound -> run) ===\n" as *u8)
  let lfd: i64 = sys_openat_append("knowledge/status/driver_bind.log" as *u8, 0x1a4)
150
  // ---- load the driver registry: deviceid -> spec ----
  let regbuf: *u8 = sys_mmap(NB_MAGIC_65536)
  let regn: i64 = nb_read(reg_path, regbuf, NB_MAGIC_65536)
  if regn <= 0 { nb_p("DRVBIND verdict=RED reason=registry-missing\n" as *u8); if lfd>=0 { nb_fp(lfd, "DRVBIND verdict=RED reason=registry-missing\n" as *u8); sys_close(lfd) } sys_exit(1); return 1 }
  let reg_id:   *i64 = sys_mmap(8 * NB_MAXREG) as *i64
  let reg_spec: *u8  = sys_mmap(NB_MAXREG * 256)     // 256 bytes per spec path
  var nreg: i64 = 0
  let ep: *i64 = sys_mmap(16) as *i64
  var rls: i64 = 0
  while rls < regn {
      var rle: i64 = rls
      var sc: i64 = 1
      while sc == 1 { if rle >= regn { sc = 0 } else { if regbuf[rle] == (10 as u8) { sc = 0 } else { rle = rle + 1 } } }
      if regbuf[rls] != (35 as u8) {
          let f0: i64 = nb_field_start(regbuf, rls, rle, 0)
          let f1: i64 = nb_field_start(regbuf, rls, rle, 1)
          if f0 >= 0 { if f1 >= 0 {
              if nreg < NB_MAXREG {
                  reg_id[nreg] = nb_parse_num(regbuf, f0, rle, ep)
                  // copy spec field (until tab/eol) into reg_spec[nreg*256]
                  var c: i64 = 0
                  var q: i64 = f1
                  while q < rle { if regbuf[q] == (9 as u8) { q = rle + 0 } else { reg_spec[nreg*256 + c] = regbuf[q]; c = c + 1; q = q + 1 } }
                  reg_spec[nreg*256 + c] = 0 as u8
                  nreg = nreg + 1
              }
          } }
      }
      rls = rle + 1
  }
181
  // ---- load the device manifest (probe): base, deviceid ----
  let devbuf: *u8 = sys_mmap(NB_MAGIC_65536)
  let devn: i64 = nb_read(devmap_path, devbuf, NB_MAGIC_65536)
  if devn <= 0 { nb_p("DRVBIND verdict=RED reason=devmap-missing\n" as *u8); if lfd>=0 { nb_fp(lfd, "DRVBIND verdict=RED reason=devmap-missing\n" as *u8); sys_close(lfd) } sys_exit(1); return 1 }
186
  var probed: i64 = 0
  var bound_working: i64 = 0
  var unbound: i64 = 0
  var failed: i64 = 0
191
  let basebuf: *u8 = sys_mmap(32)
  let outpath: *u8 = sys_mmap(256)
  let goldpath: *u8 = sys_mmap(256)
  let golden: *u8 = sys_mmap(NB_MAGIC_2048)
  let serial: *u8 = sys_mmap(NB_MAGIC_65536)
  let idbuf: *u8 = sys_mmap(32)
198
  var dls: i64 = 0
  while dls < devn {
      var dle: i64 = dls
      var sc2: i64 = 1
      while sc2 == 1 { if dle >= devn { sc2 = 0 } else { if devbuf[dle] == (10 as u8) { sc2 = 0 } else { dle = dle + 1 } } }
      if devbuf[dls] != (35 as u8) {
          let g0: i64 = nb_field_start(devbuf, dls, dle, 0)
          let g1: i64 = nb_field_start(devbuf, dls, dle, 1)
          if g0 >= 0 { if g1 >= 0 {
              let base: i64 = nb_parse_num(devbuf, g0, dle, ep)
              let did:  i64 = nb_parse_num(devbuf, g1, dle, ep)
              probed = probed + 1
              // registry lookup: deviceid -> spec
              var spec_idx: i64 = 0 - 1
              var ri: i64 = 0
              while ri < nreg { if reg_id[ri] == did { spec_idx = ri } ri = ri + 1 }
              nb_p("  probe base=" as *u8); nb_n(base); nb_p(" deviceid=" as *u8); nb_n(did)
              if spec_idx < 0 {
                  unbound = unbound + 1
                  nb_p(" -> UNBOUND (no registry entry)\n" as *u8)
                  if lfd >= 0 { nb_fp(lfd, "DRVBIND probe deviceid=" as *u8); nb_fn(lfd, did); nb_fp(lfd, " base=" as *u8); nb_fn(lfd, base); nb_fp(lfd, " status=UNBOUND\n" as *u8) }
              } else {
                  let spec: *u8 = (reg_spec as i64 + spec_idx*256) as *u8
                  // out path = runtime/_hdl_build/_bound_dev<did>.bin
                  var oo: i64 = 0
                  let pfx: *u8 = "runtime/_hdl_build/_bound_dev" as *u8
                  while pfx[oo] != (0 as u8) { outpath[oo] = pfx[oo]; oo = oo + 1 }
                  let idl: i64 = nb_itoa(did, idbuf)
                  var ic: i64 = 0
                  while ic < idl { outpath[oo] = idbuf[ic]; oo = oo + 1; ic = ic + 1 }
                  let sfx: *u8 = ".bin" as *u8
                  var sj: i64 = 0
                  while sfx[sj] != (0 as u8) { outpath[oo] = sfx[sj]; oo = oo + 1; sj = sj + 1 }
                  outpath[oo] = 0 as u8
                  // base as decimal string for the emitter override arg
                  nb_itoa(base, basebuf)
                  // EMIT the driver bound to the probed base
                  let est: i64 = nb_run(NB_EMIT_ELF, spec, basebuf, outpath, "/tmp/_drvbind_emit.out" as *u8)
                  if est != 0 {
                      failed = failed + 1
                      nb_p(" -> spec=" as *u8); nb_p(spec); nb_p(" EMIT-FAILED\n" as *u8)
                      if lfd >= 0 { nb_fp(lfd, "DRVBIND probe deviceid=" as *u8); nb_fn(lfd, did); nb_fp(lfd, " status=EMIT-FAILED\n" as *u8) }
                  } else {
                      // golden path = <out>.gold
                      var gj: i64 = 0
                      while outpath[gj] != (0 as u8) { goldpath[gj] = outpath[gj]; gj = gj + 1 }
                      let gext: *u8 = ".gold" as *u8
                      var ge: i64 = 0
                      while gext[ge] != (0 as u8) { goldpath[gj] = gext[ge]; gj = gj + 1; ge = ge + 1 }
                      goldpath[gj] = 0 as u8
                      let gn: i64 = nb_read(goldpath, golden, NB_MAGIC_2048)
                      golden[gn] = 0 as u8
                      // RUN on the sovereign emu
                      let rst: i64 = nb_run(NB_SOV_ELF, outpath, 0 as *u8, 0 as *u8, "/tmp/_drvbind_serial.txt" as *u8)
                      let sn: i64 = nb_read("/tmp/_drvbind_serial.txt" as *u8, serial, NB_MAGIC_65536)
                      let work: i64 = nb_has(serial, sn, golden, gn)
                      let halt: i64 = nb_has(serial, sn, "BOOTSOV verdict=GREEN" as *u8, 21)
                      var ok: i64 = 0
                      if rst == 0 { if gn > 0 { if work == 1 { if halt == 1 { ok = 1 } } } }
                      if ok == 1 {
                          bound_working = bound_working + 1
                          nb_p(" -> spec=" as *u8); nb_p(spec); nb_p(" BOUND+WORKING golden=" as *u8); nb_p(golden); nb_p("\n" as *u8)
                          if lfd >= 0 { nb_fp(lfd, "DRVBIND probe deviceid=" as *u8); nb_fn(lfd, did); nb_fp(lfd, " base=" as *u8); nb_fn(lfd, base); nb_fp(lfd, " spec=" as *u8); nb_fp(lfd, spec); nb_fp(lfd, " status=BOUND-WORKING golden=" as *u8); nb_fp(lfd, golden); nb_fp(lfd, "\n" as *u8) }
                      } else {
                          failed = failed + 1
                          nb_p(" -> spec=" as *u8); nb_p(spec); nb_p(" BOUND-NOT-WORKING\n" as *u8)
                          if lfd >= 0 { nb_fp(lfd, "DRVBIND probe deviceid=" as *u8); nb_fn(lfd, did); nb_fp(lfd, " status=BOUND-NOT-WORKING\n" as *u8) }
                      }
                  }
              }
          } }
      }
      dls = dle + 1
  }
273
  nb_p("DRVBIND summary probed=" as *u8); nb_n(probed); nb_p(" bound_working=" as *u8); nb_n(bound_working); nb_p(" unbound=" as *u8); nb_n(unbound); nb_p(" failed=" as *u8); nb_n(failed); nb_p("\n" as *u8)
  if lfd >= 0 { nb_fp(lfd, "DRVBIND summary probed=" as *u8); nb_fn(lfd, probed); nb_fp(lfd, " bound_working=" as *u8); nb_fn(lfd, bound_working); nb_fp(lfd, " unbound=" as *u8); nb_fn(lfd, unbound); nb_fp(lfd, " failed=" as *u8); nb_fn(lfd, failed); nb_fp(lfd, " epoch=" as *u8); nb_fn(lfd, sys_now_realtime_sec()); nb_fp(lfd, "\n" as *u8); sys_close(lfd) }
  if failed > 0 { sys_exit(1); return 1 }
  sys_exit(0)
  return 0
279}
nx_drv_bind.nx source

`nx_drv_bind.nx` source
