@ai-ecoverse/slicc-kernel 1.29.0 → 1.29.1

package/README.md

@@ -360,12 +360,12 @@ Programs mount and unmount with `mount(2)` and `umount2(2)`, so a `mount`/`umoun
 
 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()`.
+- **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 works the same way: a new program asks the kernel for its pid before `main`, and the kernel answers once its parent has made its next call, so an image an older shim execs also reports the pid it replaced (the wait starts once the program is loaded; should the parent make no call within 100 ms after that, the kernel answers anyway, and the image may then report its own pid; `launcher.identities` counts the programs that asked and those answered by that timeout).
 - **WASIX:** `proc_exec` does this by itself.
 
 ### `/proc`
 
-Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike. Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so is each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times, load and `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) are placeholders. Only Emscripten processes see this `/proc`.
+Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike, and so does a process whose parent has ended, waited for or not (`getppid()` asks the kernel each time; a shell's `$PPID` keeps the value it started with, as on Linux). Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so is each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times, load and `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) are placeholders. Only Emscripten processes see this `/proc`.
 
 While OPFS has no `/etc/passwd`, `/etc/group` or `/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.
 

package/dist/kernel-worker.js

@@ -7732,6 +7732,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "mount",
   "umount",
   "proc-exec",
+  "proc-identity",
   "proc-setpgid",
   "proc-getpgid",
   "proc-getsid",
@@ -7831,6 +7832,7 @@ var WasmProcess = class {
     for (const listener of this.stateListeners) listener("continued", SIG.CONT);
   }
   async syscall(req) {
+    this.options.onSyscall?.();
     for (; ; ) {
       await this.resumed;
       const stops = this.stops;
@@ -8176,6 +8178,8 @@ var WasmProcess = class {
         const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
         return { ok: true, kind: "json", json: waited };
       }
+      case "proc-identity":
+        return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
         this.execChild = req.pid;
         this.options.jobs?.exec(this.pid, req.pid);
@@ -8326,6 +8330,8 @@ function spawnWasmProcess(opts) {
   const header2 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const process = new WasmProcess(opts.pid, opts.fds, {
     ...opts.ignored ? { ignored: opts.ignored } : {},
+    ...opts.identity ? { identity: opts.identity } : {},
+    ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     spawner: opts.spawner,
     forker: opts.forker,
     fs: opts.fs,
@@ -9798,6 +9804,7 @@ var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 var WASM_MAGIC = [0, 97, 115, 109];
 var SHEBANG_MAX = 256;
 var NOT_FOUND = 127;
+var DECIDE_MS = 100;
 var INIT_PID = 1;
 var SHARED_DIRS = ["/tmp", "/home"];
 var encoder3 = new TextEncoder();
@@ -9896,6 +9903,8 @@ var Launcher = class {
   fstabRetries;
   inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
+  deciding = /* @__PURE__ */ new Map();
+  identities = { asked: 0, timedOut: 0 };
   nodes;
   held = /* @__PURE__ */ new Set();
   processMounts;
@@ -10102,8 +10111,19 @@ var Launcher = class {
     }
     const pid = this.nextPid++;
     const terminal = req.fds.stdioTerminal();
+    const decided = req.decided ?? Promise.resolve(true);
+    const count = (byParent) => {
+      this.identities.asked++;
+      if (!byParent) this.identities.timedOut++;
+    };
+    let asked;
     const handle = spawnWasmProcess({
       pid,
+      identity: async () => {
+        await (asked ??= decided.then(count));
+        return this.identityOf(pid);
+      },
+      onSyscall: () => this.decide(pid),
       ...req.ignored ? { ignored: req.ignored } : {},
       program: req.program,
       argv0: req.argv0,
@@ -10176,7 +10196,8 @@ var Launcher = class {
     };
     const shown = (pid) => {
       const member = pid === void 0 ? void 0 : members.get(pid);
-      return member ? rootOf(member).pid : INIT_PID;
+      const root = member && rootOf(member).pid;
+      return root !== void 0 && this.running(root) ? root : INIT_PID;
     };
     const listed = [];
     for (const member of members.values()) {
@@ -10205,7 +10226,9 @@ var Launcher = class {
         throw new SpawnError(await this.unrunnable(req.file, req.cwd));
       }
       const exec = req.exec ? { exec: true } : {};
+      const deciding = req.exec ? void 0 : this.undecided(ppid);
       const handle = await this.launch(planned, {
+        ...deciding ? { decided: deciding.promise } : {},
         env: req.env,
         cwd: req.cwd,
         fds,
@@ -10214,9 +10237,39 @@ var Launcher = class {
         ignored: this.ignoredBy(ppid),
         ...exec
       });
+      deciding?.attach();
       return childHandle(handle);
     };
   }
+  undecided(ppid) {
+    const decided = Promise.withResolvers();
+    return {
+      promise: decided.promise,
+      attach: () => {
+        const timer = setTimeout(() => decided.resolve(false), DECIDE_MS);
+        void decided.promise.then(() => clearTimeout(timer));
+        const waiting = this.deciding.get(ppid) ?? /* @__PURE__ */ new Set();
+        waiting.add(decided.resolve);
+        this.deciding.set(ppid, waiting);
+      }
+    };
+  }
+  identityOf(pid) {
+    const parent = this.jobs.shownParent(pid);
+    const alive = parent !== void 0 && this.running(parent);
+    return { pid: this.jobs.shown(pid), ppid: alive ? parent : INIT_PID };
+  }
+  running(shown) {
+    return this.jobs.list().some((member) => !this.zombies.has(member.pid) && this.jobs.shown(member.pid) === shown);
+  }
+  decide(ppid) {
+    const waiting = this.deciding.get(ppid);
+    if (!waiting) return;
+    this.deciding.delete(ppid);
+    setTimeout(() => {
+      for (const resolve of waiting) resolve(true);
+    }, 0);
+  }
   forker(ppid, parent) {
     const { exec: _exec, ...image } = parent;
     return async (state, fds) => childHandle(