@ai-ecoverse/slicc-kernel 1.8.12 → 1.9.0

package/dist/process-worker.js

@@ -268,28 +268,28 @@ function createNodeOps(h) {
         blocks: Math.ceil(size / 4096) * 8
       };
     },
-    setattr(node, attr) {
+    setattr(node, attr2) {
       if (node.live.orphan) {
-        if (attr.mode !== void 0 && attr.mode !== null) {
-          node.mode = node.mode & ~PERM_MASK | attr.mode & PERM_MASK;
+        if (attr2.mode !== void 0 && attr2.mode !== null) {
+          node.mode = node.mode & ~PERM_MASK | attr2.mode & PERM_MASK;
         }
-        if (attr.size !== void 0 && attr.size !== null) truncate(node, attr.size);
+        if (attr2.size !== void 0 && attr2.size !== null) truncate(node, attr2.size);
         return;
       }
       const path = liveNodePath(node);
-      if (attr.mode !== void 0 && attr.mode !== null) {
-        const perm = attr.mode & PERM_MASK;
+      if (attr2.mode !== void 0 && attr2.mode !== null) {
+        const perm = attr2.mode & PERM_MASK;
         if (perm !== (node.mode & PERM_MASK)) {
           metadataCall(() => bridgeOf(node).chmod(path, perm));
           node.mode = node.mode & ~PERM_MASK | perm;
         }
       }
-      if (attr.size !== void 0 && attr.size !== null && Fs.isFile(node.mode)) {
-        truncate(node, attr.size);
+      if (attr2.size !== void 0 && attr2.size !== null && Fs.isFile(node.mode)) {
+        truncate(node, attr2.size);
       }
-      const mtime = toMs(attr.mtime) ?? attr.timestamp;
+      const mtime = toMs(attr2.mtime) ?? attr2.timestamp;
       if (mtime !== void 0) {
-        const atime = toMs(attr.atime) ?? mtime;
+        const atime = toMs(attr2.atime) ?? mtime;
         flushNode(node);
         metadataCall(() => bridgeOf(node).utimes(path, atime, mtime));
       }
@@ -2405,10 +2405,297 @@ var init_process_sockets = __esm({
   }
 });
 
+// src/process/procfs.ts
+function commOf(info) {
+  const name = info.argv[0] ?? "";
+  return name.slice(name.lastIndexOf("/") + 1).slice(0, 15);
+}
+function ttyNumber(tty) {
+  const pts = tty && /^\/dev\/pts\/(\d+)$/.exec(tty);
+  if (pts) return 136 << 8 | Number(pts[1]);
+  const vt = tty && /^\/dev\/tty(\d+)$/.exec(tty);
+  return vt ? 4 << 8 | Number(vt[1]) : 0;
+}
+function ticks(ms) {
+  return Math.max(0, Math.floor(ms * HZ / 1e3));
+}
+function pidStat(info, boot) {
+  const fields = [
+    info.pid,
+    `(${commOf(info)})`,
+    info.state,
+    info.ppid,
+    info.pgid,
+    info.sid,
+    ttyNumber(info.tty),
+    info.tty ? info.pgid : -1,
+    4194304,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    20,
+    0,
+    1,
+    0,
+    ticks(info.started - boot),
+    0,
+    0,
+    "18446744073709551615",
+    ...Array(12).fill(0),
+    17,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    ...Array(7).fill(0),
+    0
+  ];
+  return `${fields.join(" ")}
+`;
+}
+function pidStatus(info) {
+  const state = info.state === "Z" ? "Z (zombie)" : "S (sleeping)";
+  const ids = `${UID}	${UID}	${UID}	${UID}`;
+  return [
+    `Name:	${commOf(info)}`,
+    "Umask:	0022",
+    `State:	${state}`,
+    `Tgid:	${info.pid}`,
+    "Ngid:	0",
+    `Pid:	${info.pid}`,
+    `PPid:	${info.ppid}`,
+    "TracerPid:	0",
+    `Uid:	${ids}`,
+    `Gid:	${ids}`,
+    "FDSize:	64",
+    "Groups:	",
+    `NSpid:	${info.pid}`,
+    `NSpgid:	${info.pgid}`,
+    `NSsid:	${info.sid}`,
+    "Threads:	1",
+    "SigQ:	0/0",
+    "SigPnd:	0000000000000000",
+    "ShdPnd:	0000000000000000",
+    "SigBlk:	0000000000000000",
+    "SigIgn:	0000000000000000",
+    "SigCgt:	0000000000000000",
+    ""
+  ].join("\n");
+}
+function pidFile(name, info, boot) {
+  if (name === "cmdline") return info.state === "Z" ? "" : `${info.argv.join("\0")}\0`;
+  if (name === "comm") return `${commOf(info)}
+`;
+  if (name === "stat") return pidStat(info, boot);
+  if (name === "statm") return "0 0 0 0 0 0 0\n";
+  return pidStatus(info);
+}
+function memoryInfo(source) {
+  const total = source.deviceMemory ? source.deviceMemory * KIB * KIB * KIB : FALLBACK_MEMORY;
+  const free = Math.max(0, total - (source.usedHeap ?? 0));
+  const kb = (bytes) => `${Math.floor(bytes / KIB)} kB`;
+  return [
+    ["MemTotal", kb(total)],
+    ["MemFree", kb(free)],
+    ["MemAvailable", kb(free)],
+    ["Buffers", kb(0)],
+    ["Cached", kb(0)],
+    ["SwapCached", kb(0)],
+    ["Shmem", kb(0)],
+    ["SReclaimable", kb(0)],
+    ["SwapTotal", kb(0)],
+    ["SwapFree", kb(0)]
+  ].map(([key, value2]) => `${`${key}:`.padEnd(16)}${value2.padStart(12)}`).concat("").join("\n");
+}
+function systemFile(name, listing, now, memory) {
+  const up = Math.max(0, now - listing.boot) / 1e3;
+  if (name === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
+`;
+  if (name === "meminfo") return memoryInfo(memory);
+  const live = listing.processes.filter((p) => p.state !== "Z");
+  if (name === "loadavg") {
+    const last = Math.max(0, ...listing.processes.map((p) => p.pid));
+    return `0.00 0.00 0.00 1/${live.length} ${last}
+`;
+  }
+  const idle = ticks(now - listing.boot);
+  return [
+    `cpu  0 0 0 ${idle} 0 0 0 0 0 0`,
+    `cpu0 0 0 0 ${idle} 0 0 0 0 0 0`,
+    "intr 0",
+    "ctxt 0",
+    `btime ${Math.floor(listing.boot / 1e3)}`,
+    `processes ${listing.processes.length}`,
+    "procs_running 1",
+    "procs_blocked 0",
+    ""
+  ].join("\n");
+}
+function memorySource(scope2 = globalThis) {
+  const nav = scope2.navigator;
+  const perf = scope2.performance;
+  const deviceMemory = nav?.deviceMemory;
+  const used = perf?.memory?.usedJSHeapSize;
+  return {
+    ...typeof deviceMemory === "number" && deviceMemory > 0 ? { deviceMemory } : {},
+    ...typeof used === "number" ? { usedHeap: used } : {}
+  };
+}
+function attr(node) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    dev: 3,
+    ino: node.id,
+    mode: node.mode,
+    nlink: 1,
+    uid: UID,
+    gid: UID,
+    rdev: 0,
+    size: 0,
+    atime: now,
+    mtime: now,
+    ctime: now,
+    blksize: 4096,
+    blocks: 0
+  };
+}
+function useProcfs(Fs, sys, pid, memory = memorySource()) {
+  const { lookupPath, createNode, hashRemoveNode } = Fs;
+  const procList = sys.procList?.bind(sys);
+  if (!lookupPath || !createNode || !hashRemoveNode || !procList) return;
+  let proc;
+  let self;
+  try {
+    proc = lookupPath.call(Fs, "/proc", { follow: true }).node;
+    self = lookupPath.call(Fs, "/proc/self", { follow: true }).node;
+  } catch {
+    return;
+  }
+  const error = (errno2 = ENOENT) => new Fs.ErrnoError(errno2);
+  const fresh = (parent, name, mode) => {
+    const node = createNode.call(Fs, parent, name, mode, 0);
+    hashRemoveNode.call(Fs, node);
+    node.node_ops = { getattr: attr, setattr: () => {
+    } };
+    node.stream_ops = {
+      llseek: (stream, offset, whence) => {
+        const at = (whence === 1 ? stream.position : 0) + offset;
+        if (at < 0) throw error(EINVAL);
+        return at;
+      }
+    };
+    return node;
+  };
+  const file = (parent, name, content) => {
+    const node = fresh(parent, name, FILE_MODE);
+    node.stream_ops = {
+      open: (stream) => {
+        stream.sliccProc = new TextEncoder().encode(content());
+      },
+      read: (stream, buffer, offset, length, at) => {
+        const data = stream.sliccProc ?? new Uint8Array(0);
+        const chunk = data.subarray(at, at + length);
+        buffer.set(chunk, offset);
+        return chunk.length;
+      },
+      llseek: (stream, offset, whence) => {
+        const end = stream.sliccProc?.length ?? 0;
+        const at = (whence === 1 ? stream.position : whence === 2 ? end : 0) + offset;
+        if (at < 0) throw error(EINVAL);
+        return at;
+      }
+    };
+    return node;
+  };
+  const find = (processes2, target, own) => processes2.find((p) => own ? p.tid === target : p.pid === target || p.tid === target);
+  const infoOf = (target) => find(procList().processes, target, false);
+  const pidContent = (target, name, own = false) => () => {
+    const listing = procList();
+    const info = find(listing.processes, target, own);
+    if (!info) throw error(ESRCH);
+    return pidFile(name, info, listing.boot);
+  };
+  const pidNames = (names) => [.../* @__PURE__ */ new Set([...names, ...PID_FILES])];
+  const pidDir = (name, target) => {
+    const dir = fresh(proc, name, DIR_MODE2);
+    dir.node_ops.lookup = (parent, child) => {
+      if (!PID_FILES.includes(child)) throw error();
+      return file(parent, child, pidContent(target, child));
+    };
+    dir.node_ops.readdir = () => [".", "..", ...PID_FILES];
+    return dir;
+  };
+  const procOps = proc.node_ops;
+  const lookup = procOps.lookup?.bind(procOps);
+  const readdir = procOps.readdir?.bind(procOps);
+  proc.node_ops = {
+    ...procOps,
+    lookup: (parent, name) => {
+      if (/^[1-9]\d*$/.test(name)) {
+        if (!infoOf(Number(name))) throw error();
+        return pidDir(name, Number(name));
+      }
+      if (SYSTEM_FILES.includes(name)) {
+        return file(
+          parent,
+          name,
+          () => systemFile(name, procList(), Date.now(), memory)
+        );
+      }
+      if (!lookup) throw error();
+      return lookup(parent, name);
+    },
+    readdir: (node) => {
+      const names = new Set(readdir ? readdir(node) : [".", ".."]);
+      for (const name of SYSTEM_FILES) names.add(name);
+      for (const p of procList().processes) names.add(String(p.pid));
+      return [...names];
+    }
+  };
+  const selfOps = self.node_ops;
+  const selfLookup = selfOps.lookup?.bind(selfOps);
+  const selfReaddir = selfOps.readdir?.bind(selfOps);
+  self.node_ops = {
+    ...selfOps,
+    lookup: (parent, name) => {
+      if (PID_FILES.includes(name)) {
+        return file(parent, name, pidContent(pid, name, true));
+      }
+      if (!selfLookup) throw error();
+      return selfLookup(parent, name);
+    },
+    readdir: (node) => pidNames(selfReaddir ? selfReaddir(node) : [".", ".."])
+  };
+}
+var HZ, DIR_MODE2, FILE_MODE, ENOENT, ESRCH, EINVAL, UID, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES;
+var init_procfs = __esm({
+  "src/process/procfs.ts"() {
+    "use strict";
+    HZ = 100;
+    DIR_MODE2 = 16749;
+    FILE_MODE = 33060;
+    ENOENT = 44;
+    ESRCH = 71;
+    EINVAL = 28;
+    UID = 1e3;
+    KIB = 1024;
+    FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
+    PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
+    SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+  }
+});
+
 // src/process/realm-user.ts
 function ownByRealmUser(Fs) {
   const { stat, fstat } = Fs;
-  const owned = (attr) => ({ ...attr, uid: REALM_UID, gid: REALM_GID });
+  const owned = (attr2) => ({ ...attr2, uid: REALM_UID, gid: REALM_GID });
   if (typeof stat === "function") {
     Fs.stat = (path, dontFollow) => owned(stat.call(Fs, path, dontFollow));
   }
@@ -2519,6 +2806,9 @@ function kernelSys(transport) {
     ptyNumbers() {
       return json(call2({ op: "pty-list" }, "pty-list"));
     },
+    procList() {
+      return json(call2({ op: "proc-list" }, "proc-list"));
+    },
     ptyNumber(fd) {
       return json(call2({ op: "pty-number", fd }, `pty-number ${fd}`));
     },
@@ -2680,6 +2970,7 @@ async function runWasmProcess(init, port, deps = {}) {
   streams.useControllingTerminal();
   useDevFd(running.FS);
   useMounts(running.FS);
+  useProcfs(running.FS, sys, init.pid);
   ownByRealmUser(running.FS);
   const livePath = (s) => liveNodePath(s.node);
   running.sliccKernel = createProcessKernel({
@@ -2746,6 +3037,7 @@ var init_process_runtime = __esm({
     init_process_http();
     init_process_signals();
     init_process_sockets();
+    init_procfs();
     init_realm_user();
     init_kernel_streams();
     O_RDONLY = 0;
@@ -4453,7 +4745,7 @@ function importsContext({
       const path = pathOf(fd);
       if (path === void 0) {
         const kind = e.type === "device" ? "device" : "stream";
-        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID, gid: UID, size: 0 };
+        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID2, gid: UID2, size: 0 };
       }
       host.fds.flushPath(path);
       const s = fs.stat(path);
@@ -4461,8 +4753,8 @@ function importsContext({
         kind: s.isDirectory ? "dir" : "file",
         path,
         mode: s.mode ?? (s.isDirectory ? 16877 : 33188),
-        uid: UID,
-        gid: UID,
+        uid: UID2,
+        gid: UID2,
         size: s.size,
         ...s.ino !== void 0 ? { ino: s.ino } : {},
         ...s.mtimeMs !== void 0 ? { mtimeMs: s.mtimeMs } : {}
@@ -4580,13 +4872,13 @@ function processes(host, call2) {
     }
   };
 }
-var UID, STDIO;
+var UID2, STDIO;
 var init_wasi_imports = __esm({
   "src/process/wasi/wasi-imports.ts"() {
     "use strict";
     init_wasi_abi();
     init_wasi_files();
-    UID = 1e3;
+    UID2 = 1e3;
     STDIO = ["stdin", "stdout", "stderr"];
   }
 });