@ai-ecoverse/slicc-kernel 1.42.3 → 1.43.0

package/README.md

@@ -174,6 +174,7 @@ 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; `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`, 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`.
+- **Job control:** `^Z`, `SIGTSTP`, `SIGTTIN` and `SIGTTOU` stop a WASIX program at once, unless it has a handler for them. A stopped program that is busy computing is stopped for job control (`jobs` shows it, `fg`, `bg` and `SIGCONT` work), but its worker keeps a core busy until its next system call, since a worker's running code cannot be frozen from outside. Agents should `kill` such a job rather than leave it stopped.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream pair, `bind`, `listen`, `connect`, `accept`, options, local and peer names) are the kernel's loopback sockets, and preview1's `sock_recv` / `sock_send` / `sock_shutdown` work on them and on inherited ones. Writing to a socket whose peer is gone fails with `EPIPE`, through `fd_write` as through `sock_send`, as if `MSG_NOSIGNAL` were set, since a WASI program cannot ignore `SIGPIPE`; a pipe or terminal whose reader is gone still ends the program with status 141. HTTP and HTTPS leave through the realm proxy that `https_proxy` names, as for any other program; `resolve` answers `/etc/hosts` names and literal addresses, and the [uplink](#uplink)'s names.
 - **Diagnostics**: a trap ends the program with 134 and its message on stderr; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
 

package/dist/kernel-worker.js

@@ -9014,7 +9014,10 @@ var WasmProcess = class {
     this.children.onReap = options.onReap;
   }
   ignores(bit) {
-    return ((this.ignored | this.inherited & ~this.caught) & bit) !== 0;
+    return (this.signalMasks().ignored & bit) !== 0;
+  }
+  signalMasks() {
+    return { ignored: this.ignored | this.inherited & ~this.caught, caught: this.caught };
   }
   inheritable(fork = false) {
     return ((fork ? 0 : this.ignored) | this.inherited) & ~this.caught;
@@ -9895,6 +9898,7 @@ function spawnWasmProcess(opts) {
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header2, SAB_I_MEMORY) * 65536,
     ignoredSignals: (fork) => process.inheritable(fork),
+    signalMasks: () => process.signalMasks(),
     umask: () => process.umask,
     writesBack: () => opts.program.abi === "wasi" && !done4
   };
@@ -11782,7 +11786,8 @@ var Launcher = class {
         started: (this.described.get(root.pid) ?? described).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
         memory: this.processes.get(member.pid)?.memory() ?? 0,
-        umask: this.umaskOf(member.pid)
+        umask: this.umaskOf(member.pid),
+        ...this.signalMasksOf(member.pid)
       });
     }
     return listed;
@@ -11868,6 +11873,10 @@ var Launcher = class {
     const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open) void this.mounts.commit(at).catch(() => void 0);
   }
+  signalMasksOf(pid) {
+    const masks = this.processes.get(pid)?.signalMasks?.();
+    return masks ? { sigIgn: masks.ignored, sigCgt: masks.caught } : {};
+  }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }