@threadedstack/wmd-web 0.0.0-stage → 0.1.13

package/src/calib-worker.js

@@ -0,0 +1,40 @@
+// Throttle detector (boot.js, host/monitor.js createThrottleMeter). Every intervalMs
+// this Worker times a fixed amount of integer work and a 10 ms Atomics.wait, and
+// posts {t:'calib', workMs, waitLateMs}. When the browser deprioritises the page's
+// process (Chromium lowers the priority of a minimised or occluded window's renderer),
+// every Worker of the page, the guest's vCPUs included, runs slower; the page compares
+// workMs with the fastest run it has seen. The work is ~1% of one core.
+
+const WORK = 5_000_000
+const cell = new Int32Array(new SharedArrayBuffer(4))
+let sink = 0
+
+function work() {
+  let x = 0x12345678 ^ sink
+  for (let i = 0; i < WORK; i++) {
+    x ^= x << 13
+    x ^= x >>> 17
+    x ^= x << 5
+  }
+  sink = x
+}
+
+function measure() {
+  const t0 = performance.now()
+  work()
+  const t1 = performance.now()
+  Atomics.wait(cell, 0, 0, 10)
+  const t2 = performance.now()
+  self.postMessage({ t: 'calib', workMs: t1 - t0, waitLateMs: Math.max(0, t2 - t1 - 10) })
+}
+
+self.onmessage = e => {
+  for (let i = 0; i < 3; i++) work() // warm up the JIT so the first samples are not the slowest
+  if (e.data.t === 'once') {
+    for (let i = 0; i < e.data.n; i++) measure()
+    return
+  }
+  if (e.data.t !== 'start') return
+  measure()
+  setInterval(measure, e.data.intervalMs)
+}

package/src/fs/9p/codec.js

