@ai-ecoverse/slicc-kernel 1.42.3 → 1.43.1

package/dist/process-worker.js

@@ -3237,10 +3237,12 @@ var init_process_signals = __esm({
         }
         if (!masks) return;
         this.restart = masks.restart;
-        const { caught, ignored } = masks;
-        if (caught === this.reported.caught && ignored === this.reported.ignored) return;
+        const { caught, ignored, defaults = 0 } = masks;
+        const same = caught === this.reported.caught && ignored === this.reported.ignored;
+        if (same && defaults === 0) return;
         this.reported = { caught, ignored };
-        this.raw.call({ op: "sig-mask", caught, ignored }, Number.POSITIVE_INFINITY, "sig-mask");
+        const req = { op: "sig-mask", caught, ignored, ...defaults ? { defaults } : {} };
+        this.raw.call(req, Number.POSITIVE_INFINITY, "sig-mask");
       }
       quiet(fn) {
         this.quieted++;
@@ -3518,8 +3520,8 @@ function pidStatus(info) {
     "SigPnd:	0000000000000000",
     "ShdPnd:	0000000000000000",
     "SigBlk:	0000000000000000",
-    "SigIgn:	0000000000000000",
-    "SigCgt:	0000000000000000",
+    `SigIgn:	${sigMask(info.sigIgn)}`,
+    `SigCgt:	${sigMask(info.sigCgt)}`,
     ""
   ].join("\n");
 }
@@ -3724,7 +3726,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     readdir: (node) => pidNames(selfReaddir ? selfReaddir(node) : [".", ".."])
   };
 }
