@ai-ecoverse/slicc-kernel 1.108.0 → 1.108.2

package/README.md

@@ -322,7 +322,7 @@ A WASI command can name an ES module of its package that provides imports of its
 
 - `memory()`, `instance()` (after instantiation), `tid` (1 for the main thread), `argv`, `env`, `cwd()`;
 - `fs`: the synchronous filesystem the WASI calls use (absolute paths);
-- `fds`: `open(path, { read, write, append, create, exclusive, truncate, directory, nofollow, mode })` returns a WASI descriptor of the program; `close`, `fstat` (`{ kind, path, mode, uid, gid, size, ino, mtimeMs }`), `fchmod`, and `tryLock(fd, exclusive)` / `unlock(fd)`: advisory locks held by the kernel across processes and threads, keyed by path, released on unlock, on closing the descriptor and at exit (`tryLock` returns 0, or 6 when another process holds the lock);
+- `fds`: `open(path, { read, write, append, create, exclusive, truncate, directory, nofollow, mode })` returns a WASI descriptor of the program; `mode` is a new file's mode. With `create` and `exclusive` under users `report` or `enforce`, the file is created with it, less the umask, as `open(2)` does, and the name is only checked by the create itself (a symlink there is `EEXIST`). Otherwise the mode is set exactly once the file is open; `close`, `fstat` (`{ kind, path, mode, uid, gid, size, ino, mtimeMs }`), `fchmod`, and `tryLock(fd, exclusive)` / `unlock(fd)`: advisory locks held by the kernel across processes and threads, keyed by path, released on unlock, on closing the descriptor and at exit (`tryLock` returns 0, or 6 when another process holds the lock);
 - `syscall(req)`: a kernel syscall, synchronously;
 - `net.connect({ host, port, nonblock })` connects a TCP socket to the kernel's loopback and returns its kernel descriptor. `host` is `localhost` or `127.x.y.z`; anything else, or a port outside 1–65535, is `EINVAL`. A refused connection throws `ECONNREFUSED`. The connection carries the program's own identity, as any connect from its process does, so a [page facade](#page-facades) such as `SLICC_LINK_URL` sees the program's stamp. With `nonblock` it returns at once, and `net.ready(fd)` answers 0 once a connect is complete, `EINPROGRESS` (26) while it isn't, or the connect's WASI errno (`SO_ERROR`). On the loopback a connect completes at once, so `ready` is 0 straight away. `ready` is meant for a descriptor from `net.connect`. The descriptor is read and written with `fd-read` and `fd-write` and closed with `fd-close`, as below, and `fd-select` (`{ op: 'fd-select', read: [fds], write: [fds], timeoutMs }`, answering `{ read, write }` with the ready ones; `timeoutMs: -1` waits without a limit) waits until it's readable or writable;
 - `spawn({ argv, env, cwd, stdin, stdout, stderr })` starts a command (resolved like `kernel.run`) as a child and returns `{ pid, stdin, stdout, stderr }`. `env` is the child's whole environment (the program's own by default), `cwd` the program's by default. Each stdio is `'inherit'` (the default: the program's own), `'null'`, or `'pipe'`: a kernel pipe whose end the result holds as a descriptor, read and written with `fd-read` (`{ op: 'fd-read', fd, max }`, an empty read at the end), `fd-write` (`{ op: 'fd-write', fd, body }`) and `fd-close`, through `syscall` or `async.submit`; the child's ends are closed in the program. A command that does not exist throws `ENOENT`;
