@ai-ecoverse/slicc-kernel 1.46.0 → 1.47.0

package/dist/kernel-worker.js

@@ -9419,6 +9419,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-captured",
   "proc-fork",
   "proc-kill",
+  "thread-kill",
   "proc-list",
   "mount-list",
   "mount",
@@ -9583,14 +9584,14 @@ var WasmProcess = class {
       if (isFdSyscall(req)) return await this.fdSyscall(req, cancelled);
       if (isTtySyscall(req)) return this.ttySyscall(req);
       if (isJobSyscall(req)) return this.jobSyscall(req);
-      if (isSocketSyscall(req)) return await this.socketSyscall(req);
+      if (isSocketSyscall(req)) return await this.socketSyscall(req, cancelled);
       if (isHttpSyscall(req)) return await this.httpSyscall(req);
       if (isHostSyscall(req)) {
         return await hostSyscall(req, {
           pid: this.pid,
           locks: this.options.locks,
           ops: this.asyncOps,
-          blocking: () => this.blockingSignal(),
+          blocking: () => this.blockingSignal(cancelled),
           valid: (inner) => isWasmSyscall(inner) && !isHostSyscall(inner)
         });
       }
@@ -9598,7 +9599,7 @@ var WasmProcess = class {
         const { ptys, jobs } = this.options;
         return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs });
       }
-      return await this.procSyscall(req);
+      return await this.procSyscall(req, cancelled);
     } catch (e) {
       if (e instanceof KernelError || e instanceof SpawnError) {
         return { ok: false, errno: e.code, message: e.code };
@@ -9613,11 +9614,11 @@ var WasmProcess = class {
   refuseIfPending(restart) {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
-  blockingSignal() {
-    if (this.options.hasPending?.()) throw new KernelError("EINTR");
-    return this.interrupt.signal;
+  blockingSignal(cancelled) {
+    if (this.options.hasPending?.() || cancelled?.aborted) throw new KernelError("EINTR");
+    return cancelled ? AbortSignal.any([this.interrupt.signal, cancelled]) : this.interrupt.signal;
   }
-  async read(req) {
+  async read(req, cancelled) {
     const file = this.fds.get(req.fd).file;
     const read = req.peek ? file.peek : file.read;
     if (!read) throw new KernelError(req.peek && file.read ? "EOPNOTSUPP" : "EBADF");
@@ -9626,15 +9627,15 @@ var WasmProcess = class {
     if (file instanceof KernelSocket && file.unconnected) throw new KernelError("ENOTCONN");
     const ready2 = pollFile(file).readable;
     if (!ready2 && req.nonblock) throw new KernelError("EAGAIN");
-    const signal = ready2 ? this.interrupt.signal : this.blockingSignal();
+    const signal = ready2 ? this.interrupt.signal : this.blockingSignal(cancelled);
     return read.call(file, Math.max(0, Math.min(req.max, MAX_READ)), signal);
   }
-  async write(fd, body, nonblock = false) {
+  async write(fd, body, nonblock = false, cancelled) {
     const file = this.fds.get(fd).file;
     if (!file.write) throw new KernelError("EBADF");
     if (!pollFile(file).writable) {
       if (nonblock) throw new KernelError("EAGAIN");
-      return file.write(body, this.blockingSignal());
+      return file.write(body, this.blockingSignal(cancelled));
     }
     if (nonblock) return file.write(body, AbortSignal.abort());
     return file.write(
@@ -9689,9 +9690,13 @@ var WasmProcess = class {
     if (isVfsSyscall(req)) return this.vfsSyscall(req);
     switch (req.op) {
       case "fd-read":
-        return { ok: true, kind: "bytes", bytes: await this.read(req) };
+        return { ok: true, kind: "bytes", bytes: await this.read(req, cancelled) };
       case "fd-write":
-        return { ok: true, kind: "json", json: await this.write(req.fd, req.body, req.nonblock) };
+        return {
+          ok: true,
+          kind: "json",
+          json: await this.write(req.fd, req.body, req.nonblock, cancelled)
+        };
       case "fd-close":
         this.options.locks?.closed(this.pid, req.fd);
         await Promise.resolve(this.fds.close(req.fd));
@@ -9756,8 +9761,7 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
-        const blocking = this.blockingSignal();
-        const signal = cancelled ? AbortSignal.any([blocking, cancelled]) : blocking;
+        const signal = this.blockingSignal(cancelled);
         const selected = await selectFds(this.fds, read, write, timeoutMs, signal);
         return { ok: true, kind: "json", json: selected };
       }
@@ -9927,13 +9931,13 @@ var WasmProcess = class {
     if (!http) return Promise.resolve({ ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT });
     return http.syscall(req);
   }
-  socketSyscall(req) {
+  socketSyscall(req, cancelled) {
     this.net ??= this.options.net ?? new LoopbackNet();
     const resolver = this.options.resolver ?? HOSTS_ONLY;
     return socketSyscall(req, {
       fds: this.fds,
       net: this.net,
-      blocking: () => this.blockingSignal(),
+      blocking: () => this.blockingSignal(cancelled),
       resolve: (name2, family, blocking) => resolver.resolve(name2, family, blocking)
     });
   }
@@ -9943,7 +9947,7 @@ var WasmProcess = class {
     if (!tty) throw new KernelError("ENOTTY");
     return tty;
   }
-  async procSyscall(req) {
+  async procSyscall(req, cancelled) {
     switch (req.op) {
       case "proc-fork":
         this.refuseIfPending(req.restart);
@@ -9952,7 +9956,7 @@ var WasmProcess = class {
         this.refuseIfPending(req.restart);
         return { ok: true, kind: "json", json: await this.spawn(req) };
       case "proc-wait": {
-        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal();
+        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
         const flags = {
           untraced: req.untraced,
           continued: req.continued,
@@ -10012,7 +10016,10 @@ var WasmProcess = class {
         this.inherited &= ~(req.defaults ?? 0);
         return { ok: true, kind: "void" };
       case "sig-pause":
-        return this.pause();
+        return this.pause(cancelled);
+      case "thread-kill":
+        if (!this.options.threadKill?.(req.tid, req.sig)) this.options.raise?.(req.sig);
+        return { ok: true, kind: "void" };
       case "proc-captured":
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
     }
@@ -10034,8 +10041,8 @@ var WasmProcess = class {
     }
     return { ok: true, kind: "void" };
   }
-  pause() {
-    return aborted(this.blockingSignal());
+  pause(cancelled) {
+    return aborted(this.blockingSignal(cancelled));
   }
   alarm;
   dlLog = [];
@@ -10152,6 +10159,18 @@ var Dying = class {
     return [typeof reported === "number" ? reported : CRASHED, void 0];
   }
 };
+function killThread(thread, caught, sig) {
+  if (!thread || (caught & sigbit(sig)) === 0) return false;
+  Atomics.or(thread.header, SAB_I_SIGNALS, sigbit(sig));
+  Atomics.notify(thread.header, SAB_I_SIGNALS);
+  const blocked = thread.interrupt;
+  thread.interrupt = new AbortController();
+  blocked.abort();
+  return true;
+}
+function threadCancel(thread) {
+  return Atomics.load(thread.header, SAB_I_SIGNALS) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
+}
 function notifiers(header2) {
   return {
     onPending(sig) {
@@ -10234,10 +10253,8 @@ function holdingToken(opts, holds) {
     renamed: (from, to) => holds.renamed(from, to)
   });
 }
-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, {
+function processOptions(opts, header2, hooks) {
+  return {
     ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
@@ -10262,9 +10279,23 @@ function spawnWasmProcess(opts) {
     ...notifiers(header2),
     onTimer: (which) => void Atomics.or(header2, SAB_I_TIMERS, 1 << which),
     hasPending: () => Atomics.load(header2, SAB_I_SIGNALS) !== 0 || Atomics.load(header2, SAB_I_TIMERS) !== 0,
-    raise: (sig) => signal(sig),
+    raise: hooks.raise,
+    threadKill: hooks.threadKill,
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header2, SAB_I_SIGNALS) } : {}
-  });
+  };
+}
+function spawnWasmProcess(opts) {
+  const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
+  const header2 = new Int32Array(sab, 0, SAB_HEADER_I32);
+  const threadSignals = /* @__PURE__ */ new Map();
+  const process = new WasmProcess(
+    opts.pid,
+    opts.fds,
+    processOptions(opts, header2, {
+      raise: (sig) => signal(sig),
+      threadKill: (tid, sig) => killThread(threadSignals.get(tid), process.signalMasks().caught, sig)
+    })
+  );
   publishStops(process, header2);
   const holds = new HeldPaths();
   opts.held?.add(holds);
@@ -10331,7 +10362,15 @@ function spawnWasmProcess(opts) {
     }
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
-    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: dispatch2 });
+    const tsignals = {
+      header: new Int32Array(tsab, 0, SAB_HEADER_I32),
+      interrupt: new AbortController()
+    };
+    threadSignals.set(thread.tid, tsignals);
+    const tdispatch = (req) => dying.serving(
+      () => isWasmSyscall(req) ? process.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
+    );
+    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: tdispatch });
     const onThreadMessage = (event) => {
       const data = event.data;
       if (data?.type === WASM_THREAD_EXIT) endThread(thread.tid);
@@ -10340,6 +10379,7 @@ function spawnWasmProcess(opts) {
     tw.addEventListener("message", onThreadMessage);
     tw.addEventListener("error", onError);
     threads.set(thread.tid, () => {
+      threadSignals.delete(thread.tid);
       tw.removeEventListener("message", onThreadMessage);
       tw.removeEventListener("error", onError);
       tresponder.dispose();