@ai-ecoverse/slicc-kernel 1.10.0 → 1.12.0

package/dist/process-worker.js

@@ -730,6 +730,10 @@ var init_sync_fs_wire = __esm({
 });
 
 // src/realm/sync-sab-wire.ts
+function publishMemory(sab, bytes) {
+  if (bytes > 0)
+    Atomics.store(new Int32Array(sab, 0, SAB_HEADER_I32), SAB_I_MEMORY, Math.ceil(bytes / 65536));
+}
 function decodeSabResult(status2, payload) {
   switch (status2) {
     case SAB_STATUS_BYTES:
@@ -765,7 +769,7 @@ function sabViews(sab) {
     window: new Uint8Array(sab, SAB_HEADER_BYTES)
   };
 }
-var SAB_HEADER_I32, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
+var SAB_HEADER_I32, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
 var init_sync_sab_wire = __esm({
   "src/realm/sync-sab-wire.ts"() {
     "use strict";
@@ -781,6 +785,7 @@ var init_sync_sab_wire = __esm({
     SAB_I_PUB = 7;
     SAB_I_SIGNALS = 8;
     SAB_I_TIMERS = 9;
+    SAB_I_MEMORY = 10;
     SAB_STATE_IDLE = 0;
     SAB_STATE_PENDING = 1;
     SAB_STATE_READY = 2;
@@ -817,6 +822,7 @@ function createSyncSabTransport(sab, port, deps = {}) {
   }
   return {
     call(req, timeoutMs, label) {
+      if (deps.memory) publishMemory(sab, deps.memory());
       const id = ++seq;
       const deadline = now() + timeoutMs;
       let out = null;
@@ -1916,28 +1922,50 @@ function mountTable() {
     "\n"
   );
 }
-function useMounts(Fs) {
-  const { writeFile } = Fs;
+function accounts(env = {}) {
+  const user = env.USER ?? "web_user";
+  const name = NAME.test(user) && user !== "root" ? user : "user";
+  const home = env.HOME || "/home";
+  return {
+    passwd: `root:x:0:0:root:/root:/bin/sh
+${name}:x:1000:1000:${name}:${home}:/bin/bash
+`,
+    group: `root:x:0:
+${name}:x:1000:
+`
+  };
+}
+function useMounts(Fs, env = {}) {
+  const { writeFile, mkdirTree } = Fs;
   if (typeof Fs.open !== "function" || typeof writeFile !== "function") return;
+  const { passwd, group } = accounts(env);
+  const backing = { "/etc/mtab": "/proc/mounts" };
   try {
     writeFile.call(Fs, "/proc/mounts", mountTable());
   } catch {
     return;
   }
+  try {
+    mkdirTree.call(Fs, "/dev/.etc");
+    writeFile.call(Fs, "/dev/.etc/passwd", passwd);
+    writeFile.call(Fs, "/dev/.etc/group", group);
+    backing["/etc/passwd"] = "/dev/.etc/passwd";
+    backing["/etc/group"] = "/dev/.etc/group";
+  } catch {
+  }
   const open = Fs.open.bind(Fs);
   Fs.open = (path, flags, mode) => {
-    if (path !== "/etc/mtab" || (flags & (O_ACCMODE | O_CREAT2)) !== 0) {
-      return open(path, flags, mode);
-    }
+    const instead = backing[path];
+    if (!instead || (flags & (O_ACCMODE | O_CREAT2)) !== 0) return open(path, flags, mode);
     try {
       return open(path, flags, mode);
     } catch (e) {
       if (e?.errno !== wasiErrno("ENOENT")) throw e;
-      return open("/proc/mounts", flags, mode);
+      return open(instead, flags, mode);
     }
   };
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, DIR_MODE, LINK_MODE, O_ACCMODE, O_CREAT2;
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, DIR_MODE, LINK_MODE, O_ACCMODE, O_CREAT2, NAME;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -1965,6 +1993,7 @@ var init_process_fds = __esm({
     LINK_MODE = 41408;
     O_ACCMODE = 3;
     O_CREAT2 = 64;
+    NAME = /^[a-z_][a-z0-9_-]*$/i;
   }
 });
 
@@ -2416,6 +2445,9 @@ function ttyNumber(tty) {
   const vt = tty && /^\/dev\/tty(\d+)$/.exec(tty);
   return vt ? 4 << 8 | Number(vt[1]) : 0;
 }
+function pages(bytes) {
+  return Math.ceil(bytes / 4096);
+}
 function ticks(ms) {
   return Math.max(0, Math.floor(ms * HZ / 1e3));
 }
@@ -2443,8 +2475,8 @@ function pidStat(info, boot) {
     1,
     0,
     ticks(info.started - boot),
-    0,
-    0,
+    info.memory,
+    pages(info.memory),
     "18446744073709551615",
     ...Array(12).fill(0),
     17,
@@ -2475,6 +2507,8 @@ function pidStatus(info) {
     `Uid:	${ids}`,
     `Gid:	${ids}`,
     "FDSize:	64",
+    `VmSize:	${Math.ceil(info.memory / KIB)} kB`,
+    `VmRSS:	${Math.ceil(info.memory / KIB)} kB`,
     "Groups:	",
     `NSpid:	${info.pid}`,
     `NSpgid:	${info.pgid}`,
@@ -2494,12 +2528,16 @@ function pidFile(name, info, boot) {
   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";
+  if (name === "statm") {
+    const p = pages(info.memory);
+    return `${p} ${p} 0 0 0 ${p} 0
+`;
+  }
   return pidStatus(info);
 }
-function memoryInfo(source) {
+function memoryInfo(source, used = 0) {
   const total = source.deviceMemory ? source.deviceMemory * KIB * KIB * KIB : FALLBACK_MEMORY;
-  const free = Math.max(0, total - (source.usedHeap ?? 0));
+  const free = Math.max(0, total - used - (source.usedHeap ?? 0));
   const kb = (bytes) => `${Math.floor(bytes / KIB)} kB`;
   return [
     ["MemTotal", kb(total)],
@@ -2518,7 +2556,12 @@ 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);
+  if (name === "meminfo") {
+    return memoryInfo(
+      memory,
+      listing.processes.reduce((sum, p) => sum + p.memory, 0)
+    );
+  }
   const live = listing.processes.filter((p) => p.state !== "Z");
   if (name === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
@@ -2869,9 +2912,21 @@ function signalMasks(m) {
   if (!mask || caught === -1) return null;
   return { caught, ignored: mask(1), restart: mask(2) };
 }
+function reportGrowth(imports, publish) {
+  const env = imports.env;
+  const resize = env?.emscripten_resize_heap;
+  if (!env || typeof resize !== "function") return;
+  env.emscripten_resize_heap = (...args) => {
+    const grown = resize(...args);
+    publish();
+    return grown;
+  };
+}
 async function runWasmProcess(init, port, deps = {}) {
   const signals = new SignalGate(
-    createSyncSabTransport(init.sab, port),
+    createSyncSabTransport(init.sab, port, {
+      memory: () => memory?.buffer.byteLength ?? 0
+    }),
     new Int32Array(init.sab, 0, SAB_HEADER_I32),
     {
       masks: () => signalMasks(module),
@@ -2926,9 +2981,11 @@ async function runWasmProcess(init, port, deps = {}) {
           sys,
           memory: () => memory
         });
+        reportGrowth(imports, () => publishMemory(init.sab, memory?.buffer.byteLength ?? 0));
         return WebAssembly.instantiate(init.program.module, imports);
       }).then((instance) => {
         memory = wasmMemory(instance, imports);
+        publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
         done(instance, init.program.module);
       }, failed2);
       return {};
@@ -2960,6 +3017,8 @@ async function runWasmProcess(init, port, deps = {}) {
   const restartable = () => signals.restartable();
   const streams = new KernelStreams(running.FS, sys, { sigpipe, restartable });
   trackCloseOnExec(running.FS);
+  useMounts(running.FS, init.env);
+  useProcfs(running.FS, sys, init.pid);
   if (init.fork) restoreForkedStreams(running.FS, streams, init.fork.streams ?? []);
   else {
     wireKernelStdio(running.FS, streams);
@@ -2969,8 +3028,6 @@ async function runWasmProcess(init, port, deps = {}) {
   if (pipefs) streams.usePipes(pipefs);
   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({
@@ -5214,8 +5271,8 @@ function align(n, to) {
   return Math.ceil(n / to) * to;
 }
 function growTo(memory, bytes) {
-  const pages = Math.ceil(bytes / PAGE) - memory.buffer.byteLength / PAGE;
-  if (pages > 0) memory.grow(pages);
+  const pages2 = Math.ceil(bytes / PAGE) - memory.buffer.byteLength / PAGE;
+  if (pages2 > 0) memory.grow(pages2);
 }
 function growTable(table, length) {
   if (table.length < length) table.grow(length - table.length);
@@ -6442,14 +6499,20 @@ function restoreExportedMemory(instance, imported, init) {
   fillMemory(instance.exports.memory, init.fork.memory);
 }
 function fillMemory(memory, copy) {
-  const pages = copy.byteLength / 65536 - memory.buffer.byteLength / 65536;
-  if (pages > 0) memory.grow(pages);
+  const pages2 = copy.byteLength / 65536 - memory.buffer.byteLength / 65536;
+  if (pages2 > 0) memory.grow(pages2);
   new Uint8Array(memory.buffer).set(copy);
 }
+function sizeOf(main) {
+  return () => main.memory?.buffer.byteLength ?? 0;
+}
+function memoryOf(instance, imported) {
+  return imported ?? instance.exports.memory;
+}
 function kernelOf(init, port, hooks = { masks: () => null, raise: () => {
-} }) {
+} }, memory) {
   const transport = new SignalGate(
-    createSyncSabTransport(init.sab, port),
+    createSyncSabTransport(init.sab, port, memory ? { memory } : {}),
     new Int32Array(init.sab, 0, SAB_HEADER_I32),
     hooks
   ).transport();
@@ -6562,7 +6625,8 @@ async function runWasiProcess(init, port) {
     call2({ op: "proc-kill", pid: init.pid, sig });
     throw new WasiExit(128 + sig);
   });
-  const { transport, sys, call: kernelCall, say } = kernelOf(init, port, signals);
+  const main = {};
+  const { transport, sys, call: kernelCall, say } = kernelOf(init, port, signals, sizeOf(main));
   const stats = init.env.SLICC_WASI_STATS === "1" ? new WasiStats() : void 0;
   const call2 = stats ? timedCalls(stats, kernelCall) : kernelCall;
   const { module } = init.program;
@@ -6602,6 +6666,8 @@ async function runWasiProcess(init, port) {
     ...program ? { program } : {}
   });
   restoreExportedMemory(instance, memory, init);
+  main.memory = memoryOf(instance, memory);
+  publishMemory(init.sab, sizeOf(main)());
   signals.bind(instance.exports);
   host.onRaise = (sig) => signals.raised(sig);
   const exports = instance.exports;