@threadedstack/wmd-web 0.0.0-stage → 0.1.13

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

@@ -0,0 +1,521 @@
+// A 9P2000.L file server over an Overlay (../overlay.js), transport-agnostic:
+// handle() takes one request frame and returns its reply frame, synchronously,
+// so it can sit behind any channel (a shared-memory ring, a MessagePort, a
+// test). The behaviour follows wmd's Go server (internal/engine/ninep over
+// internal/memfs, on github.com/hugelgupf/p9); the differences are listed in
+// web/docs/9p.md.
+
+import {
+  E2BIG, EBADF, EBUSY, EFBIG, EINVAL, EIO, EISDIR, ELOOP, ENOENT, ENOSYS, ENOTDIR,
+  FsError,
+} from '../errno.js'
+import {
+  S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, makedev,
+} from '../pack.js'
+import { NAME_MAX } from '../overlay.js'
+import { HEADER, NOFID, NOTAG, ProtoError, T, decode, direntSize, encode, encodeDirents, header } from './codec.js'
+
+export const VERSION = '9P2000.L'
+/** The largest msize the server agrees to (wmd's channel pump stops at 1 MiB replies). */
+export const MAX_MSIZE = 1 << 20
+export const MAXWELEM = 16
+
+// Tlopen/Tlcreate flags (Linux's open flags, P9_DOTL_*).
+export const O_ACCMODE = 3
+export const O_RDONLY = 0
+export const O_WRONLY = 1
+export const O_RDWR = 2
+export const O_TRUNC = 0o1000
+export const O_APPEND = 0o2000 // P9_DOTL_APPEND
+export const O_DIRECTORY = 0o200000
+
+// Tsetattr valid bits.
+export const SETATTR_MODE = 0x1
+export const SETATTR_UID = 0x2
+export const SETATTR_GID = 0x4
+export const SETATTR_SIZE = 0x8
+export const SETATTR_ATIME = 0x10
+export const SETATTR_MTIME = 0x20
+export const SETATTR_CTIME = 0x40
+export const SETATTR_ATIME_SET = 0x80
+export const SETATTR_MTIME_SET = 0x100
+
+/** Rgetattr's valid mask: P9_GETATTR_BASIC (mode..blocks). */
+export const GETATTR_BASIC = 0x7ff
+export const AT_REMOVEDIR = 0x200
+export const XATTR_SIZE_MAX = 65536
+const XATTR_REPLACE = 2
+const LOCK_SUCCESS = 0
+const LOCK_TYPE_UNLCK = 2
+
+const NS = 1000000000n
+
+/** The d_type of a mode (DT_*), as getdents(2) reports it. */
+export function dtype(mode) {
+  switch (mode & S_IFMT) {
+    case S_IFDIR: return 4
+    case S_IFREG: return 8
+    case S_IFLNK: return 10
+    case S_IFCHR: return 2
+    case S_IFBLK: return 6
+    case S_IFIFO: return 1
+    case S_IFSOCK: return 12
+  }
+  return 0
+}
+
+function qidOf(n) {
+  return { type: n.qtype, version: 0, path: n.ino }
+}
+
+function checkSafeName(name) {
+  if (name === '' || name === '.' || name === '..' || name.includes('/')) throw new FsError(EINVAL)
+}
+
+function splitNs(ns) {
+  // Floor division, so nsec is in [0, 1e9) as Linux's timespec needs (Go's
+  // splitNanos truncates: -1.5 s would give nsec -5e8). A negative sec goes in
+  // the u64 field as two's complement.
+  let s = ns / NS
+  let r = ns % NS
+  if (r < 0n) {
+    s -= 1n
+    r += NS
+  }
+  return [s, r]
+}
+
+function num(v) {
+  // A u64 field as a Number, Infinity when it is too large to be one.
+  return typeof v === 'bigint' ? Infinity : v
+}
+
+export class Fid {
+  constructor(node, parent, name, uid) {
+    this.node = node
+    this.parent = parent // the directory it was walked from (for Tremove/Trename)
+    this.name = name
+    this.uid = uid
+    this.opened = false
+    this.omode = 0
+    this.append = false // opened with O_APPEND: every Twrite goes to the end of the file
+    this.xattr = null // {op: 'walk', buf} | {op: 'create', name, size, flags, buf, len}
+    this.snap = null // readdir listing ({names, nodes}), taken at offset 0
+  }
+}
+
+export class NinePServer {
+  /**
+   * @param {import('../overlay.js').Overlay} fs
+   * @param {{maxMsize?: number}} [o]
+   */
+  constructor(fs, { maxMsize = MAX_MSIZE } = {}) {
+    this.fs = fs
+    this.maxMsize = maxMsize
+    this.msize = maxMsize
+    this.fids = new Map()
+    this.counts = {} // message name -> count
+    this.internalErrors = [] // unexpected exceptions (bugs), newest last, capped
+  }
+
+  /** Handles one request frame; returns the reply frame. Never throws. */
+  handle(req) {
+    let tag = NOTAG
+    let type = 0
+    try {
+      const h = header(req)
+      tag = h.tag
+      type = h.type
+      const m = decode(req)
+      this.counts[m.op] = (this.counts[m.op] || 0) + 1
+      const fn = this[m.op]
+      if (typeof fn !== 'function' || m.op[0] !== 'T') return this.#err(tag, ENOSYS)
+      const [rname, fields] = fn.call(this, m)
+      return encode(rname, tag, fields)
+    } catch (e) {
+      if (e instanceof FsError) return this.#err(tag, e.errno)
+      if (e instanceof ProtoError) {
+        if (e.type !== undefined) {
+          this.counts[`type${e.type}`] = (this.counts[`type${e.type}`] || 0) + 1
+          return this.#err(tag, ENOSYS)
+        }
+        return this.#err(tag, EINVAL)
+      }
+      this.internalErrors.push({ type, error: String(e && e.stack || e) })
+      if (this.internalErrors.length > 32) this.internalErrors.shift()
+      return this.#err(tag, EIO)
+    }
+  }
+
+  #err(tag, errno) {
+    return encode(T.Rlerror, tag, { ecode: errno })
+  }
+
+  #fid(n) {
+    const f = this.fids.get(n)
+    if (!f) throw new FsError(EBADF)
+    return f
+  }
+
+  // Makes fid id be f. Fid ids are the client's; 9P says a new one must not
+  // be in use (walk(5)), so callers check that first. The overlay counts the
+  // fids on each inode: an unlinked file's contents go when the last goes.
+  #setFid(id, f) {
+    const old = this.fids.get(id)
+    this.fids.set(id, f)
+    this.fs.ref(f.node)
+    if (old) this.fs.unref(old.node)
+  }
+
+  #dropFid(id) {
+    const f = this.fids.get(id)
+    if (!f) return
+    this.fids.delete(id)
+    this.fs.unref(f.node)
+  }
+
+  #dropAll() {
+    for (const id of [...this.fids.keys()]) this.#dropFid(id)
+  }
+
+  // A new fid id must not be in use: EBADF, as Linux's v9fs never reuses a
+  // live fid (wmd's Go server replaces it).
+  #checkNewFid(id) {
+    if (this.fids.has(id)) throw new FsError(EBADF)
+  }
+
+  #dirFid(n) {
+    const f = this.#fid(n)
+    if (!f.node.isDir()) throw new FsError(ENOTDIR)
+    return f
+  }
+
+  // ---- session -----------------------------------------------------------
+
+  Tversion(m) {
+    this.#dropAll()
+    if (!m.version.startsWith(VERSION) || m.msize < HEADER + 4) {
+      return ['Rversion', { msize: Math.min(m.msize, this.maxMsize), version: 'unknown' }]
+    }
+    this.msize = Math.min(m.msize, this.maxMsize)
+    return ['Rversion', { msize: this.msize, version: VERSION }]
+  }
+
+  Tauth() {
+    throw new FsError(ENOSYS)
+  }
+
+  Tattach(m) {
+    if (m.afid !== NOFID) throw new FsError(EINVAL)
+    this.#checkNewFid(m.fid)
+    const uid = m.n_uname === NOFID ? 0 : m.n_uname
+    let node = this.fs.root
+    let parent = null
+    let name = ''
+    for (const part of m.aname.split('/').filter((s) => s !== '')) {
+      checkSafeName(part)
+      if (!node.isDir()) throw new FsError(node.type === S_IFLNK ? ELOOP : ENOTDIR)
+      parent = node
+      name = part
+      node = this.fs.lookup(node, part)
+    }
+    this.#setFid(m.fid, new Fid(node, parent, name, uid))
+    return ['Rattach', { qid: qidOf(node) }]
+  }
+
+  Tflush() {
+    // Requests are answered one at a time, in order: none is ever pending.
+    return ['Rflush', {}]
+  }
+
+  Tclunk(m) {
+    const f = this.#fid(m.fid)
+    this.#dropFid(m.fid)
+    const x = f.xattr
+    if (x && x.op === 'create') {
+      if (x.len !== x.size) throw new FsError(EINVAL)
+      if (x.flags === XATTR_REPLACE && x.size === 0) this.fs.removexattr(f.node, x.name)
+      else this.fs.setxattr(f.node, x.name, x.buf.subarray(0, x.len), x.flags)
+    }
+    return ['Rclunk', {}]
+  }
+
+  // ---- walking -----------------------------------------------------------
+
+  Twalk(m) {
+    const f = this.#fid(m.fid)
+    if (f.opened && m.newfid === m.fid) throw new FsError(EBUSY)
+    if (m.newfid !== m.fid) this.#checkNewFid(m.newfid)
+    if (m.wnames.length > MAXWELEM) throw new FsError(EINVAL)
+    let node = f.node
+    let parent = f.parent
+    let name = f.name
+    const qids = []
+    for (const w of m.wnames) {
+      checkSafeName(w)
+      if (!node.isDir()) throw new FsError(node.type === S_IFLNK ? ELOOP : ENOTDIR)
+      if (node.removed) throw new FsError(ENOENT)
+      parent = node
+      name = w
+      node = this.fs.lookup(node, w)
+      qids.push(qidOf(node))
+    }
+    this.#setFid(m.newfid, new Fid(node, parent, name, f.uid))
+    return ['Rwalk', { qids }]
+  }
+
+  // ---- attributes --------------------------------------------------------
+
+  Tgetattr(m) {
+    const n = this.#fid(m.fid).node
+    const a = this.fs.getattr(n)
+    const [as, an] = splitNs(a.atime)
+    const [ms, mn] = splitNs(a.mtime)
+    const [cs, cn] = splitNs(a.ctime)
+    return ['Rgetattr', {
+      valid: GETATTR_BASIC, qid: qidOf(n), mode: a.mode, uid: a.uid, gid: a.gid,
+      nlink: a.nlink, rdev: a.rdev, size: a.size, blksize: a.blksize, blocks: a.blocks,
+      atime_sec: as, atime_nsec: an, mtime_sec: ms, mtime_nsec: mn, ctime_sec: cs, ctime_nsec: cn,
+      btime_sec: 0, btime_nsec: 0, gen: 0, data_version: 0,
+    }]
+  }
+
+  Tsetattr(m) {
+    const n = this.#fid(m.fid).node
+    const v = m.valid
+    const s = {}
+    if (v & SETATTR_MODE) s.mode = m.mode & 0o7777
+    if (v & SETATTR_UID && m.uid !== NOFID) s.uid = m.uid
+    if (v & SETATTR_GID && m.gid !== NOFID) s.gid = m.gid
+    if (v & SETATTR_SIZE) {
+      const size = num(m.size)
+      if (!Number.isFinite(size)) throw new FsError(EFBIG)
+      s.size = size
+    }
+    if (v & SETATTR_ATIME) {
+      s.atime = v & SETATTR_ATIME_SET ? BigInt(m.atime_sec) * NS + BigInt(m.atime_nsec) : this.fs.now()
+    }
+    if (v & SETATTR_MTIME) {
+      s.mtime = v & SETATTR_MTIME_SET ? BigInt(m.mtime_sec) * NS + BigInt(m.mtime_nsec) : this.fs.now()
+    }
+    this.fs.setattr(n, s)
+    return ['Rsetattr', {}]
+  }
+
+  Tstatfs(m) {
+    this.#fid(m.fid)
+    return ['Rstatfs', this.fs.statfs()]
+  }
+
+  Treadlink(m) {
+    return ['Rreadlink', { target: this.fs.readlink(this.#fid(m.fid).node) }]
+  }
+
+  // ---- opening, reading, writing -----------------------------------------
+
+  Tlopen(m) {
+    const f = this.#fid(m.fid)
+    if (f.opened || f.xattr) throw new FsError(EINVAL)
+    const acc = m.flags & O_ACCMODE
+    const n = f.node
+    if (m.flags & O_DIRECTORY && !n.isDir()) throw new FsError(ENOTDIR)
+    if (n.isDir() && acc !== O_RDONLY) throw new FsError(EISDIR)
+    this.fs.open(n, { write: acc !== O_RDONLY, trunc: (m.flags & O_TRUNC) !== 0 })
+    f.opened = true
+    f.omode = acc
+    f.append = (m.flags & O_APPEND) !== 0
+    f.snap = null
+    return ['Rlopen', { qid: qidOf(n), iounit: 0 }]
+  }
+
+  Tlcreate(m) {
+    const f = this.#dirFid(m.fid)
+    if (f.opened) throw new FsError(EINVAL)
+    checkSafeName(m.name)
+    const n = this.fs.create(f.node, m.name, m.mode & 0o7777, f.uid, m.gid)
+    const nf = new Fid(n, f.node, m.name, f.uid)
+    nf.opened = true
+    nf.omode = m.flags & O_ACCMODE
+    nf.append = (m.flags & O_APPEND) !== 0
+    this.#setFid(m.fid, nf)
+    return ['Rlcreate', { qid: qidOf(n), iounit: 0 }]
+  }
+
+  Tread(m) {
+    const f = this.#fid(m.fid)
+    const max = this.msize - (HEADER + 4)
+    const count = Math.min(m.count, max)
+    const off = num(m.offset)
+    if (f.xattr) {
+      if (f.xattr.op !== 'walk') throw new FsError(EINVAL)
+      const b = f.xattr.buf
+      if (!Number.isFinite(off) || off >= b.length) return ['Rread', { data: new Uint8Array(0) }]
+      return ['Rread', { data: b.subarray(off, off + count) }]
+    }
+    if (!f.opened || f.omode === O_WRONLY) throw new FsError(EBADF)
+    if (!Number.isFinite(off)) return ['Rread', { data: new Uint8Array(0) }]
+    return ['Rread', { data: this.fs.read(f.node, off, count) }]
+  }
+
+  Twrite(m) {
+    const f = this.#fid(m.fid)
+    const off = num(m.offset)
+    if (f.xattr) {
+      const x = f.xattr
+      if (x.op !== 'create' || off !== x.len || x.len + m.data.length > x.size) throw new FsError(EINVAL)
+      x.buf.set(m.data, x.len)
+      x.len += m.data.length
+      return ['Rwrite', { count: m.data.length }]
+    }
+    if (!f.opened || f.omode === O_RDONLY) throw new FsError(EBADF)
+    if (!Number.isFinite(off)) throw new FsError(EFBIG)
+    // O_APPEND: at the end of the file, whatever offset the client computed (as QEMU's
+    // server, whose pwrite on an O_APPEND file appends, and Linux's own pwrite(2)). Without
+    // the page cache (cache=mmap/none) v9fs takes the offset from its i_size with no lock
+    // (v9fs_file_write_iter), so two processes appending to one file would overwrite each
+    // other's records; here each Twrite lands whole after the last.
+    const at = f.append ? this.fs.size(f.node) : off
+    return ['Rwrite', { count: this.fs.write(f.node, at, m.data) }]
+  }
+
+  Tfsync(m) {
+    this.#fid(m.fid)
+    return ['Rfsync', {}]
+  }
+
+  Treaddir(m) {
+    const f = this.#fid(m.fid)
+    if (!f.node.isDir()) throw new FsError(ENOTDIR)
+    if (!f.opened) throw new FsError(EBADF)
+    const off = num(m.offset)
+    if (off === 0 || !f.snap) f.snap = this.fs.listing(f.node)
+    const { names, nodes } = f.snap
+    const count = Math.min(m.count, this.msize - (HEADER + 4))
+    const out = []
+    let used = 0
+    for (let i = Number.isFinite(off) ? off : names.length; i < names.length; i++) {
+      const name = names[i]
+      const n = nodes[i]
+      const sz = direntSize(name)
+      if (used + sz > count) break
+      used += sz
+      out.push({ qid: qidOf(n), offset: i + 1, type: dtype(n.mode), name })
+    }
+    return ['Rreaddir', { data: encodeDirents(out) }]
+  }
+
+  // ---- making and removing -----------------------------------------------
+
+  Tmkdir(m) {
+    const d = this.#dirFid(m.dfid)
+    checkSafeName(m.name)
+    const n = this.fs.mkdir(d.node, m.name, m.mode & 0o7777, d.uid, m.gid)
+    return ['Rmkdir', { qid: qidOf(n) }]
+  }
+
+  Tsymlink(m) {
+    const d = this.#dirFid(m.fid)
+    checkSafeName(m.name)
+    const n = this.fs.symlink(d.node, m.name, m.symtgt, d.uid, m.gid)
+    return ['Rsymlink', { qid: qidOf(n) }]
+  }
+
+  Tmknod(m) {
+    const d = this.#dirFid(m.dfid)
+    checkSafeName(m.name)
+    const n = this.fs.mknod(d.node, m.name, m.mode, makedev(m.major, m.minor), d.uid, m.gid)
+    return ['Rmknod', { qid: qidOf(n) }]
+  }
+
+  Tlink(m) {
+    const d = this.#dirFid(m.dfid)
+    const t = this.#fid(m.fid)
+    checkSafeName(m.name)
+    this.fs.link(d.node, m.name, t.node)
+    return ['Rlink', {}]
+  }
+
+  Tunlinkat(m) {
+    const d = this.#dirFid(m.dirfid)
+    checkSafeName(m.name)
+    this.fs.unlink(d.node, m.name, (m.flags & AT_REMOVEDIR) !== 0)
+    return ['Runlinkat', {}]
+  }
+
+  Trenameat(m) {
+    const od = this.#dirFid(m.olddirfid)
+    const nd = this.#dirFid(m.newdirfid)
+    checkSafeName(m.oldname)
+    checkSafeName(m.newname)
+    this.fs.rename(od.node, m.oldname, nd.node, m.newname)
+    return ['Rrenameat', {}]
+  }
+
+  Trename(m) {
+    const f = this.#fid(m.fid)
+    const d = this.#dirFid(m.dfid)
+    checkSafeName(m.name)
+    if (!f.parent) throw new FsError(EINVAL)
+    if (f.parent.kids && f.parent.kids.get(f.name) !== f.node) throw new FsError(ENOENT)
+    this.fs.rename(f.parent, f.name, d.node, m.name)
+    f.parent = d.node
+    f.name = m.name
+    return ['Rrename', {}]
+  }
+
+  Tremove(m) {
+    // Removes the file and clunks the fid, even when the removal fails.
+    const f = this.#fid(m.fid)
+    try {
+      if (!f.parent) throw new FsError(EINVAL)
+      if (f.parent.kids && f.parent.kids.get(f.name) !== f.node) throw new FsError(ENOENT)
+      this.fs.unlink(f.parent, f.name, f.node.isDir())
+    } finally {
+      this.#dropFid(m.fid)
+    }
+    return ['Rremove', {}]
+  }
+
+  // ---- extended attributes -----------------------------------------------
+
+  Txattrwalk(m) {
+    const f = this.#fid(m.fid)
+    if (m.newfid !== m.fid) this.#checkNewFid(m.newfid)
+    let buf
+    if (m.name === '') {
+      const names = this.fs.listxattr(f.node)
+      let s = ''
+      for (const k of names) s += k + '\0'
+      buf = new Uint8Array(s.length)
+      for (let i = 0; i < s.length; i++) buf[i] = s.charCodeAt(i)
+    } else {
+      buf = this.fs.getxattr(f.node, m.name)
+    }
+    const nf = new Fid(f.node, f.parent, f.name, f.uid)
+    nf.xattr = { op: 'walk', buf }
+    this.#setFid(m.newfid, nf)
+    return ['Rxattrwalk', { size: buf.length }]
+  }
+
+  Txattrcreate(m) {
+    const f = this.#fid(m.fid)
+    if (f.opened) throw new FsError(EINVAL)
+    const size = num(m.size)
+    if (size > XATTR_SIZE_MAX) throw new FsError(E2BIG)
+    if (m.name.length === 0 || m.name.length > NAME_MAX) throw new FsError(EINVAL)
+    f.xattr = { op: 'create', name: m.name, size, flags: m.flags, buf: new Uint8Array(size), len: 0 }
+    return ['Rxattrcreate', {}]
+  }
+
+  // ---- locks: one guest per container, nothing to contend with -----------
+
+  Tlock(m) {
+    this.#fid(m.fid)
+    return ['Rlock', { status: LOCK_SUCCESS }]
+  }
+
+  Tgetlock(m) {
+    this.#fid(m.fid)
+    return ['Rgetlock', { ltype: LOCK_TYPE_UNLCK, start: m.start, length: m.length, proc_id: m.proc_id, client_id: m.client_id }]
+  }
+}

package/src/fs/errno.js

@@ -0,0 +1,43 @@
+// Linux errno values (asm-generic), as 9P2000.L's Rlerror carries them.
+
+export const EPERM = 1
+export const ENOENT = 2
+export const EIO = 5
+export const ENXIO = 6
+export const E2BIG = 7
+export const EBADF = 9
+export const EAGAIN = 11
+export const ENOMEM = 12
+export const EACCES = 13
+export const EBUSY = 16
+export const EEXIST = 17
+export const EXDEV = 18
+export const ENOTDIR = 20
+export const EISDIR = 21
+export const EINVAL = 22
+export const EFBIG = 27
+export const ENOSPC = 28
+export const EROFS = 30
+export const EMLINK = 31
+export const ERANGE = 34
+export const ENAMETOOLONG = 36
+export const ENOSYS = 38
+export const ENOTEMPTY = 39
+export const ELOOP = 40
+export const ENODATA = 61
+export const EPROTO = 71
+export const EMSGSIZE = 90
+export const EOPNOTSUPP = 95
+
+/** A file system error with a Linux errno. */
+export class FsError extends Error {
+  constructor(errno, msg) {
+    super(msg || `errno ${errno}`)
+    this.errno = errno
+  }
+}
+
+/** Throws FsError(errno). */
+export function fail(errno, msg) {
+  throw new FsError(errno, msg)
+}