-var HZ, DIR_MODE2, FILE_MODE, LINK_MODE2, ENOENT, ESRCH, EINVAL, UID, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES;
+var HZ, DIR_MODE2, FILE_MODE, LINK_MODE2, ENOENT, ESRCH, EINVAL, UID, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES, sigMask;
 var init_procfs = __esm({
   "src/process/procfs.ts"() {
     "use strict";
@@ -3741,6 +3743,7 @@ var init_procfs = __esm({
     FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
     PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
     SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+    sigMask = (mask = 0) => (mask >>> 1).toString(16).padStart(16, "0");
   }
 });
 
@@ -5481,6 +5484,7 @@ var init_wasi_host = __esm({
       interruptWakes = false;
       onRaise;
       muted;
+      signals;
       listening;
       o;
       constructor(o) {
@@ -5562,7 +5566,8 @@ var init_wasi_host = __esm({
             flags,
             data: mem.string(dp, dl)
           }),
-          umount2: (tp, tl, flags) => void this.o.kernel.call({ op: "umount", target: path(tp, tl), flags })
+          umount2: (tp, tl, flags) => void this.o.kernel.call({ op: "umount", target: path(tp, tl), flags }),
+          sigaction_set: (sig, disposition, flags) => this.signals ? this.signals.disposition(sig, disposition, flags) : E.NOSYS
         });
       }
       imports() {
@@ -6225,14 +6230,20 @@ var init_wasi_module = __esm({
 });
 
 // src/process/wasi/wasi-signals.ts
-var DELIVERED_MASK, LIBC_DEFAULT_EXIT, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
+var DELIVERED_MASK, STOP_DEFAULTS, LIBC_DEFAULT_EXIT, SA_RESTART, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
   "src/process/wasi/wasi-signals.ts"() {
     "use strict";
     init_signals();
+    init_wasi_abi();
     init_wasi_host();
     DELIVERED_MASK = Object.values(SIG).filter((sig) => sig !== SIG.KILL && sig !== SIG.STOP).reduce((m, sig) => m | sigbit(sig), 0);
+    STOP_DEFAULTS = sigbit(SIG.TSTP) | sigbit(SIG.TTIN) | sigbit(SIG.TTOU);
     LIBC_DEFAULT_EXIT = 127;
+    SA_RESTART = 268435456;
+    DISPOSITION_IGNORE = 1;
+    DISPOSITION_HANDLER = 2;
+    withBit = (mask, bit, on) => on ? mask | bit : mask & ~bit;
     WASIX_LIBC_DEFAULT_LINE = /^Program recieved (?:stop|termination|fatal) signal: [^\n]+\n$/;
     WasiSignals = class {
       exports;
@@ -6241,6 +6252,11 @@ var init_wasi_signals = __esm({
       delivering;
       defaulted = false;
       libcDefault = false;
+      hooked = false;
+      handlers = 0;
+      ignoring = 0;
+      restarting = 0;
+      defaults = 0;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -6256,9 +6272,45 @@ var init_wasi_signals = __esm({
       register(name) {
         if (typeof this.exports?.[name] === "function") this.callback = name;
       }
+      useHook() {
+        this.hooked = true;
+      }
+      disposition(sig, disposition, flags) {
+        if (sig < 1 || sig > 31 || (DELIVERED_MASK & sigbit(sig)) === 0) return E.INVAL;
+        const bit = sigbit(sig);
+        this.handlers = withBit(this.handlers, bit, disposition === DISPOSITION_HANDLER);
+        this.ignoring = withBit(this.ignoring, bit, disposition === DISPOSITION_IGNORE);
+        this.restarting = withBit(this.restarting, bit, (flags & SA_RESTART) !== 0);
+        this.defaults = withBit(this.defaults, bit, disposition === 0);
+        return E.SUCCESS;
+      }
+      snapshot() {
+        return {
+          ...this.callback ? { callback: this.callback } : {},
+          ...this.hooked ? { hooked: true } : {},
+          handlers: this.handlers,
+          ignoring: this.ignoring,
+          restarting: this.restarting,
+          uncaught: this.uncaught
+        };
+      }
+      restore(state) {
+        if (state.callback) this.register(state.callback);
+        if (state.hooked) this.hooked = true;
+        this.handlers = state.handlers;
+        this.ignoring = state.ignoring;
+        this.restarting = state.restarting;
+        this.uncaught = state.uncaught;
+      }
       masks() {
+        if (this.hooked) {
+          const caught = this.handler() ? this.handlers : 0;
+          const defaults = this.defaults;
+          this.defaults = 0;
+          return { caught, ignored: this.ignoring, restart: this.restarting, defaults };
+        }
         if (!this.handler()) return null;
-        return { caught: DELIVERED_MASK & ~this.uncaught, ignored: 0, restart: 0 };
+        return { caught: DELIVERED_MASK & ~this.uncaught & ~STOP_DEFAULTS, ignored: 0, restart: 0 };
       }
       raise(sig) {
         const handler = this.handler();
@@ -7100,7 +7152,8 @@ var init_wasix_process = __esm({
             cloexec: [...fds.cloexec],
             cwd: this.host.cwd,
             ...fds.isShared ? { shared: true } : {},
-            setjmps: this.driver.setjmps()
+            setjmps: this.driver.setjmps(),
+            ...this.host.signals ? { signals: this.host.signals.snapshot() } : {}
           };
           return this.call({
             op: "proc-fork",
@@ -8133,6 +8186,9 @@ async function runWasiProcess(init, port2) {
   main.memory = memoryOf(instance, memory);
   publishMemory(init.sab, sizeOf(main)());
   signals.bind(instance.exports);
+  if (importsSigactionHook(module)) signals.useHook();
+  if (fork?.signals) signals.restore(fork.signals);
+  host.signals = signals;
   host.onRaise = (sig) => signals.raised(sig);
   host.muted = (fd, data) => signals.muted(fd, data);
   const exports = instance.exports;
@@ -8229,7 +8285,7 @@ async function runWasiThread(init, port2) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, SLICC_FS, RESERVED2, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SLICC_FS, RESERVED2, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -8258,6 +8314,7 @@ var init_wasi_runtime = __esm({
     SLICC = "slicc";
     SLICC_FS = "slicc_fs";
     RESERVED2 = RESERVED_NAMESPACES;
+    importsSigactionHook = (module) => WebAssembly.Module.imports(module).some((i) => i.module === SLICC && i.name === "sigaction_set");
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
     FALLBACK_MAXIMUM_PAGES = 32768;
     LinkSync = class {
@@ -8841,9 +8898,11 @@ function netOps(kernel, io) {
     connect: async (options) => {
       const signal = options.signal ?? NEVER;
       signal.throwIfAborted();
+      const host = options.host ?? "127.0.0.1";
+      if (host.includes(":")) throw new JsCallError("EADDRNOTAVAIL", host);
       const addr = {
         family: "inet",
-        host: await resolve(options.host, signal),
+        host: await resolve(host, signal),
         port: port(options.port)
       };
       return opened(async (fd) => {