@ai-ecoverse/slicc-kernel 1.54.3 → 1.54.4

package/dist/node.js

@@ -6586,12 +6586,14 @@ var AsyncOps = class {
     const at = this.ready.indexOf(id2);
     if (at >= 0) this.ready.splice(at, 1);
   }
-  async wait(timeoutMs, signal) {
+  async wait(timeoutMs, blocking) {
+    let signal;
     for (; ; ) {
       if (this.closed) return -1;
       const id2 = this.ready.shift();
       if (id2 !== void 0) return id2;
       if (timeoutMs !== void 0 && timeoutMs <= 0) return 0;
+      signal ??= blocking();
       const woke = await this.sleep(timeoutMs, signal);
       if (!woke) return 0;
     }
@@ -6652,7 +6654,7 @@ async function hostSyscall(req, ctx) {
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
       return json3(ctx.ops.submit(req.req));
     case "async-wait":
-      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking()));
+      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
     case "async-take":
       return ctx.ops.take(req.id);
     case "async-resolve":
@@ -9575,6 +9577,9 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "dl-closure",
   "dl-closure-free",
   "dl-reserve",
+  "dl-load-reserve",
+  "dl-lock",
+  "dl-unlock",
   "fd-renumber",
   "fd-promote",
   "fd-open-tty",
@@ -9634,7 +9639,7 @@ var WasmProcess = class {
   stopped = 0;
   stops = 0;
   owed = false;
-  waits = 0;
+  waiting = /* @__PURE__ */ new Set();
   resumed = Promise.resolve();
   wake;
   stateListeners = [];
@@ -9690,7 +9695,8 @@ var WasmProcess = class {
       return "terminate";
     }
     this.options.onPending?.(sig);
-    if (this.options.jobs?.keyboard && KEYBOARD.has(sig)) this.owed = true;
+    if (this.options.jobs?.keyboard && KEYBOARD.has(sig) && this.waiting.size === 0)
+      this.owed = true;
     const blocked = this.interrupt;
     this.interrupt = new AbortController();
     blocked.abort();
@@ -9735,10 +9741,15 @@ var WasmProcess = class {
       await this.resumed;
       if (this.dying) return DYING;
       const stops = this.stops;
-      const waits = this.waits;
-      const result = await this.dispatch(req, cancelled);
+      const scope = new AbortController();
+      const forward = () => scope.abort();
+      if (cancelled?.aborted) scope.abort();
+      cancelled?.addEventListener("abort", forward, { once: true });
+      const result = await this.dispatch(req, scope.signal).finally(() => {
+        cancelled?.removeEventListener("abort", forward);
+        this.waiting.delete(scope.signal);
+      });
       if (this.dying) return DYING;
-      if (!result.ok && result.errno === "EINTR" && this.waits !== waits) this.owed = false;
       const restart = !result.ok && result.errno === "EINTR" && this.stops !== stops;
       if (restart && !this.options.hasPending?.()) continue;
       await this.resumed;
@@ -9791,12 +9802,31 @@ var WasmProcess = class {
   refuseIfPending(restart) {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
+  async procWait(req, cancelled) {
+    const flags = {
+      untraced: req.untraced,
+      continued: req.continued,
+      inGroup: this.waitGroup(req.pid)
+    };
+    if (this.owed && !req.nohang) {
+      const now = await this.children.wait(req.pid, true, this.interrupt.signal, flags);
+      if (now[0] !== 0) return now;
+    }
+    const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
+    const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
+    return waited;
+  }
   blockingSignal(cancelled, owing = true) {
-    if (owing) this.waits++;
-    if (this.options.hasPending?.() || cancelled?.aborted || owing && this.owed) {
+    if (owing && this.owed) {
+      this.owed = false;
       throw new KernelError("EINTR");
     }
-    return cancelled ? AbortSignal.any([this.interrupt.signal, cancelled]) : this.interrupt.signal;
+    if (this.options.hasPending?.() || cancelled.aborted) throw new KernelError("EINTR");
+    if (owing) this.waiting.add(cancelled);
+    return this.cancelSignal(cancelled);
+  }
+  cancelSignal(cancelled) {
+    return AbortSignal.any([this.interrupt.signal, cancelled]);
   }
   async read(req, cancelled) {
     const file = this.fds.get(req.fd).file;
@@ -9820,7 +9850,7 @@ var WasmProcess = class {
     if (nonblock) return file.write(body, AbortSignal.abort());
     return file.write(
       body,
-      this.options.hasPending?.() ? AbortSignal.abort() : this.interrupt.signal
+      this.options.hasPending?.() ? AbortSignal.abort() : this.cancelSignal(cancelled)
     );
   }
   async openVfs(req) {
@@ -9964,6 +9994,11 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
+        if (this.owed && timeoutMs !== 0) {
+          const ready2 = await selectFds(this.fds, read, write, 0, this.interrupt.signal);
+          if (ready2.read.length + ready2.write.length > 0)
+            return { ok: true, kind: "json", json: ready2 };
+        }
         const signal = this.blockingSignal(cancelled, timeoutMs !== 0);
         const selected = await selectFds(this.fds, read, write, timeoutMs, signal);
         return { ok: true, kind: "json", json: selected };
@@ -10161,16 +10196,8 @@ var WasmProcess = class {
       case "proc-spawn":
         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(cancelled);
-        const flags = {
-          untraced: req.untraced,
-          continued: req.continued,
-          inGroup: this.waitGroup(req.pid)
-        };
-        const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
-        return { ok: true, kind: "json", json: waited };
-      }
+      case "proc-wait":
+        return { ok: true, kind: "json", json: await this.procWait(req, cancelled) };
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
@@ -10202,7 +10229,7 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.mounts?.() ?? [] };
       case "mount":
       case "umount":
-        return this.mountSyscall(req);
+        return this.mountSyscall(req, cancelled);
       case "proc-alarm":
         this.setAlarm(req.sig, req.firstMs ?? req.ms, req.repeat ? req.ms : 0, req.timer);
         return { ok: true, kind: "void" };
@@ -10223,6 +10250,18 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "dl-reserve":
         return { ok: true, kind: "json", json: this.reserveSlots(req.floor, req.size) };
+      case "dl-load-reserve":
+        return {
+          ok: true,
+          kind: "json",
+          json: { base: this.reserveSlots(req.floor, req.size), handle: this.closures.handle++ }
+        };
+      case "dl-lock":
+        await this.lockDl(req.owner);
+        return { ok: true, kind: "void" };
+      case "dl-unlock":
+        this.unlockDl(req.owner);
+        return { ok: true, kind: "void" };
       case "sig-mask":
         this.caught = req.caught;
         this.ignored = req.ignored;
@@ -10237,14 +10276,14 @@ var WasmProcess = class {
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
     }
   }
-  async mountSyscall(req) {
+  async mountSyscall(req, cancelled) {
     const { mount, umount } = this.options;
     if (!mount || !umount) throw new KernelError("ENOSYS");
     try {
       if (req.op === "umount") await umount(req.target, req.flags);
       else {
         const { source, target, type, flags, data } = req;
-        const signal = this.blockingSignal();
+        const signal = this.blockingSignal(cancelled);
         await Promise.race([mount({ source, target, type, flags, data }, signal), aborted(signal)]);
       }
     } catch (err) {
@@ -10259,7 +10298,12 @@ var WasmProcess = class {
   }
   alarm;
   dlLog = [];
-  closures = { next: 0, free: [], live: /* @__PURE__ */ new Set() };
+  closures = {
+    next: 0,
+    handle: 1,
+    free: [],
+    live: /* @__PURE__ */ new Set()
+  };
   allocateClosure(floor) {
     const index = this.closures.free.pop() ?? Math.max(floor, this.closures.next);
     this.closures.next = Math.max(this.closures.next, index + 1);
@@ -10272,6 +10316,47 @@ var WasmProcess = class {
     this.closures.free.push(index);
     this.dlLog.push({ kind: "closure-free", index });
   }
+  dlLock = {
+    owner: 0,
+    depth: 0,
+    waiters: /* @__PURE__ */ new Set()
+  };
+  async lockDl(owner) {
+    while (this.dlLock.depth > 0 && this.dlLock.owner !== owner) {
+      if (this.dying) throw new KernelError("EINTR");
+      const interrupt = this.interrupt.signal;
+      const gone = await new Promise((resolve) => {
+        const waiter = {
+          owner,
+          wake: (ended) => {
+            this.dlLock.waiters.delete(waiter);
+            interrupt.removeEventListener("abort", recheck);
+            resolve(ended);
+          }
+        };
+        const recheck = () => waiter.wake(false);
+        this.dlLock.waiters.add(waiter);
+        interrupt.addEventListener("abort", recheck, { once: true });
+      });
+      if (gone) throw new KernelError("EINTR");
+    }
+    this.dlLock.owner = owner;
+    this.dlLock.depth++;
+  }
+  threadEnded(tid) {
+    for (const waiter of [...this.dlLock.waiters]) if (waiter.owner === tid) waiter.wake(true);
+    if (this.dlLock.depth === 0 || this.dlLock.owner !== tid) return;
+    this.dlLock.depth = 0;
+    this.wakeDl();
+  }
+  unlockDl(owner) {
+    if (this.dlLock.depth === 0 || this.dlLock.owner !== owner) throw new KernelError("EPERM");
+    this.dlLock.depth--;
+    if (this.dlLock.depth === 0) this.wakeDl();
+  }
+  wakeDl() {
+    for (const waiter of [...this.dlLock.waiters]) waiter.wake(false);
+  }
   reserveSlots(floor, size) {
     const base = Math.max(floor, this.closures.next);
     this.closures.next = base + size;
@@ -10583,6 +10668,7 @@ function spawnWasmProcess(opts) {
   const endThread = (tid) => {
     const end = threads.get(tid);
     threads.delete(tid);
+    process2.threadEnded(tid);
     end?.();
   };
   const spawnThread = (thread) => {