@ai-ecoverse/slicc-kernel 1.122.3 → 1.123.0

package/README.md

@@ -918,6 +918,15 @@ Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `
 
 The kernel writes `/etc/passwd` and `/etc/group` when it starts (see [Users](#users)). While the root has none of them, or no `/etc/mtab`, reading them gets per-process ones: root is uid 0 and the realm user, uid 1000, is named after `USER`, or `web_user` (Emscripten's default) without one, so it matches `$USER`, with `HOME` as its home, so `id`, `whoami`, `ls -l` and `ps` show names. Nothing is written to OPFS, and a real file there wins.
 
+### How many processes at once
+
+In a browser every process worker of the page shares one renderer. V8 reserves about 8 GiB of address space for each 32-bit wasm memory, whatever its declared maximum, and its sandbox holds about 1 TiB. So a page runs about 125 wasm processes (or programs that own a wasm memory) at once, counting everything in the renderer (#970). Node has no such ceiling, and neither does Linux. The kernel keeps processes inside that ceiling:
+- **The ceiling:** 112 by default in a browser and none in Node. It's the kernel's count of live wasm processes, with the kernel's other wasm memories in the page left outside it. When an instantiation runs out of memory anyway, the kernel learns the real ceiling at that moment (the live count minus one), and that learned value wins over the default.
+- **Admission:** a spawn, fork, exec or `kernel.run` at the ceiling waits for another process to exit. It keeps waiting as long as processes exit or are admitted, and fails with `EAGAIN` only after 10 s with neither. A long `make -j` or `xargs -P` therefore queues, and a pipeline that needs more live processes than the ceiling fails cleanly. bash's own retry on a fork's `EAGAIN` (`fork: retry: Resource temporarily unavailable`) handles the rest.
+- **Close to the ceiling** (within 16 of it), the kernel waits for each new process to finish instantiating before the spawn returns. If it ran out of memory, the kernel starts it again, quietly, once there's room, so the caller sees no failure.
+- **The rare residual case:** a process that fails to instantiate with nobody waiting on it, which happens only when something outside the count fills the renderer. It ends with status 126 and `<program>: cannot allocate memory for a new process (too many processes at once)` on its stderr, never a JS `RangeError`.
+- **`/proc/sys/kernel/slicc_wasm_memories`** reads `<live> <ceiling>` (the ceiling 0 for none).
+
 ### Metadata
 
 OPFS stores names, bytes, sizes and modification times, nothing else. Everything POSIX needs on top of that lives in an IndexedDB sidecar, so it survives reloads and new kernels:

package/dist/kernel-worker.js

@@ -6408,7 +6408,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.122.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.123.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -12551,17 +12551,28 @@ var FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
 var PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
 var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime", "version"];
 var SYS_TREE = {
-  kernel: { osrelease: `${OS_RELEASE}
-`, ostype: "Linux\n" }
+  kernel: {
+    osrelease: `${OS_RELEASE}
+`,
+    ostype: "Linux\n",
+    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0}
+`
+  }
 };
+function isSysFile(at) {
+  return typeof at === "string" || typeof at === "function";
+}
 function sysEntry(parts2) {
   let at = SYS_TREE;
   for (const part of parts2) {
-    if (typeof at !== "object" || !Object.hasOwn(at, part)) return void 0;
+    if (isSysFile(at) || !Object.hasOwn(at, part)) return void 0;
     at = at[part];
   }
   return at;
 }
