@ai-ecoverse/slicc-kernel 1.34.0 → 1.35.0

package/README.md

@@ -349,7 +349,7 @@ Directories are renamed with `FileSystemHandle.move()` where available, else by
   - `@ai-ecoverse/slicc-kernel/driver` exports the types and `fsError`.
 - **Capabilities:** `readonly`, `symlinks`, `chmod`, `ranges`, `maxIo` (the largest read or write per message), `maxFile`, `listingStats`, `linkTimes`, and `attrTtl`/`entryTtl` (in ms, default 1000). `linkTimes` promises that `setattr` with `mtime` on a symlink sets the link's own time. Without it, setting a link's own times (`touch -h`, `utimensat` with `AT_SYMLINK_NOFOLLOW`) fails with `EOPNOTSUPP` and never reaches the target. tmpfs has it; hostfs does not. Setting times through a link follows it in the kernel, so `setattr` gets the target. `ranges` (driver protocol 1.1) promises that a write lands in the file at once, with no copy of the whole file on `open` or `release`, and that `setattr` takes `size`.
 - **Caching:** the kernel caches attributes and listings for those TTLs, and a driver can push `invalidate` for changes made outside.
-- **File contents:** on a mount with `ranges`, as `tmpfs` is, and on the root file system when it is in OPFS (in a browser with sync access handles) or an in-memory root, a program reads and writes a file in 64 KiB pages: reads come from the driver 1 MiB at a time, and changed pages go back in 1 MiB runs once 8 MiB have changed, at `fsync`, and when the file is closed (from the kernel's own descriptors also 250 ms after a write). A file of any size the mount can hold works, with memory to spare for about one more copy of it. In OPFS a write opens a sync access handle for just that write. Elsewhere (`fsa` mounts, `hostfs` with an older proxy, and a root outside OPFS), file contents are read whole when a program opens a file and written back when it closes it. Both give close-to-open consistency, as NFS has. A process that ends without closing its files keeps what it wrote: on exit, on a trap, and when a signal kills it. For a killed WASI program, the kernel lets its worker write its changed pages back before `waitpid` reports the death. The only exception is a worker that makes no call into the kernel for 2 seconds after the signal; it is stopped without that write-back.
+- **File contents:** on a mount with `ranges`, as `tmpfs` is, and on the root file system when it is in OPFS (in a browser with sync access handles) or an in-memory root, a program reads and writes a file in 64 KiB pages: reads come from the driver 1 MiB at a time, and changed pages go back in 1 MiB runs once 8 MiB have changed, at `fsync`, and when the file is closed (from the kernel's own descriptors also 250 ms after a write). A file of any size the mount can hold works, with memory to spare for about one more copy of it. In OPFS a write opens a sync access handle for just that write. Elsewhere (`fsa` mounts, `hostfs` with an older proxy, and a root outside OPFS), file contents are read whole when a program opens a file and written back when it closes it. Before a program's next call into the kernel (any wait, read of a pipe or terminal, sleep or spawn), its changed pages also go back, so other processes and the embedder see a write as soon as the writer does anything but compute: a daemon's pidfile, a log another process follows. On a whole-file mount that holds only for files of up to 64 KiB; a larger one goes back at close, fsync and exit, as before. Beyond that, both give close-to-open consistency, as NFS has. A process that ends without closing its files keeps what it wrote: on exit, on a trap, and when a signal kills it. For a killed WASI program, the kernel lets its worker write its changed pages back before `waitpid` reports the death. The only exception is a worker that makes no call into the kernel for 2 seconds after the signal; it is stopped without that write-back.
 - **Rules on a mount:**
   - a rename across mounts is `EXDEV`, so `mv` copies;
   - `df` reports each mount from its driver's `statfs`;
@@ -421,6 +421,22 @@ An exec'd program takes over the pid of the process it replaces, as on Linux: `g
 - **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.
 
+### File modes and the umask
+
+Every process has a umask in the kernel, `022` for a process the embedder starts, inherited across fork, spawn and exec and shown in `/proc/<pid>/status` (`Umask:`). The kernel applies it when a program creates a file or directory, whatever its libc does: an Emscripten program's `open` with `O_CREAT`, `mkdir` and `mknod` (so `umask 077; touch f` gives `600` in a child too), and a WASI program's `path_open` with `O_CREAT` and `path_create_directory` (`0666` and `0777` less the umask).
+
+WASI and WASIX have no call for file modes, so the kernel adds the import module `slicc_fs`, whose functions return a preview1 errno (kernels without them answer `ENOSYS`):
+
+| Import | Does |
+| --- | --- |
+| `fd_chmod(fd, mode)` | `fchmod` on an open file or directory |
+| `path_chmod(dirfd, path, path_len, mode, flags)` | `fchmodat`; with `flags & 1` (`AT_SYMLINK_NOFOLLOW`) a symlink answers `ENOTSUP` and is never followed |
+| `umask(mask, old_out)` | sets the process's umask and writes the previous one |
+| `fd_mode(fd, mode_out)` | the permission bits of an open file or directory |
+| `path_mode(dirfd, path, path_len, flags, mode_out)` | those of a path, of the link itself with `flags & 1` |
+
+Lowering a soft resource limit (`ulimit -S -n 64`) still fails with `EPERM` in Emscripten programs: their libc's `setrlimit` is a stub compiled into the program, not a call to the kernel.
+
 ### `/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`.

package/dist/kernel-worker.js

@@ -1144,14 +1144,6 @@ function sinkFile(onData) {
     }
   });
 }
