@ai-ecoverse/slicc-kernel 1.54.7 → 1.54.8

package/README.md

@@ -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