@ai-ecoverse/slicc-kernel 1.26.3 → 1.26.5

package/README.md

@@ -300,7 +300,7 @@ Programs mount and unmount with `mount(2)` and `umount2(2)`, so a `mount`/`umoun
 
 ### Exec
 
-An exec'd program takes over the pid of the process it replaces, as on Linux: `getpid()` and `$$` in the new image, `/proc`, `ps`, `kill` and the parent's `waitpid` all agree on that pid, and the image's parent pid is the replaced process's. Its own children see that pid as their parent.
+An exec'd program takes over the pid of the process it replaces, as on Linux: `getpid()` and `$$` in the new image, `/proc`, `ps`, `kill` and the parent's `waitpid` all agree on that pid, and the image's parent pid is the replaced process's. Its own children see that pid as their parent. A file removed or renamed over while programs hold it open keeps its bytes for them, as on Linux: the kernel keeps one copy for all holders, shared by their descriptors (writes through one are seen through the others), and frees it when the last one closes. Signals a program ignores stay ignored in the image it execs and in the children it spawns or forks, as POSIX has it, so `nohup cmd` and `trap '' TERM; exec cmd` keep `cmd` safe from them; caught signals go back to their default. The kernel holds what was handed down, so a new image that sets one of those signals back to the default with `signal(SIG_DFL)` still ignores it, until it installs a handler.
 
 - **Emscripten:** `Module.sliccKernel.execve(file, argv, env, cwd)` runs `file` as this process's new image on its fds 0, 1 and 2, waits for it, and returns its wait status, or a negative errno when it cannot start. `env` and `cwd` may be `null` for this process's own. An exec shim detects it with `typeof Module.sliccKernel.execve === 'function'` and exits with the status it returns, as `execve` never returns on success. Older shims spawn the program and then call `Module.sliccKernel.execWait(pid)`; that still works, but the image then reports a pid of its own from `getpid()`.
 - **WASIX:** `proc_exec` does this by itself.

package/dist/kernel-worker.js

@@ -6919,8 +6919,10 @@ var VfsNodes = class {
     for (const [p, node] of this.byPath) if (within3(p, path)) await node.serial(() => node.flush());
   }
   async unlinking(path) {
-    const node = this.byPath.get(path);
-    if (node) await node.serial(async () => void await Promise.all([node.keep(), node.limit()]));
+    for (const [held, node] of [...this.byPath]) {
+      if (!within3(held, path)) continue;
+      await node.serial(async () => void await Promise.all([node.keep(), node.limit()]));
+    }
   }
   revoke(prefix) {
     for (const [path, node] of this.byPath) {
@@ -6930,10 +6932,11 @@ var VfsNodes = class {
     }
   }
   unlinked(path) {
-    const node = this.byPath.get(path);
-    if (!node) return;
-    node.orphaned = true;
-    this.byPath.delete(path);
+    for (const [held, node] of [...this.byPath]) {
+      if (!within3(held, path)) continue;
+      node.orphaned = true;
+      this.byPath.delete(held);
+    }
   }
   renamed(from, to) {
     if (from === to) return;
@@ -7007,6 +7010,23 @@ async function refuseReadonly(fs, path, flags, opts = {}) {
   const st = own ?? await stat(await targetDir(fs, path));
   if (st?.readonly) throw new KernelError("EROFS");
 }
+function keepingOpen(fs, nodes) {
+  return {
+    ...fs,
+    async rm(path, options) {
+      const at = fs.resolvePath("/", path);
+      await nodes.unlinking(at);
+      await fs.rm(path, options);
+      nodes.unlinked(at);
+    },
+    async rename(from, to) {
+      const [a, b] = [fs.resolvePath("/", from), fs.resolvePath("/", to)];
+      await nodes.unlinking(b);
+      await fs.rename(from, to);
+      nodes.renamed(a, b);
+    }
+  };
+}
 function vfsFile(fs, opts, nodes) {
   const access = opts.flags & O_ACCMODE;
   const readable = access !== O_WRONLY;
@@ -7182,6 +7202,7 @@ var WasmProcess = class {
   children;
   caught = 0;
   ignored = 0;
+  inherited = 0;
   interrupt = new AbortController();
   execChild;
   execTermsig;
@@ -7199,12 +7220,19 @@ var WasmProcess = class {
     this.pid = pid;
     this.fds = fds;
     this.options = options;
+    this.inherited = options.ignored ?? 0;
     this.children = new ChildTable(fds, options.spawner, options.forker);
-    this.nodes = new VfsNodes(options.fs);
-    options.openFiles?.add(this.nodes);
+    this.nodes = options.nodes ?? new VfsNodes(options.fs);
+    if (!options.nodes) options.openFiles?.add(this.nodes);
     this.children.onChildState = () => this.signal(SIG.CHLD);
     this.children.onReap = options.onReap;
   }
+  ignores(bit) {
+    return ((this.ignored | this.inherited & ~this.caught) & bit) !== 0;
+  }
+  inheritable(fork = false) {
+    return ((fork ? 0 : this.ignored) | this.inherited) & ~this.caught;
+  }
   signal(sig) {
     if (this.execChild !== void 0) {
       void Promise.resolve(this.options.kill?.(this.execChild, sig)).catch(() => void 0);
@@ -7214,7 +7242,7 @@ var WasmProcess = class {
     if (sig === SIG.CONT) this.cont();
     if (sig === SIG.STOP) return this.stop(sig);
     const bit = sigbit(sig);
-    if (this.ignored & bit) return "ignore";
+    if (this.ignores(bit)) return "ignore";
     if (!(this.caught & bit)) {
       const action = defaultAction(sig);
       return action === "stop" ? this.stop(sig) : action;
@@ -7513,7 +7541,7 @@ var WasmProcess = class {
     if (session !== void 0 && session !== tty) return;
     const pgid = this.pgid();
     if (jobs.tcgetpgrp(tty, this.sid()) === pgid) return;
-    if (this.ignored & sigbit(SIG.TTIN)) throw new KernelError("EIO");
+    if (this.ignores(sigbit(SIG.TTIN))) throw new KernelError("EIO");
     jobs.killGroup(pgid, SIG.TTIN);
     throw new KernelError("EINTR");
   }
@@ -7698,7 +7726,7 @@ var WasmProcess = class {
     this.asyncOps.close();
     for (const pid of this.children.pids()) this.options.onReap?.(pid);
     await this.fds.closeAll();
-    this.options.openFiles?.delete(this.nodes);
+    if (!this.options.nodes) this.options.openFiles?.delete(this.nodes);
     await this.options.http?.closeAll();
   }
 };
@@ -7741,12 +7769,14 @@ function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header2 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const process = new WasmProcess(opts.pid, opts.fds, {
+    ...opts.ignored ? { ignored: opts.ignored } : {},
     spawner: opts.spawner,
     forker: opts.forker,
     fs: opts.fs,
     kill: opts.kill,
     processes: opts.processes,
     openFiles: opts.openFiles,
+    ...opts.nodes ? { nodes: opts.nodes } : {},
     mounts: opts.mounts,
     ...opts.mount ? { mount: opts.mount } : {},
     ...opts.umount ? { umount: opts.umount } : {},
@@ -7883,7 +7913,8 @@ function spawnWasmProcess(opts) {
     signal,
     termsig: () => endedBy,
     onState: (listener) => process.onState(listener),
-    memory: () => Atomics.load(header2, SAB_I_MEMORY) * 65536
+    memory: () => Atomics.load(header2, SAB_I_MEMORY) * 65536,
+    ignoredSignals: (fork) => process.inheritable(fork)
   };
 }
 
@@ -9304,6 +9335,7 @@ var Launcher = class {
   fstabRetries;
   inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
+  nodes;
   held = /* @__PURE__ */ new Set();
   processMounts;
   booting = new AbortController();
@@ -9337,7 +9369,10 @@ var Launcher = class {
       ca: this.ca
     });
     enableCdp(this.net, this.cdp);
-    this.fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
+    const fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
+    this.nodes = new VfsNodes(fs);
+    this.openFiles.add(this.nodes);
+    this.fs = keepingOpen(fs, this.nodes);
     this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
       this.catalog = void 0;
     });
@@ -9495,6 +9530,7 @@ var Launcher = class {
     const terminal = req.fds.stdioTerminal();
     const handle = spawnWasmProcess({
       pid,
+      ...req.ignored ? { ignored: req.ignored } : {},
       program: req.program,
       argv0: req.argv0,
       args: req.args,
@@ -9509,6 +9545,7 @@ var Launcher = class {
       kill: (target, sig) => this.kill(target, sig),
       processes: () => ({ boot: this.boot, processes: this.list() }),
       openFiles: this.openFiles,
+      nodes: this.nodes,
       held: this.held,
       statfs: (path) => this.mounts.statfs(path),
       mounts: () => this.mounts.list(),
@@ -9599,6 +9636,7 @@ var Launcher = class {
         fds,
         report,
         ppid,
+        ignored: this.ignoredBy(ppid),
         ...exec
       });
       return childHandle(handle);
@@ -9606,7 +9644,19 @@ var Launcher = class {
   }
   forker(ppid, parent) {
     const { exec: _exec, ...image } = parent;
-    return async (state, fds) => childHandle(this.start({ ...image, cwd: state.cwd ?? parent.cwd, fds, ppid, fork: state }));
+    return async (state, fds) => childHandle(
+      this.start({
+        ...image,
+        cwd: state.cwd ?? parent.cwd,
+        fds,
+        ppid,
+        fork: state,
+        ignored: this.ignoredBy(ppid, true)
+      })
+    );
+  }
+  ignoredBy(pid, fork = false) {
+    return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
   kill(pid, sig) {
     if (pid < 0) return this.jobs.killGroup(-pid, sig);