+function sysText(file, listing) {
+  return typeof file === "string" ? file : file(listing());
+}
 function commOf(info) {
   const name2 = info.argv[0] ?? "";
   return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
@@ -12797,7 +12808,9 @@ var ProcTree = class {
     }
     if (top === "sys") {
       const entry = sysEntry(parts2.slice(1));
-      if (typeof entry === "string") return { kind: "file", content: () => entry };
+      if (typeof entry === "string" || typeof entry === "function") {
+        return { kind: "file", content: () => sysText(entry, () => this.listing()) };
+      }
       return entry && { kind: "dir", names: () => Object.keys(entry) };
     }
     if (top === "self") {
@@ -19254,6 +19267,7 @@ var WasmProcess = class {
 var WASM_PROCESS_INIT = "wasm-process-init";
 var WASM_PROCESS_EXIT = "wasm-process-exit";
 var WASM_PROCESS_ERROR = "wasm-process-error";
+var WASM_PROCESS_READY = "wasm-process-ready";
 var WASM_THREAD_SPAWN = "wasm-thread-spawn";
 var WASM_THREAD_INIT = "wasm-thread-init";
 var WASM_THREAD_EXIT = "wasm-thread-exit";
@@ -19261,6 +19275,8 @@ var WASM_MAX_THREADS = 256;
 
 // src/kernel/host.ts
 var CRASHED = 70;
+var NO_MEMORY = 126;
+var WASM_OOM = /Cannot allocate Wasm memory|WebAssembly\.Memory\(\): could not allocate memory/;
 var KILL_GRACE_MS = 2e3;
 var KILL_HARD_MS = 5e3;
 var descIds = /* @__PURE__ */ new WeakMap();
@@ -19526,7 +19542,22 @@ function threadInit(opts, program, sab, cred, thread, main) {
 function settleExit(exit, settle3, code) {
   void exit.catch(() => void 0).then(() => settle3(code & 255));
 }
+function readiness(abi) {
+  const ready2 = Promise.withResolvers();
+  if (abi === "js") ready2.resolve(true);
+  return ready2;
+}
+function outOfMemory(opts, data) {
+  if (data?.type !== WASM_PROCESS_ERROR || !WASM_OOM.test(String(data.message))) return false;
+  if (!opts.onOom?.()) {
+    opts.onError?.(
+      `${opts.argv0}: cannot allocate memory for a new process (too many processes at once)`
+    );
+  }
+  return true;
+}
 function spawnWasmProcess(opts) {
+  const { promise: ready2, resolve: started } = readiness(opts.program.abi);
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const blocked2 = opts.fork?.wasi?.blocked ?? opts.blocked;
@@ -19579,6 +19610,7 @@ function spawnWasmProcess(opts) {
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    started(true);
     clocks.freeze();
     dying.clear();
     endedBy = sig ?? process.execTermsig;
@@ -19596,7 +19628,12 @@ function spawnWasmProcess(opts) {
     queueMicrotask(() => finish(...dying.status(code)));
   };
   const handle = (data) => {
-    if (data?.type === WASM_PROCESS_EXIT) {
+    if (data?.type === WASM_PROCESS_READY) {
+      started(true);
+    } else if (outOfMemory(opts, data)) {
+      started(false);
+      finish(NO_MEMORY);
+    } else if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
       if (!dying.ending) opts.onError?.(String(data.message));
@@ -19670,6 +19707,7 @@ function spawnWasmProcess(opts) {
   return {
     pid: opts.pid,
     exited,
+    ready: ready2,
     kill,
     signal,
     termsig: () => endedBy,
@@ -21264,6 +21302,63 @@ var SettlingChildren = class {
   }
 };
 
+// src/kernel/wasm-memories.ts
+var DEFAULT_CEILING = 112;
+var IDLE_MS = 1e4;
+var MARGIN = 16;
+var WasmMemories = class {
+  live = 0;
+  ceiling;
+  waiters = /* @__PURE__ */ new Set();
+  idleMs;
+  constructor(ceiling, idleMs = IDLE_MS) {
+    this.ceiling = ceiling;
+    this.idleMs = idleMs;
+  }
+  count() {
+    return { live: this.live, ceiling: this.ceiling ?? 0 };
+  }
+  ended() {
+    this.live = Math.max(0, this.live - 1);
+    this.progress();
+  }
+  learn() {
+    this.ceiling = Math.max(1, this.live - 1);
+  }
+  near() {
+    return this.ceiling !== void 0 && this.live + MARGIN >= this.ceiling;
+  }
+  async admit() {
+    while (this.ceiling !== void 0 && this.live >= this.ceiling) {
+      if (!await this.changed()) throw new SpawnError("EAGAIN");
+    }
+    this.live += 1;
+    this.progress();
+  }
+  progress() {
+    const waiters = [...this.waiters];
+    this.waiters.clear();
+    for (const wake of waiters) wake();
+  }
+  changed() {
+    return new Promise((resolve2) => {
+      const wake = () => {
+        clearTimeout(timer);
+        resolve2(true);
+      };
+      const timer = setTimeout(() => {
+        this.waiters.delete(wake);
+        resolve2(false);
+      }, this.idleMs);
+      this.waiters.add(wake);
+    });
+  }
+};
+function defaultCeiling() {
+  const node = globalThis.process?.versions?.node;
+  return node === void 0 ? DEFAULT_CEILING : void 0;
+}
+
 // src/mount/driver.ts
 function ownerOf2(req) {
   const owner = {
@@ -23461,6 +23556,9 @@ function withScriptEnv(target, command) {
     ]
   };
 }
+function memoriesOf(given) {
+  return new WasmMemories(given?.ceiling ?? defaultCeiling(), given?.idleMs);
+}
 function childHandle(handle) {
   return {
     pid: handle.pid,
@@ -23532,6 +23630,7 @@ var Launcher = class {
   jobs = new JobTable();
   locks;
   fifos = new FifoTable();
+  memories;
   sems = new SemTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
   ptys = new PtyTable(
@@ -23585,6 +23684,7 @@ var Launcher = class {
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
+    this.memories = memoriesOf(options.wasmMemories);
     this.rootFs = options.fs;
     const peers = options.fs.peers?.();
     this.locks = kernelLocks(options.fs.rootName, peers);
@@ -24415,7 +24515,11 @@ var Launcher = class {
     }
     const done4 = this.heldUrl(program);
     try {
-      const handle = this.start({ ...req, cwd, program, argv0: target.argv0, args, env });
+      const handle = await this.admitted(
+        program.abi !== "js",
+        req.fds,
+        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env })
+      );
       void handle.exited.finally(done4);
       return handle;
     } catch (err) {
@@ -24459,6 +24563,39 @@ var Launcher = class {
     if (req.tag !== void 0) this.tags.set(pid, req.tag);
     if (req.links !== void 0) this.links.set(pid, req.links);
   }
+  async admitted(wasm, fds, start2) {
+    if (!wasm) return start2(fds);
+    for (; ; ) {
+      await this.memories.admit().catch(async (err) => {
+        await fds.closeAll();
+        throw err;
+      });
+      const counted2 = (handle2) => {
+        void handle2.exited.finally(() => this.memories.ended());
+        return handle2;
+      };
+      if (!this.memories.near()) {
+        try {
+          return counted2(start2(fds));
+        } catch (err) {
+          this.memories.ended();
+          throw err;
+        }
+      }
+      const forked = fds.fork();
+      const handle = await Promise.resolve().then(() => counted2(start2(forked, true))).catch(async (err) => {
+        this.memories.ended();
+        await forked.closeAll();
+        throw err;
+      });
+      const fit = await (handle.ready ?? true);
+      if (fit) {
+        await fds.closeAll();
+        return handle;
+      }
+      await handle.exited;
+    }
+  }
   start(req) {
     this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
@@ -24509,6 +24646,10 @@ var Launcher = class {
       ...this.prefixes.length > 0 && !stack.writer ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
       createWorker: this.createWorker,
       onError: req.report,
+      onOom: () => {
+        this.memories.learn();
+        return req.quietOom === true;
+      },
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
       kill: (target, sig, info) => this.kill(target, sig, this.credOf(pid), pid, info),
@@ -24517,7 +24658,8 @@ var Launcher = class {
         boot: this.boot,
         processes: this.list(this.credOf(pid)),
         load: this.loadAverage(),
-        cpu: this.cpuTotal()
+        cpu: this.cpuTotal(),
+        wasm: this.memories.count()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -24854,9 +24996,10 @@ var Launcher = class {
   }
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
-    return async (state, fds) => childHandle(
-      this.start({
+    return async (state, given) => {
+      const fresh2 = (fds, quietOom) => this.start({
         ...image,
+        quietOom,
         cwd: state.cwd ?? parent.cwd,
         fds,
         ppid,
@@ -24867,8 +25010,9 @@ var Launcher = class {
         cred: this.credOf(ppid),
         tag: this.tagOf(ppid),
         links: this.links.get(ppid)
-      })
-    );
+      });
+      return childHandle(await this.admitted(parent.program.abi !== "js", given, fresh2));
+    };
   }
   keySignal(tty, fallback, sig, send) {
     const pgid = this.jobs.tcgetpgrp(tty, fallback);