-function nullFile() {
-  return new OpenFile({
-    read: async () => new Uint8Array(0),
-    write: async (bytes) => bytes.length,
-    close: () => {
-    }
-  });
-}
 function written(device, bytes) {
   if (device === "full" && bytes.length > 0) throw new KernelError("ENOSPC");
   return bytes.length;
@@ -5003,7 +4995,7 @@ var ChildTable = class {
       captured.set(n, chunks);
       return sinkFile((bytes) => chunks.push(bytes));
     }
-    return nullFile();
+    return deviceFile("null");
   }
   async wait(pid, nohang, signal, flags = {}) {
     let interrupt;
@@ -7865,10 +7857,12 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-cloexec",
   "fd-list",
   "proc-alarm",
+  "proc-umask",
   "dl-log",
   "fd-renumber",
   "fd-promote",
   "fd-open-tty",
+  "fd-tty-names",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -7902,6 +7896,7 @@ function isWasmSyscall(req) {
   return typeof op === "string" && SYSCALL_OPS.has(op);
 }
 var MAX_READ = 1024 * 1024;
+var DEFAULT_UMASK = 18;
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
@@ -7912,6 +7907,7 @@ var WasmProcess = class {
   inherited = 0;
   interrupt = new AbortController();
   dying = false;
+  umask = DEFAULT_UMASK;
   execChild;
   execTermsig;
   stopped = 0;
@@ -7929,6 +7925,7 @@ var WasmProcess = class {
     this.fds = fds;
     this.options = options;
     this.inherited = options.ignored ?? 0;
+    this.umask = options.umask ?? DEFAULT_UMASK;
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
     if (!options.nodes) options.openFiles?.add(this.nodes);
@@ -8001,6 +7998,11 @@ var WasmProcess = class {
       return result;
     }
   }
+  setUmask(mask) {
+    const old = this.umask;
+    if (mask !== void 0) this.umask = mask & 511;
+    return old;
+  }
   die() {
     if (this.dying) return;
     this.dying = true;
@@ -8165,6 +8167,8 @@ var WasmProcess = class {
         if (!tty) throw new KernelError("ENXIO");
         return { ok: true, kind: "json", json: this.fds.install(tty.file(), 3) };
       }
+      case "fd-tty-names":
+        return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
         const signal = this.blockingSignal();
@@ -8396,6 +8400,8 @@ var WasmProcess = class {
       case "proc-alarm":
         this.setAlarm(req.sig, req.firstMs ?? req.ms, req.repeat ? req.ms : 0, req.timer);
         return { ok: true, kind: "void" };
+      case "proc-umask":
+        return { ok: true, kind: "json", json: this.setUmask(req.mask) };
       case "dl-log":
         if (req.append) this.dlLog.push(req.append);
         return { ok: true, kind: "json", json: this.dlLog.slice(req.from) };
@@ -8545,7 +8551,7 @@ var Dying = class {
     return [typeof reported === "number" ? reported : CRASHED, void 0];
   }
 };
-function processInit(opts, sab) {
+function processInit(opts, sab, umask) {
   const base = {
     type: WASM_PROCESS_INIT,
     pid: opts.shownPid ?? opts.pid,
@@ -8554,6 +8560,7 @@ function processInit(opts, sab) {
     env: opts.env,
     cwd: opts.cwd,
     sab,
+    umask,
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
   };
   if (opts.program.abi === "js") {
@@ -8565,11 +8572,17 @@ function processInit(opts, sab) {
     ...opts.fork ? { fork: opts.fork } : { fds: inheritedFds(opts.fds) }
   };
 }
+function inherited(opts) {
+  return {
+    ...opts.ignored ? { ignored: opts.ignored } : {},
+    ...opts.umask !== void 0 ? { umask: opts.umask } : {}
+  };
+}
 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 } : {},
+    ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     spawner: opts.spawner,
@@ -8703,7 +8716,7 @@ function spawnWasmProcess(opts) {
     };
     tw.postMessage(tinit);
   };
-  const init = processInit(opts, sab);
+  const init = processInit(opts, sab, process.umask);
   worker.postMessage(init, opts.fork ? [opts.fork.memory.buffer] : []);
   const signal = (sig) => {
     if (process.signal(sig) !== "terminate") return;
@@ -8721,6 +8734,7 @@ function spawnWasmProcess(opts) {
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header2, SAB_I_MEMORY) * 65536,
     ignoredSignals: (fork) => process.inheritable(fork),
+    umask: () => process.umask,
     writesBack: () => opts.program.abi === "wasi" && !done4
   };
 }
@@ -8826,8 +8840,13 @@ var JobTable = class {
     return id;
   }
   terminalNamed(name2) {
-    const known = /* @__PURE__ */ new Set([...this.terminals.values(), ...this.foreground.keys()]);
-    return [...known].find((tty) => tty.name === name2);
+    return this.knownTerminals().find((tty) => tty.name === name2);
+  }
+  terminalNames() {
+    return this.knownTerminals().flatMap((tty) => tty.name ? [tty.name] : []);
+  }
+  knownTerminals() {
+    return [.../* @__PURE__ */ new Set([...this.terminals.values(), ...this.foreground.keys()])];
   }
   controllingTerminal(pid) {
     const member = this.members.get(pid);
@@ -10461,6 +10480,7 @@ var Launcher = class {
         this.settling.syscall(pid, call.op);
       },
       ...req.ignored ? { ignored: req.ignored } : {},
+      ...req.umask !== void 0 ? { umask: req.umask } : {},
       program: req.program,
       argv0: req.argv0,
       args: req.args,
@@ -10552,7 +10572,8 @@ var Launcher = class {
         ...described,
         started: (this.described.get(root.pid) ?? described).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
-        memory: this.processes.get(member.pid)?.memory() ?? 0
+        memory: this.processes.get(member.pid)?.memory() ?? 0,
+        umask: this.umaskOf(member.pid)
       });
     }
     return listed;
@@ -10574,6 +10595,7 @@ var Launcher = class {
         report,
         ppid,
         ignored: this.ignoredBy(ppid),
+        umask: this.umaskOf(ppid),
         ...exec
       });
       deciding?.attach();
@@ -10618,7 +10640,8 @@ var Launcher = class {
         fds,
         ppid,
         fork: state,
-        ignored: this.ignoredBy(ppid, true)
+        ignored: this.ignoredBy(ppid, true),
+        umask: this.umaskOf(ppid)
       })
     );
   }
@@ -10627,6 +10650,9 @@ var Launcher = class {
     const foreground = () => this.jobs.tcgetpgrp(tty, fallback);
     this.settling.deliver(sig, pgid, send, tty.reading ? void 0 : foreground);
   }
+  umaskOf(pid) {
+    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK;
+  }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
@@ -10873,7 +10899,7 @@ var Launcher = class {
       return { status: NOT_FOUND, stdout: concat5(out), stderr: concat5(err) };
     }
     const fds = new FdTable();
-    fds.installAt(0, options.stdin ? bytesSource(options.stdin) : nullFile());
+    fds.installAt(0, options.stdin ? bytesSource(options.stdin) : deviceFile("null"));
     fds.installAt(1, sinkFile(stdout));
     fds.installAt(2, sinkFile(stderr));
     const group = options.pgid !== void 0 ? { pgid: options.pgid } : {};