@ai-ecoverse/slicc-kernel 1.94.4 → 1.95.1

package/dist/process-worker.js

@@ -1042,11 +1042,11 @@ function createSyncSabTransport(sab, port2, deps = {}) {
     }
   }
   return {
-    call(req, timeoutMs, label, transfer = []) {
+    call(req, timeoutMs2, label, transfer = []) {
       if (deps.memory) publishMemory(sab, deps.memory());
       const id = ++seq;
       calls += Number(!PATH_OPS.has(req.op));
-      const deadline = now() + timeoutMs;
+      const deadline = now() + timeoutMs2;
       let out = null;
       let status2 = 0;
       let offset = 0;
@@ -1089,12 +1089,12 @@ function errnoError(code2, path) {
   return syncError(code2, `sync-sab bridge, '${path}'`);
 }
 function createSyncFsSabBridge(transport, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? SYNC_FS_REQUEST_TIMEOUT_MS;
+  const timeoutMs2 = opts.timeoutMs ?? SYNC_FS_REQUEST_TIMEOUT_MS;
   let identity = {};
   let last = null;
   function run(req, path, transfer) {
     last = null;
-    const result = transport.call(req, timeoutMs, `sync-sab bridge, '${path}'`, transfer);
+    const result = transport.call(req, timeoutMs2, `sync-sab bridge, '${path}'`, transfer);
     if (!result.ok) throw errnoError(result.errno, path);
     return result;
   }
@@ -2343,7 +2343,7 @@ function mountVfsIntoEmscripten(Fs, deps) {
   try {
     Fs.chdir(deps.cwd);
   } catch (err) {
-    warn(`cannot chdir to ${deps.cwd}: ${String(err)}`);
+    warn(`cannot chdir to ${deps.cwd}: errno ${err.errno}`);
   }
   return {
     mounted,
@@ -4149,11 +4149,11 @@ function drain(Fs, stream) {
   }
   return out;
 }
-function kernelSelect(Fs, transport, read2, write2, timeoutMs) {
+function kernelSelect(Fs, transport, read2, write2, timeoutMs2) {
   const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
   const kr = read2.map(kernel);
   const kw = write2.map(kernel);
-  const r = transport.call({ op: "fd-select", read: kr, write: kw, timeoutMs }, Infinity, "select");
+  const r = transport.call({ op: "fd-select", read: kr, write: kw, timeoutMs: timeoutMs2 }, Infinity, "select");
   if (!r.ok) return -wasiErrno(r.errno);
   const got = r.kind === "json" ? r.json : { read: [], write: [] };
   return {
@@ -4172,11 +4172,11 @@ function ownReady(Fs, read2, write2) {
     write: write2.filter((fd) => flags(fd) & (POLLOUT2 | POLLERR2 | POLLNVAL))
   };
 }
-function anySelect(Fs, transport, read2, write2, timeoutMs) {
+function anySelect(Fs, transport, read2, write2, timeoutMs2) {
   const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
   const own = (fd) => kernel(fd) === void 0;
-  if (![...read2, ...write2].some(own)) return kernelSelect(Fs, transport, read2, write2, timeoutMs);
-  const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  if (![...read2, ...write2].some(own)) return kernelSelect(Fs, transport, read2, write2, timeoutMs2);
+  const deadline = timeoutMs2 < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs2;
   const kernelRead = read2.filter((fd) => !own(fd));
   const kernelWrite = write2.filter((fd) => !own(fd));
   for (; ; ) {
@@ -4287,7 +4287,7 @@ function createProcessKernel(deps) {
       if (!r.ok) return -wasiErrno(r.errno);
       return r.kind === "json" ? r.json : -wasiErrno("EIO");
     },
-    select: (read2, write2, timeoutMs) => anySelect(Fs, transport, read2, write2, timeoutMs),
+    select: (read2, write2, timeoutMs2) => anySelect(Fs, transport, read2, write2, timeoutMs2),
     execWait,
     execve(file, argv, env, cwd) {
       const pid = spawnChild(file, argv, env, cwd, [0, 1, 2], void 0, true);
@@ -4434,11 +4434,11 @@ var init_process_signals = __esm({
       }
       transport() {
         return {
-          call: (req, timeoutMs, label) => {
+          call: (req, timeoutMs2, label) => {
             this.report();
             this.depth++;
             try {
-              const result = this.raw.call(req, timeoutMs, label);
+              const result = this.raw.call(req, timeoutMs2, label);
               this.deliver();
               return result;
             } finally {
@@ -4703,7 +4703,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.94.4" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.95.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -5408,9 +5408,9 @@ function bridgeFlags(init) {
 }
 function credSyncTransport(gated, early, cred) {
   return {
-    call: (req, timeoutMs, label) => {
+    call: (req, timeoutMs2, label) => {
       if (!FS_OPS.has(req.op)) early();
-      const r = gated.call(req, timeoutMs, label);
+      const r = gated.call(req, timeoutMs2, label);
       if (cred && req.op === "proc-setcred" && r.ok && r.kind === "json")
         Object.assign(cred, r.json);
       return r;
@@ -7339,9 +7339,9 @@ function readyEvents(subs, ready) {
     hangup: ready.hangup?.includes(s.fd) === true
   }));
 }
-function selectOnce(deps, read2, write2, timeoutMs) {
+function selectOnce(deps, read2, write2, timeoutMs2) {
   try {
-    const ready = deps.kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
+    const ready = deps.kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs: timeoutMs2 });
     return { ready, interrupted: false };
   } catch (e) {
     if (!deps.interruptWakes || e.code !== "EINTR") throw e;
@@ -8815,16 +8815,16 @@ function importsContext({
     ...processes(host, call2, tid !== MAIN_TID),
     async: {
       submit: (req) => call2({ op: "async-submit", req }),
-      wait(timeoutMs) {
+      wait(timeoutMs2) {
         for (; ; ) {
           try {
             return call2({
               op: "async-wait",
-              ...timeoutMs !== void 0 ? { timeoutMs } : {}
+              ...timeoutMs2 !== void 0 ? { timeoutMs: timeoutMs2 } : {}
             });
           } catch (err) {
             if (code(err) !== "EINTR") throw err;
-            if (timeoutMs !== void 0) return 0;
+            if (timeoutMs2 !== void 0) return 0;
           }
         }
       },
@@ -9717,6 +9717,91 @@ var init_wasix_fork = __esm({
   }
 });
 
+// src/process/wasi/wasix-epoll.ts
+function timeoutMs(ns) {
+  const value2 = BigInt.asUintN(64, ns);
+  if (value2 === FOREVER) return -1;
+  const ms = (value2 + NS_PER_MS2 - 1n) / NS_PER_MS2;
+  return ms > BigInt(MAX_TIMEOUT_MS) ? -1 : Number(ms);
+}
+function wasixEpollImports(host) {
+  const { mem, fds, o } = host;
+  const call2 = (req) => o.kernel.call(req);
+  const kernelFd = (fd, refusal2) => {
+    const e = fds.find(fd);
+    if (!e) throw new WasiError("EBADF");
+    if (e.type !== "kernel") throw new WasiError(refusal2);
+  };
+  const writeEvents2 = (ptr, events) => {
+    const view = mem.view();
+    events.forEach((ev, i) => {
+      const at = ptr + i * EVENT_SIZE;
+      mem.bytes(at, EVENT_SIZE).fill(0);
+      view.setUint32(at, ev.events, true);
+      mem.bytes(at + DATA_OFFSET, DATA_SIZE).set(ev.data);
+    });
+  };
+  return {
+    epoll_create: (out) => {
+      const fd = call2({ op: "epoll-create" });
+      fds.adopt(fd, "stream", false);
+      mem.view().setUint32(out, fd, true);
+    },
+    epoll_ctl: (epfd, op, fd, event) => {
+      const how = OPS[op];
+      if (!how) throw new WasiError("EINVAL");
+      kernelFd(epfd, "EINVAL");
+      kernelFd(fd, "EPERM");
+      if (how !== "del" && event === 0) throw new WasiError("EINVAL");
+      const events = event === 0 ? 0 : mem.view().getUint32(event, true);
+      const data = event === 0 ? [] : [...mem.bytes(event + DATA_OFFSET, DATA_SIZE)];
+      call2({ op: "epoll-ctl", epfd, how, fd, events, data });
+    },
+    epoll_wait: (epfd, ptr, maxevents, timeout, out) => {
+      mem.view().setUint32(out, 0, true);
+      if ((maxevents | 0) <= 0) throw new WasiError("EINVAL");
+      kernelFd(epfd, "EINVAL");
+      const max = Math.min(maxevents | 0, MAX_EVENTS);
+      const ms = host.entered ? 0 : timeoutMs(timeout);
+      const events = call2({ op: "epoll-wait", epfd, max, timeoutMs: ms });
+      if (host.entered && events.length === 0 && timeoutMs(timeout) !== 0) return E.INTR;
+      writeEvents2(ptr, events);
+      mem.view().setUint32(out, events.length, true);
+      return E.SUCCESS;
+    },
+    fd_event: (initial, flags, out) => {
+      const value2 = BigInt.asUintN(64, initial);
+      if (value2 > EVENTFD_MAX) throw new WasiError("EINVAL");
+      const fd = call2({
+        op: "eventfd-open",
+        initial: value2.toString(),
+        semaphore: (flags & EVENTFD_SEMAPHORE) !== 0
+      });
+      fds.adopt(fd, "stream", (flags & EVENTFD_NONBLOCK) !== 0);
+      mem.view().setUint32(out, fd, true);
+    }
+  };
+}
+var EVENT_SIZE, DATA_OFFSET, DATA_SIZE, MAX_EVENTS, FOREVER, MAX_TIMEOUT_MS, NS_PER_MS2, EVENTFD_SEMAPHORE, EVENTFD_NONBLOCK, EVENTFD_MAX, OPS;
+var init_wasix_epoll = __esm({
+  "src/process/wasi/wasix-epoll.ts"() {
+    "use strict";
+    init_wasi_abi();
+    init_wasi_files();
+    EVENT_SIZE = 32;
+    DATA_OFFSET = 8;
+    DATA_SIZE = 24;
+    MAX_EVENTS = 4096;
+    FOREVER = 0xffffffffffffffffn;
+    MAX_TIMEOUT_MS = 2147483647;
+    NS_PER_MS2 = 1000000n;
+    EVENTFD_SEMAPHORE = 1;
+    EVENTFD_NONBLOCK = 4;
+    EVENTFD_MAX = 0xfffffffffffffffen;
+    OPS = ["add", "set", "del", "mod"];
+  }
+});
+
 // src/process/wasi/wasix-ffi.ts
 function read(view, at, type) {
   if (type === "i32") return view.getInt32(at, true);
@@ -10899,6 +10984,7 @@ var init_wasix_host = __esm({
     init_wasi_host();
     init_wasi_module();
     init_wasi_threads();
+    init_wasix_epoll();
     init_wasix_ffi();
     init_wasix_linker();
     init_wasix_process();
@@ -11025,7 +11111,8 @@ var init_wasix_host = __esm({
             { mem: this.mem, table: () => this.table, types: this.types },
             ...a
           ),
-          ...wasixSocketImports(this.host, this.host.imports())
+          ...wasixSocketImports(this.host, this.host.imports()),
+          ...wasixEpollImports(this.host)
         });
       }
       preview1() {