@@ -0,0 +1,303 @@
+// 9P2000.L message codec: every T and R message the Linux v9fs client and a
+// 9P2000.L server exchange, both directions (a server decodes T and encodes R;
+// tests and clients do the opposite).
+//
+// Frame: size[4] (little endian, including itself) type[1] tag[2] fields.
+// Strings are u16 length + bytes, held as byte strings (one char per byte,
+// see ../pack.js). u64 fields decode to a Number when they fit in 53 bits,
+// else a BigInt, and encode from either.
+
+export const NOTAG = 0xffff
+export const NOFID = 0xffffffff
+export const HEADER = 7
+/** Rread/Rwrite/Treaddir overhead: header + count[4] (P9_IOHDRSZ is 24 for Twrite). */
+export const IOHDRSZ = 24
+
+// Field kinds.
+const U8 = 'u8', U16 = 'u16', U32 = 'u32', U64 = 'u64', S = 's', QID = 'qid'
+const DATA = 'data', WNAMES = 'wnames', QIDS = 'qids'
+
+/** type number -> [name, [[field, kind], ...]] */
+export const MESSAGES = {
+  6: ['Tlerror', []],
+  7: ['Rlerror', [['ecode', U32]]],
+  8: ['Tstatfs', [['fid', U32]]],
+  9: ['Rstatfs', [['fstype', U32], ['bsize', U32], ['blocks', U64], ['bfree', U64], ['bavail', U64],
+    ['files', U64], ['ffree', U64], ['fsid', U64], ['namelen', U32]]],
+  12: ['Tlopen', [['fid', U32], ['flags', U32]]],
+  13: ['Rlopen', [['qid', QID], ['iounit', U32]]],
+  14: ['Tlcreate', [['fid', U32], ['name', S], ['flags', U32], ['mode', U32], ['gid', U32]]],
+  15: ['Rlcreate', [['qid', QID], ['iounit', U32]]],
+  16: ['Tsymlink', [['fid', U32], ['name', S], ['symtgt', S], ['gid', U32]]],
+  17: ['Rsymlink', [['qid', QID]]],
+  18: ['Tmknod', [['dfid', U32], ['name', S], ['mode', U32], ['major', U32], ['minor', U32], ['gid', U32]]],
+  19: ['Rmknod', [['qid', QID]]],
+  20: ['Trename', [['fid', U32], ['dfid', U32], ['name', S]]],
+  21: ['Rrename', []],
+  22: ['Treadlink', [['fid', U32]]],
+  23: ['Rreadlink', [['target', S]]],
+  24: ['Tgetattr', [['fid', U32], ['mask', U64]]],
+  25: ['Rgetattr', [['valid', U64], ['qid', QID], ['mode', U32], ['uid', U32], ['gid', U32],
+    ['nlink', U64], ['rdev', U64], ['size', U64], ['blksize', U64], ['blocks', U64],
+    ['atime_sec', U64], ['atime_nsec', U64], ['mtime_sec', U64], ['mtime_nsec', U64],
+    ['ctime_sec', U64], ['ctime_nsec', U64], ['btime_sec', U64], ['btime_nsec', U64],
+    ['gen', U64], ['data_version', U64]]],
+  26: ['Tsetattr', [['fid', U32], ['valid', U32], ['mode', U32], ['uid', U32], ['gid', U32], ['size', U64],
+    ['atime_sec', U64], ['atime_nsec', U64], ['mtime_sec', U64], ['mtime_nsec', U64]]],
+  27: ['Rsetattr', []],
+  30: ['Txattrwalk', [['fid', U32], ['newfid', U32], ['name', S]]],
+  31: ['Rxattrwalk', [['size', U64]]],
+  32: ['Txattrcreate', [['fid', U32], ['name', S], ['size', U64], ['flags', U32]]],
+  33: ['Rxattrcreate', []],
+  40: ['Treaddir', [['fid', U32], ['offset', U64], ['count', U32]]],
+  41: ['Rreaddir', [['data', DATA]]],
+  50: ['Tfsync', [['fid', U32], ['datasync', U32]]],
+  51: ['Rfsync', []],
+  52: ['Tlock', [['fid', U32], ['ltype', U8], ['flags', U32], ['start', U64], ['length', U64],
+    ['proc_id', U32], ['client_id', S]]],
+  53: ['Rlock', [['status', U8]]],
+  54: ['Tgetlock', [['fid', U32], ['ltype', U8], ['start', U64], ['length', U64], ['proc_id', U32], ['client_id', S]]],
+  55: ['Rgetlock', [['ltype', U8], ['start', U64], ['length', U64], ['proc_id', U32], ['client_id', S]]],
+  70: ['Tlink', [['dfid', U32], ['fid', U32], ['name', S]]],
+  71: ['Rlink', []],
+  72: ['Tmkdir', [['dfid', U32], ['name', S], ['mode', U32], ['gid', U32]]],
+  73: ['Rmkdir', [['qid', QID]]],
+  74: ['Trenameat', [['olddirfid', U32], ['oldname', S], ['newdirfid', U32], ['newname', S]]],
+  75: ['Rrenameat', []],
+  76: ['Tunlinkat', [['dirfid', U32], ['name', S], ['flags', U32]]],
+  77: ['Runlinkat', []],
+  100: ['Tversion', [['msize', U32], ['version', S]]],
+  101: ['Rversion', [['msize', U32], ['version', S]]],
+  102: ['Tauth', [['afid', U32], ['uname', S], ['aname', S], ['n_uname', U32]]],
+  103: ['Rauth', [['aqid', QID]]],
+  104: ['Tattach', [['fid', U32], ['afid', U32], ['uname', S], ['aname', S], ['n_uname', U32]]],
+  105: ['Rattach', [['qid', QID]]],
+  108: ['Tflush', [['oldtag', U16]]],
+  109: ['Rflush', []],
+  110: ['Twalk', [['fid', U32], ['newfid', U32], ['wnames', WNAMES]]],
+  111: ['Rwalk', [['qids', QIDS]]],
+  116: ['Tread', [['fid', U32], ['offset', U64], ['count', U32]]],
+  117: ['Rread', [['data', DATA]]],
+  118: ['Twrite', [['fid', U32], ['offset', U64], ['data', DATA]]],
+  119: ['Rwrite', [['count', U32]]],
+  120: ['Tclunk', [['fid', U32]]],
+  121: ['Rclunk', []],
+  122: ['Tremove', [['fid', U32]]],
+  123: ['Rremove', []],
+}
+
+/** name -> type number */
+export const T = {}
+for (const [num, [name]] of Object.entries(MESSAGES)) T[name] = Number(num)
+
+export class ProtoError extends Error {}
+
+const TWO32 = 2 ** 32
+const MAX_SAFE = Number.MAX_SAFE_INTEGER
+
+function strBytesLen(s) {
+  return s.length
+}
+
+function sizeOf(kind, v) {
+  switch (kind) {
+    case U8: return 1
+    case U16: return 2
+    case U32: return 4
+    case U64: return 8
+    case S: return 2 + strBytesLen(v)
+    case QID: return 13
+    case DATA: return 4 + v.length
+    case WNAMES: { let n = 2; for (const s of v) n += 2 + s.length; return n }
+    case QIDS: return 2 + 13 * v.length
+  }
+  throw new ProtoError(`kind ${kind}`)
+}
+
+/** Writes into a DataView at a moving offset. */
+export class Writer {
+  constructor(u8) {
+    this.u8 = u8
+    this.dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength)
+    this.p = 0
+  }
+  u8_(v) { this.dv.setUint8(this.p, v); this.p += 1 }
+  u16(v) { this.dv.setUint16(this.p, v, true); this.p += 2 }
+  u32(v) { this.dv.setUint32(this.p, v >>> 0, true); this.p += 4 }
+  u64(v) {
+    if (typeof v === 'number' && v >= 0 && v <= MAX_SAFE && Number.isInteger(v)) {
+      this.dv.setUint32(this.p, v % TWO32, true)
+      this.dv.setUint32(this.p + 4, Math.floor(v / TWO32), true)
+    } else {
+      this.dv.setBigUint64(this.p, BigInt.asUintN(64, BigInt(v)), true)
+    }
+    this.p += 8
+  }
+  str(s) {
+    if (s.length > 0xffff) throw new ProtoError('string too long')
+    this.u16(s.length)
+    const u8 = this.u8
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i)
+      if (c > 0xff) throw new ProtoError('not a byte string')
+      u8[this.p + i] = c
+    }
+    this.p += s.length
+  }
+  qid(q) {
+    this.u8_(q.type)
+    this.u32(q.version || 0)
+    this.u64(q.path)
+  }
+  bytes(b) {
+    this.u8.set(b, this.p)
+    this.p += b.length
+  }
+}
+
+/** Reads from a Uint8Array at a moving offset; ProtoError when short. */
+export class Reader {
+  constructor(u8, p = 0, end = u8.length) {
+    this.u8 = u8
+    this.dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength)
+    this.p = p
+    this.end = end
+  }
+  need(n) {
+    if (this.p + n > this.end) throw new ProtoError('message too short')
+  }
+  u8_() { this.need(1); return this.dv.getUint8(this.p++) }
+  u16() { this.need(2); const v = this.dv.getUint16(this.p, true); this.p += 2; return v }
+  u32() { this.need(4); const v = this.dv.getUint32(this.p, true); this.p += 4; return v }
+  u64() {
+    this.need(8)
+    const lo = this.dv.getUint32(this.p, true)
+    const hi = this.dv.getUint32(this.p + 4, true)
+    this.p += 8
+    if (hi < 0x200000) return hi * TWO32 + lo
+    return (BigInt(hi) << 32n) | BigInt(lo)
+  }
+  str() {
+    const n = this.u16()
+    this.need(n)
+    const s = String.fromCharCode.apply(null, this.u8.subarray(this.p, this.p + n))
+    this.p += n
+    return s
+  }
+  qid() {
+    const type = this.u8_()
+    const version = this.u32()
+    const path = this.u64()
+    return { type, version, path }
+  }
+  bytes(n) {
+    this.need(n)
+    const b = this.u8.subarray(this.p, this.p + n)
+    this.p += n
+    return b
+  }
+}
+
+function writeField(w, kind, v) {
+  switch (kind) {
+    case U8: return w.u8_(v)
+    case U16: return w.u16(v)
+    case U32: return w.u32(v)
+    case U64: return w.u64(v)
+    case S: return w.str(v)
+    case QID: return w.qid(v)
+    case DATA: w.u32(v.length); return w.bytes(v)
+    case WNAMES: w.u16(v.length); for (const s of v) w.str(s); return
+    case QIDS: w.u16(v.length); for (const q of v) w.qid(q); return
+  }
+}
+
+function readField(r, kind) {
+  switch (kind) {
+    case U8: return r.u8_()
+    case U16: return r.u16()
+    case U32: return r.u32()
+    case U64: return r.u64()
+    case S: return r.str()
+    case QID: return r.qid()
+    case DATA: return r.bytes(r.u32())
+    case WNAMES: { const n = r.u16(); const out = new Array(n); for (let i = 0; i < n; i++) out[i] = r.str(); return out }
+    case QIDS: { const n = r.u16(); const out = new Array(n); for (let i = 0; i < n; i++) out[i] = r.qid(); return out }
+  }
+}
+
+/** Encodes message type (number or name) with tag and fields into a frame. */
+export function encode(type, tag, fields = {}) {
+  if (typeof type === 'string') type = T[type]
+  const spec = MESSAGES[type]
+  if (!spec) throw new ProtoError(`unknown message type ${type}`)
+  let size = HEADER
+  for (const [name, kind] of spec[1]) size += sizeOf(kind, fields[name])
+  if (size > 0xffffffff) throw new ProtoError('message too large')
+  const out = new Uint8Array(size)
+  const w = new Writer(out)
+  w.u32(size)
+  w.u8_(type)
+  w.u16(tag)
+  for (const [name, kind] of spec[1]) writeField(w, kind, fields[name])
+  return out
+}
+
+/** The frame's header: {size, type, tag}. */
+export function header(buf) {
+  if (buf.length < HEADER) throw new ProtoError('message too short')
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+  return { size: dv.getUint32(0, true), type: buf[4], tag: dv.getUint16(5, true) }
+}
+
+/** Decodes a frame into {type, op (the message's name), tag, ...fields}. Byte fields are views into buf. */
+export function decode(buf) {
+  const { size, type, tag } = header(buf)
+  if (size < HEADER || size > buf.length) throw new ProtoError('bad frame size')
+  const spec = MESSAGES[type]
+  if (!spec) {
+    const e = new ProtoError(`unknown message type ${type}`)
+    e.tag = tag
+    e.type = type
+    throw e
+  }
+  const r = new Reader(buf, HEADER, size)
+  const m = { type, op: spec[0], tag }
+  for (const [name, kind] of spec[1]) m[name] = readField(r, kind)
+  if (r.p !== size) throw new ProtoError(`${spec[0]}: ${size - r.p} trailing bytes`)
+  return m
+}
+
+/** One Rreaddir entry's encoded size. */
+export function direntSize(name) {
+  return 13 + 8 + 1 + 2 + name.length
+}
+
+/** Encodes dirents [{qid, offset, type, name}] (Rreaddir's data). */
+export function encodeDirents(list) {
+  let n = 0
+  for (const d of list) n += direntSize(d.name)
+  const out = new Uint8Array(n)
+  const w = new Writer(out)
+  for (const d of list) {
+    w.qid(d.qid)
+    w.u64(d.offset)
+    w.u8_(d.type)
+    w.str(d.name)
+  }
+  return out
+}
+
+/** Decodes Rreaddir's data into [{qid, offset, type, name}]. */
+export function decodeDirents(data) {
+  const r = new Reader(data)
+  const out = []
+  while (r.p < r.end) {
+    const qid = r.qid()
+    const offset = r.u64()
+    const type = r.u8_()
+    const name = r.str()
+    out.push({ qid, offset, type, name })
+  }
+  return out
+}