@ai-ecoverse/slicc-kernel 1.54.6 → 1.54.8

package/README.md

@@ -66,7 +66,7 @@ Starts `argv` as the session leader on a new terminal and resolves once it is ru
 | --- | --- |
 | `pid` | the session leader's pid |
 | `onData` | the output listener; output that arrives while it is `null` is kept and delivered when one is set |
-| `write(data)` | types a string or bytes into the terminal; with `ISIG` on, `^C`, `^Z` and `^\` signal the foreground process group. A key typed while a child of that group is still setting up is held until the child has finished, then sent to the group in the foreground at that point. Setting up means the child's calls before its first other one: `setpgid`, `tcsetpgrp`, signal masks, and starting the program it execs (which then sets itself up too). The hold ends 2 s after the child's first call at the latest. A key typed while the foreground group is busy, not reading the terminal (a shell between reading a command line and starting it), goes to that group and also to the job the group starts next, once that job has taken the terminal; the second copy is dropped when the group reads the terminal again. So `^C` or `^Z` right after a command line reaches the new job, as it does on Linux, where starting a job takes microseconds rather than a worker start. For the same reason, a child that is still setting up cannot give the terminal to its own group once its parent has already given the terminal to that group and taken it back: on Linux the child's `tcsetpgrp` would have landed first, so the parent's later choice stands. Otherwise `tcsetpgrp` behaves as before. A `^C`, `^\` or `^Z` that a program with a handler for it takes between two system calls, rather than while waiting, ends the program's next wait in the kernel that would block (reading nothing yet, `select` or `poll` with a timeout, a blocking write, `waitpid`) with `EINTR`, once, as if the key had come during that wait. A zero-timeout `select` or `poll` does not use it up. Without this, an interactive shell whose `^C` landed while it was taking in the key before it would wait for the next key before showing a new prompt: readline acts on `^C` only when a read ends with `EINTR`. On Linux that window is the microseconds between two reads; here it is a few kernel calls per key. A signal sent with `kill` does not do this. |
+| `write(data)` | types a string or bytes into the terminal; with `ISIG` on, `^C`, `^Z` and `^\` signal the foreground process group. A key typed while a child of that group is still setting up is held until the child has finished, then sent to the group in the foreground at that point; this applies only to children of a job-control shell (a process that ignores `SIGTTOU`, as interactive shells do) and to the programs those children exec, so a program that starts a child without job control (Python's `subprocess`) gets the key at once. Setting up means the child's calls before its first other one: `setpgid`, `tcsetpgrp`, signal masks, and starting the program it execs (which then sets itself up too). The hold ends 2 s after the child's first call at the latest. A key typed while the foreground group is busy, not reading the terminal (a shell between reading a command line and starting it), goes to that group and also to the job the group starts next, once that job has taken the terminal; the second copy is dropped when the group reads the terminal again. So `^C` or `^Z` right after a command line reaches the new job, as it does on Linux, where starting a job takes microseconds rather than a worker start. For the same reason, a child that is still setting up cannot give the terminal to its own group once its parent has already given the terminal to that group and taken it back: on Linux the child's `tcsetpgrp` would have landed first, so the parent's later choice stands. Otherwise `tcsetpgrp` behaves as before. A `^C`, `^\` or `^Z` that a program with a handler for it takes between two system calls, rather than while waiting, ends the program's next wait in the kernel that would block (reading nothing yet, `select` or `poll` with a timeout, a blocking write, `waitpid`) with `EINTR`, once, as if the key had come during that wait. A zero-timeout `select` or `poll` does not use it up. Without this, an interactive shell whose `^C` landed while it was taking in the key before it would wait for the next key before showing a new prompt: readline acts on `^C` only when a read ends with `EINTR`. On Linux that window is the microseconds between two reads; here it is a few kernel calls per key. A signal sent with `kill` does not do this. |
 | `resize(cols, rows)` | sets the window size (`TIOCGWINSZ`) and sends `SIGWINCH` to the foreground process group |
 | `signal(name)` | sends a signal (`'SIGINT'`, `'SIGTSTP'`, `'SIGQUIT'`, `'SIGHUP'`, …) to the foreground process group, regardless of termios |
 | `exited` | resolves with the session leader's exit status (`128 + n` if killed by signal `n`) |
@@ -500,7 +500,7 @@ Programs ask the kernel for their ids:
 
 ### `/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 are the credentials in `status` (`Uid:`, `Gid:`, `Groups:`) and 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. A process that isn't root sees only its own user's processes (see [Users](#users)). WASI and WASIX programs see the same `/proc`, read-only (opening a file in it for writing fails with `EROFS`), from every thread, also through a symlink that points into it (where every change, `mkdir`, `rename`, `unlink`, `chmod` and so on, fails too: with `EROFS` when the root file system has a physical `/proc`, which stays hidden and untouched, and otherwise with the `ENOENT` of the missing directory, since that check is only paid for when a physical `/proc` exists), and `/` lists it, so a WASI program gets a preopen for it; `/proc/self` is the program's own pid there too (the pid an exec'd program took over). Neither has `/proc/<pid>/fd` yet.
+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 are the credentials in `status` (`Uid:`, `Gid:`, `Groups:`) and 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. A process that isn't root sees only its own user's processes (see [Users](#users)). WASI and WASIX programs see the same `/proc`, read-only (opening a file in it for writing fails with `EROFS`), from every thread, also through a symlink that points into it (where every change, `mkdir`, `rename`, `unlink`, `chmod` and so on, fails too: with `EROFS` when the root file system has a physical `/proc`, which stays hidden and untouched, and otherwise with the `ENOENT` of the missing directory, since that check is only paid for when a physical `/proc` exists; with one, a symlink whose target passes `..` after a file or a missing name, such as `/f/../proc`, fails with `ENOTDIR` or `ENOENT`, as on Linux), and `/` lists it, so a WASI program gets a preopen for it; `/proc/self` is the program's own pid there too (the pid an exec'd program took over). Neither has `/proc/<pid>/fd` yet.
 
 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.
 

package/dist/kernel-worker.js

@@ -1806,9 +1806,9 @@ var KernelSocket = class _KernelSocket {
         case SO_TYPE:
           return SOCK_STREAM;
         case SO_ERROR: {
-          const failed = this.failed;
+          const failed2 = this.failed;
           this.failed = void 0;
-          return failed ? wasiErrno(failed) : 0;
+          return failed2 ? wasiErrno(failed2) : 0;
         }
         case SO_ACCEPTCONN:
           return this.state === "listening" ? 1 : 0;
@@ -8022,6 +8022,7 @@ function* procWalk(path, follow2) {
   let done4 = [];
   let todo = path.split("/").filter((part) => part !== "");
   let hops = 0;
+  let broken;
   while (todo.length > 0) {
     const part = todo.shift();
     if (part === ".") continue;
@@ -8031,19 +8032,31 @@ function* procWalk(path, follow2) {
     }
     const at = `/${[...done4, part].join("/")}`;
     const whole = normalize(`/${[...done4, part, ...todo].join("/")}`);
-    if (inProc(at) && inProc(whole)) return whole;
+    if (inProc(at) && inProc(whole)) return broken ?? whole;
     if (!follow2 && todo.length === 0) return void 0;
-    const target = yield at;
-    if (target === null) return void 0;
-    if (target === void 0) done4.push(part);
-    else {
+    const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
+    if (typeof target === "string") {
       if (++hops > MAX_HOPS2) return void 0;
-      if (target.startsWith("/")) done4 = [];
-      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+      [done4, todo] = throughLink(target, done4, todo);
+    } else {
+      broken ??= refusalOf(target);
+      done4.push(part);
     }
   }
   return void 0;
 }
+function failed(err) {
+  const code = err?.code;
+  return { refused: typeof code === "string" ? code : "ENOENT" };
+}
+function refusalOf(found) {
+  if (found === true) return void 0;
+  return found === false ? { refused: "ENOTDIR" } : found;
+}
+function throughLink(target, done4, todo) {
+  const parts = target.split("/").filter((part) => part !== "");
+  return [target.startsWith("/") ? [] : done4, [...parts, ...todo]];
+}
 async function procAlias(fs, path, follow2) {
   const { readlink, lstat } = fs;
   if (!readlink || !lstat) return void 0;
@@ -8055,7 +8068,10 @@ async function procAlias(fs, path, follow2) {
   const walk = procWalk(path, follow2);
   let step = walk.next();
   while (!step.done) {
-    const target = await readlink.call(fs, step.value).catch(() => void 0);
+    const { at, check } = step.value;
+    const link2 = await readlink.call(fs, at).catch(() => void 0);
+    const isDir = (st) => st.isDirectory === true;
+    const target = link2 ?? (check ? await lstat.call(fs, at).then(isDir, failed) : true);
     step = walk.next(target);
   }
   return step.value;
@@ -10101,6 +10117,8 @@ var WasmProcess = class {
   async openVfs(req) {
     if (inProc(req.path)) return this.openProc(req, req.path);
     const alias = req.orphan ? void 0 : await procAlias(this.options.fs, req.path, !req.exclusive);
+    if (typeof alias === "object")
+      throw Object.assign(new Error(alias.refused), { code: alias.refused });
     if (alias !== void 0) return this.openProc(req, alias);
     await refuseReadonly(this.options.fs, req.path, req.flags, req);
     const fd = this.fds.install(heldFile(), 3);
@@ -11757,22 +11775,22 @@ async function mountFstab(lines2, mount, signal, retries = FSTAB_RETRIES, discar
   );
 }
 async function mountLine({ line, spec, invalid }, mount, signal, retries, discard) {
-  let failed = invalid;
+  let failed2 = invalid;
   for (let attempt = 0; !invalid && attempt <= retries.length && !signal.aborted; attempt++) {
     try {
       const entry = await mount(spec);
       if (!signal.aborted) return { line, target: spec.target, entry };
       discard(entry);
-      failed = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
+      failed2 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
       break;
     } catch (err) {
-      failed = err;
+      failed2 = err;
       if (FINAL.has(codeOf3(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf3(failed);
-  return { line, target: spec.target, code, error: String(failed?.message ?? code) };
+  const code = codeOf3(failed2);
+  return { line, target: spec.target, code, error: String(failed2?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
@@ -13078,7 +13096,7 @@ var Launcher = class {
     this.processes.set(pid, handle);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
-    if (req.ppid !== void 0) this.settling.started(pid, req.ppid);
+    if (req.ppid !== void 0 && this.controlsJobs(req.ppid)) this.settling.started(pid, req.ppid);
     this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
     if (req.exec && req.ppid !== void 0) this.jobs.exec(req.ppid, pid, true);
     if (req.pgid !== void 0) this.jobs.join(pid, req.pgid);
@@ -13248,6 +13266,9 @@ var Launcher = class {
     const masks = this.processes.get(pid)?.signalMasks?.();
     return masks ? { sigIgn: masks.ignored, sigCgt: masks.caught } : {};
   }
+  controlsJobs(pid) {
+    return this.settling.isSettling(pid) || (this.ignoredBy(pid) & sigbit(SIG.TTOU)) !== 0;
+  }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }