@ai-ecoverse/slicc-kernel 1.98.3 → 1.98.4

package/README.md

@@ -261,7 +261,7 @@ An empty path is `ENOENT` in every path call (`path_open`, `path_filestat_get`,
 On top of preview1 a WASI program gets:
 
 - **Threads**: `wasi.thread-spawn` (wasm32-wasip1-threads) and WASIX `thread_spawn_v2` start a worker per thread on the process's shared memory, sized from the module's own import (a 2 GiB maximum when the engine cannot reserve more). The threads share one descriptor table, and a file written, created, renamed or removed in one thread shows its new size and metadata to `stat` in every other thread at once, under any of its names (a symlink, a hard link, a new name after a rename in the same process), also when another thread renames a file over that name meanwhile, since the kernel reports which file an open or a change reached; this holds among the kernel's own processes, not against other tabs, `hostfs` writers or programs that aren't WASI; another process's changes show at close and after a `spawn` or `wait`, as with close-to-open caching, so a file another process renames while this one holds it open may show its old size under the new name until then; `exit` or a trap in any thread ends the process. At most 64 threads per process; `SLICC_WASM_THREADS` sets another cap, up to 256.
-- **WASIX** (a module importing `wasix_32v1`): fork and setjmp/longjmp through Asyncify (the module is built with `wasm-opt --asyncify`), exec, `posix_spawn`, `waitpid` (with `WNOHANG`, and `WUNTRACED` for a child that stops; WASIX has no `WCONTINUED`), pipes, `dup2`, signal handlers and interval timers, terminal modes, and dynamic linking: a position-independent main module loads side modules with `dlopen` from `LD_LIBRARY_PATH`, its runtime path, `/lib`, `/usr/lib` and `/usr/local/lib`. Each thread has its own copy of the function table, so the kernel hands out its slots (a side module's range, a `dlsym`'d function, a closure): threads loading or looking up at the same time never get the same slot. As in glibc, one `dlopen` at a time runs in a process, constructors included: a `dlopen` from a library's constructor goes ahead in its own thread, and another thread's `dlopen` waits, then finds the library loaded and gets the same handle. A thread waiting there still ends or stops with its process, but a signal handler it has runs once that `dlopen` returns. The lock is let go when a `dlopen` fails (an exception, a trap or `pthread_exit` out of a constructor included) and when its thread ends; a forked child starts with it free. A forked child also gets the side modules its parent had loaded, at the same addresses and table slots, with the slot and closure counters and the parent's thread-local blocks: they are linked again in the child before it resumes, without running their constructors again, since their data is already in the copied memory. A side-module function on the stack when `fork` is called (a callback into the main module that forks) is not instrumented by Asyncify, so it runs again when the stack is rewound, in the parent and in the child, and libffi frames there can trap; side modules would need building with Asyncify for that, which the toolchain does not do yet. In such a program, `dlopen(NULL)`, and `dlopen` of the program's own file (also by a path that resolves to it through symlinks), give a handle for the program that is already running (no second copy is loaded); a program that isn't position-independent gets an error from `dlopen(NULL)`, as from any `dlopen`; `dlsym` on it searches the program, then the loaded libraries, and `dlclose` of it does nothing. A function already in the table (the program's own, or a library's) keeps its slot, so `dlsym(handle, "strlen") == strlen`.
+- **WASIX** (a module importing `wasix_32v1`): fork and setjmp/longjmp through Asyncify (the module is built with `wasm-opt --asyncify`), with the unwound frames kept in the unused part of the program's stack, below its stack pointer (for a position-independent program, the stack the kernel's linker gives it), so a fork from deep in the stack leaves the program's data alone, exec, `posix_spawn`, `waitpid` (with `WNOHANG`, and `WUNTRACED` for a child that stops; WASIX has no `WCONTINUED`), pipes, `dup2`, signal handlers and interval timers, terminal modes, and dynamic linking: a position-independent main module loads side modules with `dlopen` from `LD_LIBRARY_PATH`, its runtime path, `/lib`, `/usr/lib` and `/usr/local/lib`. Each thread has its own copy of the function table, so the kernel hands out its slots (a side module's range, a `dlsym`'d function, a closure): threads loading or looking up at the same time never get the same slot. As in glibc, one `dlopen` at a time runs in a process, constructors included: a `dlopen` from a library's constructor goes ahead in its own thread, and another thread's `dlopen` waits, then finds the library loaded and gets the same handle. A thread waiting there still ends or stops with its process, but a signal handler it has runs once that `dlopen` returns. The lock is let go when a `dlopen` fails (an exception, a trap or `pthread_exit` out of a constructor included) and when its thread ends; a forked child starts with it free. A forked child also gets the side modules its parent had loaded, at the same addresses and table slots, with the slot and closure counters and the parent's thread-local blocks: they are linked again in the child before it resumes, without running their constructors again, since their data is already in the copied memory. A side-module function on the stack when `fork` is called (a callback into the main module that forks) is not instrumented by Asyncify, so it runs again when the stack is rewound, in the parent and in the child, and libffi frames there can trap; side modules would need building with Asyncify for that, which the toolchain does not do yet. In such a program, `dlopen(NULL)`, and `dlopen` of the program's own file (also by a path that resolves to it through symlinks), give a handle for the program that is already running (no second copy is loaded); a program that isn't position-independent gets an error from `dlopen(NULL)`, as from any `dlopen`; `dlsym` on it searches the program, then the loaded libraries, and `dlclose` of it does nothing. A function already in the table (the program's own, or a library's) keeps its slot, so `dlsym(handle, "strlen") == strlen`.
 - **epoll and eventfd** (WASIX `epoll_create`, `epoll_ctl`, `epoll_wait` and `fd_event`, which tokio's reactor uses through the WASIX mio fork):
   - **Where they live:** an epoll instance and an eventfd are kernel descriptors, so they survive `dup`, `fork` and `exec` (unless close-on-exec) and are shared by a process's threads.
   - **What epoll watches:** sockets (listening, connecting, connected, loopback and uplink), pipes, terminals, `kernel.run`'s stdin, eventfds and other epoll instances (a cycle of instances is `ELOOP`).
@@ -919,6 +919,20 @@ WASIX_SYSROOT_28=/path/to/wasix-sysroot ./build.sh
 - `wasixcc` (0.4.7, WASIX clang 21.1.2) comes from `PATH`, or is installed by `install-wasixcc.sh` as for `dlfork`.
 - The build is reproducible: `bin/epolltest.wasm` is 78,799 bytes, sha256 `9ff8d336a261ebb9076b5b9c760e9ba50fa17053b1d66ab89cfe05395c8e1deb`.
 
+### `piefork`
+
+A position-independent C program, built like `dlfork` (wasixcc with `WASIXCC_PIC=yes` and legacy exceptions, against `@ai-ecoverse/wasix-sysroot` 2025.9.30-28, then `wasm-opt --asyncify` with `asyncify-imports@wasix_32v1.proc_fork`). It's the fixture of `test/integration/pie-fork.test.mjs` (#708).
+
+What it does:
+1. It recurses 300 frames, each holding stack buffers.
+2. At the bottom it snapshots the first 64 KiB of memory, from address 16, where the linker puts its data, and forks.
+3. Parent and child then compare that memory with the snapshot and scribble 64 KiB of stack.
+4. On the way back up, each frame checks its own buffers.
+
+Each side prints `pattern` (a static array's damage), `low` (bytes of low memory changed) and `frames` (damaged frames).
+
+**Build:** `WASIX_SYSROOT_28=/path/to/wasix-sysroot ./build.sh`, with `wasixcc` 0.4.7 and binaryen's `wasm-opt` (version 132) on `PATH`. `bin/piefork.wasm` is 823,983 bytes, sha256 `0477598c71b02356145d1725548ee0f2b9e53ca0d43c7349f17acc2ff12b59f8`.
+
 ## License
 
 Apache-2.0

package/dist/kernel-worker.js

@@ -12082,7 +12082,7 @@ var PATH_OPS = new Set(SYNC_FS_OPS);
 var EARLY_WHOLE_FILE = 64 * 1024;
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.98.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.98.4" : "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

@@ -4591,7 +4591,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.98.3" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.98.4" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -13276,16 +13276,18 @@ function mutableGlobals(exports) {
   }
   return out;
 }
-var UNWINDING, REWINDING, AsyncifyDriver;
+var STACK_POINTER, UNWINDING, REWINDING, AsyncifyDriver;
 var init_wasix_fork = __esm({
   "src/process/wasi/wasix-fork.ts"() {
     "use strict";
     init_wasi_abi();
+    STACK_POINTER = "__stack_pointer";
     UNWINDING = 1;
     REWINDING = 2;
     AsyncifyDriver = class {
       exports = {};
       stackUpper = 0;
+      linked;
       pending;
       answer = 0;
       snapshots = /* @__PURE__ */ new Map();
@@ -13294,10 +13296,12 @@ var init_wasix_fork = __esm({
       constructor(mem) {
         this.mem = mem;
       }
+      useStack(pointer, low) {
+        this.linked = { pointer, low };
+      }
       bind(exports) {
         this.exports = exports;
-        const sp = this.exports.__stack_pointer;
-        this.stackUpper = sp instanceof WebAssembly.Global ? sp.value : 0;
+        this.stackUpper = this.stackPointer();
       }
       get supported() {
         return typeof this.exports.asyncify_start_unwind === "function";
@@ -13332,7 +13336,7 @@ var init_wasix_fork = __esm({
       }
       fork(fork) {
         const sp = this.stackPointer();
-        const globals = mutableGlobals(this.exports);
+        const globals = this.globals();
         return this.unwind((data) => {
           this.answer = fork(data, globals, sp);
         });
@@ -13343,7 +13347,7 @@ var init_wasix_fork = __esm({
         v.setBigUint64(snapPtr, BigInt(retPtr), true);
         v.setBigUint64(snapPtr + 8, BigInt(id), true);
         v.setBigUint64(snapPtr + 16, 0x51cc5117n, true);
-        const globals = mutableGlobals(this.exports);
+        const globals = this.globals();
         return this.unwind((data) => {
           const end = this.mem.view().getUint32(data, true);
           this.snapshots.set(id, { frames: this.mem.bytes(data + 8, end - data - 8).slice(), globals });
@@ -13361,11 +13365,24 @@ var init_wasix_fork = __esm({
           this.answer = Number(val) || 1;
         });
       }
+      stackGlobal() {
+        const g = this.exports[STACK_POINTER];
+        return g instanceof WebAssembly.Global ? g : this.linked?.pointer;
+      }
       stackPointer() {
-        const g = this.exports.__stack_pointer;
-        return g instanceof WebAssembly.Global ? g.value : 0;
+        return this.stackGlobal()?.value ?? 0;
+      }
+      globals() {
+        const out = mutableGlobals(this.exports);
+        if (this.linked && !out.some(([name2]) => name2 === STACK_POINTER)) {
+          out.push([STACK_POINTER, this.linked.pointer.value]);
+        }
+        return out;
       }
       dataPointer() {
+        if (this.linked && !(this.exports[STACK_POINTER] instanceof WebAssembly.Global)) {
+          return this.linked.low + 15 & ~15;
+        }
         const g = this.exports.__data_end;
         const dataEnd = g instanceof WebAssembly.Global ? g.value : 0;
         return dataEnd < this.stackUpper ? dataEnd + 15 & ~15 : 16;
@@ -13385,7 +13402,7 @@ var init_wasix_fork = __esm({
       }
       restoreGlobals(globals) {
         for (const [name2, value2] of globals) {
-          const g = this.exports[name2];
+          const g = name2 === STACK_POINTER ? this.stackGlobal() : this.exports[name2];
           if (g instanceof WebAssembly.Global) g.value = value2;
         }
       }
@@ -15135,6 +15152,7 @@ async function instantiate(host, module, memory, threads, {
     }
   }
   if (sync) bindLinker(host, sync, instance, { thread, forked, path });
+  if (sync && !thread) driver.useStack(sync.linker.stackPointer, sync.linker.stackLow);
   return { instance, driver };
 }
 function bindLinker(host, sync, instance, at) {