@@ -922,7 +922,7 @@ The Biome, TypeScript, lefthook, Renovate and CI configuration comes from [slicc
 
 `tools/big-file.mjs [bytes]` is a manual check, not part of any suite. It writes a file of that size (64 MiB by default) through a tmpfs mount with the unit-test launcher, reads it back, and prints the peak RSS and its ratio to the file size. A 256 MiB file peaks at about 1.8 times its size. Before ranged I/O (#127), a 1.1 GiB file peaked at 18 GB of RSS. **Do not run it past 1 GiB on a workstation.** It refuses anything over 256 MiB unless `SLICC_BIG_FILE_I_HAVE_THE_RAM=1` is set. Measure a small file and extrapolate instead. The unit suite checks a 32 MiB file the same way, and allows a fixed 192 MiB for garbage V8 has yet to collect, which dominates at that size.
 
-Releases are cut by semantic-release on every push to `main`, in two jobs, and only on `main`. The first job runs on the bench pool, so it starts within a minute of the push, before `main` has moved on. It computes the version, tags the commit and creates the GitHub release, with `npmPublish: false`. A run that starts after `main` has moved skips; the run for the newer commit releases it. The second job runs on a GitHub-hosted runner, because npm's trusted publishing and provenance accept no self-hosted runner. It publishes the tagged commit with `tools/release-recover.mjs`. However long it waits for a runner, it publishes exactly the commit the run started on, so the provenance, the tag and the package's `gitHead` agree. For any version tagged at HEAD, `tools/release-recover.mjs` pushes the tag if origin lacks it, publishes the version if npm lacks it (with retries), and creates its GitHub release if that is missing too. So a failure after the version is tagged (a rejected push, a failed `npm publish`) doesn't strand it, and re-running the Release workflow completes it the same way.
+Releases are cut by semantic-release on every push to `main`, in two jobs, and only on `main`. The first job runs on the bench pool, so it starts within a minute of the push, before `main` has moved on. It computes the version, tags the commit and creates the GitHub release, with `npmPublish: false`. A run that starts after `main` has moved skips; the run for the newer commit releases it. The second job runs on a GitHub-hosted runner, because npm's trusted publishing and provenance accept no self-hosted runner. It publishes the tagged commit with `tools/release-recover.mjs`. However long it waits for a runner, it publishes exactly the commit the run started on, so the provenance, the tag and the package's `gitHead` agree. For any version tagged at HEAD, `tools/release-recover.mjs` pushes the tag if origin lacks it, publishes the version if npm lacks it (with retries) and it is newer than npm's `latest` (an older one stays unpublished, so `latest` never moves back to it, and an `npm view` error fails the job instead of guessing; #837), and creates its GitHub release if that is missing too. So a failure after the version is tagged (a rejected push, a failed `npm publish`) doesn't strand it, and re-running the Release workflow completes it the same way.
 
 ### Certification (`cert-review`)
 
@@ -1084,9 +1084,9 @@ A threaded WASIX C program for `test/integration/thread-signal.test.mjs` (#520).
 
 A WASIX C program for `test/integration/long-timers.test.mjs` (#767).
 - `longwait alarm` sets `alarm(3000000)` (about 35 days), sleeps 0.5 s, and prints how many alarms came and how many seconds were left.
-- `longwait select|ppoll|nanosleep` waits 3,000,000 s on a pipe that never gets data, until a 300 ms interval timer interrupts the wait.
+- `longwait select|ppoll|nanosleep` waits 3,000,000 s on a pipe that never gets data, until a 300 ms interval timer interrupts the wait, and prints `not before it` when the wait lasted at least 300 ms (`early` otherwise). It sets no upper bound, so a loaded CI host can't fail the row; a wait that never ends times the test out.
 
-**Build:** `WASIX_SYSROOT_28=/path/to/wasix-sysroot ./build.sh`, with `wasixcc` 0.4.7 and binaryen's `wasm-opt` on `PATH`. `bin/longwait.wasm` is 44,010 bytes, sha256 `70ae2adfb46864fad3af0241fe26f401a62a5176ccd25ab82fe6588178cfb5c8`.
+**Build:** `WASIX_SYSROOT_28=/path/to/wasix-sysroot ./build.sh`, with `wasixcc` 0.4.7 and binaryen's `wasm-opt` on `PATH`. `bin/longwait.wasm` is 44,004 bytes, sha256 `e69d03f01479693666078297e781f5373719700c8534d1f2933749f5b3cee903`.
 
 ### `epollmask`
 

package/dist/kernel-worker.js

@@ -7985,7 +7985,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.108.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.108.2" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC

package/dist/node-process-worker.js

@@ -2497,7 +2497,7 @@ var init_wasi_fds = __esm({
         const flags = want === 6 ? O_RDWR : want === 2 ? O_WRONLY : 0;
         return openDevice2.call(this.kernel.sys, flags);
       }
-      open(path, oflags, rights, fdflags) {
+      open(path, oflags, rights, fdflags, mode) {
         const device2 = deviceOf(path);
         if (device2) return this.install({ type: "device", device: device2 });
         const kernelDevice = this.openKernelDevice(path, oflags, fdflags, rights);
@@ -2518,13 +2518,16 @@ var init_wasi_fds = __esm({
         }
         if (!s && !(oflags & OFLAGS.CREAT)) throw new WasiError("ENOENT");
         refuseWrite(s, oflags, rights);
-        return this.regular(path, s, oflags, rights, fdflags);
+        return this.regular(path, s, oflags, rights, fdflags, mode);
       }
-      regular(path, s, oflags, rights, fdflags) {
+      regular(path, s, oflags, rights, fdflags, mode) {
         if (this.shared || this.kernelHolds(path, s)) {
-          return this.kernelFile(path, s, oflags, rights, fdflags);
+          return this.kernelFile(path, s, oflags, rights, fdflags, mode);
         }
-        return this.install({ type: "file", file: this.file(path, s, oflags, rights, fdflags) });
+        return this.install({
+          type: "file",
+          file: this.file(path, s, oflags, rights, fdflags, mode)
+        });
       }
       kernelHolds(path, st) {
         for (const [fd, e] of this.table) {
@@ -2546,7 +2549,7 @@ var init_wasi_fds = __esm({
         } catch {
         }
       }
-      file(path, existing, oflags, rights, fdflags) {
+      file(path, existing, oflags, rights, fdflags, mode) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         let buffer = this.buffers.get(path);
         if (buffer?.handle !== void 0 && this.fs.kept?.(buffer.handle)) {
@@ -2559,13 +2562,13 @@ var init_wasi_fds = __esm({
           if (this.fs.owners) this.fs.access?.(path, want, "open");
           if (oflags & OFLAGS.TRUNC) buffer.truncate(0);
         } else {
-          buffer = this.freshBuffer(path, existing, oflags, want);
+          buffer = this.freshBuffer(path, existing, oflags, want, mode);
         }
         buffer.opens++;
         return new LocalFile(buffer, readable3, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
       }
-      freshBuffer(path, existing, oflags, want) {
-        const made = !existing && this.createNew(path, oflags);
+      freshBuffer(path, existing, oflags, want, mode) {
+        const made = !existing && this.createNew(path, oflags, mode);
         const empty = made || (oflags & OFLAGS.TRUNC) !== 0;
         if (existing?.ranged) this.fs.invalidate?.();
         const seen = this.fs.changes?.now();
@@ -2595,11 +2598,11 @@ var init_wasi_fds = __esm({
         if (id !== void 0) this.know(buffer, id);
         return buffer;
       }
-      kernelFile(path, existing, oflags, rights, fdflags) {
+      kernelFile(path, existing, oflags, rights, fdflags, mode) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         const append = (fdflags & FDFLAGS.APPEND) !== 0;
         const flags = (writable2 ? readable3 ? O_RDWR : O_WRONLY : 0) | (append ? O_APPEND : 0);
-        const made = !existing && this.createNew(path, oflags);
+        const made = !existing && this.createNew(path, oflags, mode);
         const truncate = made || (oflags & OFLAGS.TRUNC) !== 0;
         const fd = this.kernel.sys.openVfs(path, flags, 0, {
           ...truncate ? { truncate } : {},
@@ -2612,13 +2615,13 @@ var init_wasi_fds = __esm({
         this.bump();
         return fd;
       }
-      createNew(path, oflags) {
+      createNew(path, oflags, mode) {
         if (!this.fs.create) {
           this.fs.writeFile(path, new Uint8Array(0));
           return true;
         }
         try {
-          this.fs.create(path, void 0, true);
+          this.fs.create(path, mode, true);
           return true;
         } catch (err) {
           if (oflags & OFLAGS.EXCL || err.code !== "EEXIST") throw err;
@@ -4897,13 +4900,15 @@ function importsContext({
   const fds = {
     open(path, o = {}) {
       const abs = host.fds.resolve(3, path);
-      if (o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
+      const fresh = o.create === true && o.exclusive === true && owners && fs.create !== void 0;
+      if (!fresh && o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
         throw new WasiError("ELOOP");
-      const existed = fs.exists(abs);
+      const existed = !fresh && fs.exists(abs);
       const oflags = (o.create ? OFLAGS.CREAT : 0) | (o.exclusive ? OFLAGS.EXCL : 0) | (o.truncate ? OFLAGS.TRUNC : 0) | (o.directory ? OFLAGS.DIRECTORY : 0);
       const rights = (o.write ? RIGHTS.FD_WRITE : 0n) | (o.read || !o.write ? RIGHTS.FD_READ : 0n);
-      const fd = host.fds.open(abs, oflags, rights, o.append ? FDFLAGS.APPEND : 0);
-      if (o.mode !== void 0 && !existed) fs.chmod(abs, o.mode);
+      const flags = o.append ? FDFLAGS.APPEND : 0;
+      const fd = host.fds.open(abs, oflags, rights, flags, fresh ? o.mode : void 0);
+      if (o.mode !== void 0 && !existed && !fresh) fs.chmod(abs, o.mode);
       return fd;
     },
     close(fd) {
@@ -5167,7 +5172,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.108.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.108.2" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });