@ai-ecoverse/slicc-kernel 1.72.0 → 1.73.1

package/dist/process-worker.js

@@ -2650,36 +2650,57 @@ function pathOpensLinks(Fs) {
   if (!mayOpen || !isLink) return;
   fs.mayOpen = (node, flags) => flags & O_PATH && isLink.call(fs, node.mode) ? 0 : mayOpen.call(fs, node, flags);
 }
+function importKey(namespace, name2, glue) {
+  const own = glue?.[name2];
+  if (typeof own === "function") {
+    const found = Object.keys(namespace).find((k) => namespace[k] === own);
+    if (found !== void 0) return found;
+  }
+  const literal = LITERALS[name2];
+  return typeof namespace[literal] === "function" ? literal : void 0;
+}
+function wrapImport(imports, name2, glue, wrap2) {
+  let wrapped = false;
+  for (const ns of namespaces(imports)) {
+    const key = importKey(ns, name2, glue);
+    if (key === void 0) continue;
+    ns[key] = wrap2(ns[key]);
+    wrapped = true;
+  }
+  if (!wrapped && typeof glue?.[name2] === "function") {
+    throw new Error(`slicc-kernel cannot find the glue's ${LITERALS[name2]} among its imports`);
+  }
+}
 function kernelUmask(imports, deps) {
   let umask = deps.initial & 511;
-  for (const ns of namespaces(imports)) {
-    const { __syscall_openat: openat, __syscall_mkdirat: mkdirat } = ns;
-    const { __syscall_mknodat: mknodat, __syscall_umask: own } = ns;
-    if (typeof openat === "function") {
-      ns.__syscall_openat = (dirfd, path, flags, varargs) => {
-        const memory = deps.memory();
-        if (flags & O_CREAT2 && varargs && memory)
-          new Int32Array(memory.buffer)[varargs >> 2] &= ~umask;
-        return openat(dirfd, path, flags, varargs);
-      };
-    }
-    if (typeof mkdirat === "function") {
-      ns.__syscall_mkdirat = (dirfd, path, mode) => mkdirat(dirfd, path, mode & ~umask);
-    }
-    if (typeof mknodat === "function") {
-      ns.__syscall_mknodat = (dirfd, path, mode, dev) => mknodat(dirfd, path, mode & ~umask, dev);
-    }
-    if (typeof own === "function") {
+  const { glue } = deps;
+  wrapImport(imports, "openat", glue, (openat) => (dirfd, path, flags, varargs) => {
+    const memory = deps.memory();
+    if (flags & O_CREAT2 && varargs && memory) new Int32Array(memory.buffer)[varargs >> 2] &= ~umask;
+    return openat(dirfd, path, flags, varargs);
+  });
+  wrapImport(
+    imports,
+    "mkdirat",
+    glue,
+    (mkdirat) => (dirfd, path, mode) => mkdirat(dirfd, path, mode & ~umask)
+  );
+  wrapImport(
+    imports,
+    "mknodat",
+    glue,
+    (mknodat) => (dirfd, path, mode, dev) => mknodat(dirfd, path, mode & ~umask, dev)
+  );
+  wrapImport(imports, "umask", glue, (own) => {
+    own(umask);
+    return (mask) => {
+      const old = umask;
+      umask = mask & 511;
       own(umask);
-      ns.__syscall_umask = (mask) => {
-        const old = umask;
-        umask = mask & 511;
-        own(umask);
-        deps.set(umask);
-        return old;
-      };
-    }
-  }
+      deps.set(umask);
+      return old;
+    };
+  });
 }
 function touching(times, memory) {
   if (times === 0) return true;
@@ -2698,13 +2719,11 @@ function touch(Fs, on, run) {
   }
 }
 function noFollowUtimes(imports, fs, glue, memory = () => void 0) {
-  for (const namespace of namespaces(imports)) {
-    const key = Object.keys(namespace).find(
-      (name2) => glue !== void 0 && namespace[name2] === glue || name2 === "__syscall_utimensat"
-    );
-    const utimensat = key === void 0 ? void 0 : namespace[key];
-    if (key === void 0 || typeof utimensat !== "function") continue;
-    namespace[key] = (dirfd, path, times, flags) => {
+  wrapImport(
+    imports,
+    "utimensat",
+    { utimensat: glue },
+    (utimensat) => (dirfd, path, times, flags) => {
       const Fs = fs();
       const on = touching(times, memory());
       const { utime, lookupPath, ErrnoError } = Fs ?? {};
@@ -2721,8 +2740,8 @@ function noFollowUtimes(imports, fs, glue, memory = () => void 0) {
       } finally {
         Fs.utime = utime;
       }
-    };
-  }
+    }
+  );
 }
 function errnoOf(err) {
   const { errno: errno2, code: code2 } = err ?? {};
@@ -3077,22 +3096,18 @@ function kernelChecks(Fs, memory, call2) {
   bridge.access(liveNodePath(node), call2.amode, kind, (call2.flags & AT_SYMLINK_NOFOLLOW) !== 0);
   return 0;
 }
-function kernelAccess(imports, fs, memory) {
-  for (const ns of namespaces(imports)) {
-    const own = ns.__syscall_faccessat;
-    if (typeof own !== "function") continue;
-    ns.__syscall_faccessat = (dirfd, path, amode, flags) => {
-      const rc = own(dirfd, path, amode, flags);
-      const Fs = fs();
-      const heap = memory();
-      if (rc !== 0 || !Fs?.lookupPath || !heap) return rc;
-      try {
-        return kernelChecks(Fs, heap, { dirfd, path, amode: amode & 7, flags });
-      } catch (err) {
-        return -errnoOf(err);
-      }
-    };
-  }
+function kernelAccess(imports, fs, memory, glue) {
+  wrapImport(imports, "faccessat", glue, (own) => (dirfd, path, amode, flags) => {
+    const rc = own(dirfd, path, amode, flags);
+    const Fs = fs();
+    const heap = memory();
+    if (rc !== 0 || !Fs?.lookupPath || !heap) return rc;
+    try {
+      return kernelChecks(Fs, heap, { dirfd, path, amode: amode & 7, flags });
+    } catch (err) {
+      return -errnoOf(err);
+    }
+  });
 }
 function linuxDevices(Fs) {
   const { chmod } = Fs;
@@ -3104,7 +3119,7 @@ function linuxDevices(Fs) {
     }
   }
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, O_PATH, UTIME_NOW, UTIME_OMIT, PROT_WRITE, MAP_PRIVATE, MAP_TYPE, O_WRONLY, MAP_ALIGN, DIR_MODE, LINK_MODE, CHAR_DEVICE, O_ACCMODE2, O_CREAT2, field, pinnedRoot, rootKind, NAME, AT_FDCWD, AT_EACCESS, DEVICE_MODES;
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, O_PATH, LITERALS, UTIME_NOW, UTIME_OMIT, PROT_WRITE, MAP_PRIVATE, MAP_TYPE, O_WRONLY, MAP_ALIGN, DIR_MODE, LINK_MODE, CHAR_DEVICE, O_ACCMODE2, O_CREAT2, field, pinnedRoot, rootKind, NAME, AT_FDCWD, AT_EACCESS, DEVICE_MODES;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -3133,6 +3148,16 @@ var init_process_fds = __esm({
     AT_SYMLINK_NOFOLLOW = 256;
     EMSCRIPTEN_EPERM = 63;
     O_PATH = 2097152;
+    LITERALS = {
+      openat: "__syscall_openat",
+      mkdirat: "__syscall_mkdirat",
+      mknodat: "__syscall_mknodat",
+      umask: "__syscall_umask",
+      faccessat: "__syscall_faccessat",
+      utimensat: "__syscall_utimensat",
+      getppid: "slicc_getppid_js",
+      resizeHeap: "emscripten_resize_heap"
+    };
     UTIME_NOW = 1073741823;
     UTIME_OMIT = 1073741822;
     PROT_WRITE = 2;
@@ -4528,9 +4553,8 @@ function identify(transport, init) {
   const id = r.ok && r.kind === "json" ? r.json : null;
   return id ?? { pid: init.pid, ppid: init.ppid ?? 1 };
 }
-function liveParent(imports, parent) {
-  const env = imports.env;
-  if (env && typeof env.slicc_getppid_js === "function") env.slicc_getppid_js = parent;
+function liveParent(imports, parent, glue) {
+  wrapImport(imports, "getppid", glue, () => parent);
 }
 function signalMasks(m) {
   const mask = m.sliccSigMask;
@@ -4538,15 +4562,12 @@ function signalMasks(m) {
   if (!mask || caught === -1) return null;
   return { caught, ignored: mask(1), restart: mask(2) };
 }
-function reportGrowth(imports, publish) {
-  const env = imports.env;
-  const resize = env?.emscripten_resize_heap;
-  if (!env || typeof resize !== "function") return;
-  env.emscripten_resize_heap = (...args) => {
+function reportGrowth(imports, publish, glue) {
+  wrapImport(imports, "resizeHeap", glue, (resize) => (...args) => {
     const grown = resize(...args);
     publish();
     return grown;
-  };
+  });
 }
 function callerOwner(Fs, init) {
   return init.owners ? {} : { owner: ownByCaller(Fs, init.cred, credAbi(init.program.glue)) };
@@ -4554,6 +4575,25 @@ function callerOwner(Fs, init) {
 function utimensatOf(module) {
   return ownValue(module, "sliccSyscalls")?.utimensat;
 }
+function kernelWrappers(imports, module, deps) {
+  const { init, transport, sys, memory } = deps;
+  const kernelGlue = ownValue(module, "sliccKernelImports");
+  liveParent(imports, deps.ppid, kernelGlue);
+  kernelUmask(imports, {
+    glue: kernelGlue,
+    initial: init.umask ?? 18,
+    memory,
+    set: (mask) => void transport.call({ op: "proc-umask", mask }, Number.POSITIVE_INFINITY, "umask")
+  });
+  const fsOf = () => ownValue(module, "FS");
+  noFollowUtimes(imports, fsOf, kernelGlue?.utimensat ?? utimensatOf(module), memory);
+  kernelAccess(imports, fsOf, memory, kernelGlue);
+  const glue = ownValue(module, "sliccFdImports");
+  syncFsync(imports, fsOf, glue);
+  positionalIo(imports, { glue, fs: fsOf, sys, memory });
+  const grown = () => publishMemory(init.sab, memory()?.buffer.byteLength ?? 0);
+  reportGrowth(imports, grown, kernelGlue);
+}
 async function runWasmProcess(init, port2, deps = {}) {
   const signals = new SignalGate(
     createSyncSabTransport(init.sab, port2, {
@@ -4615,24 +4655,13 @@ async function runWasmProcess(init, port2, deps = {}) {
             }
           }
         });
-        liveParent(imports, () => identify(transport, init).ppid);
-        kernelUmask(imports, {
-          initial: init.umask ?? 18,
-          memory: () => memory,
-          set: (mask) => void transport.call({ op: "proc-umask", mask }, Number.POSITIVE_INFINITY, "umask")
-        });
-        const fsOf = () => ownValue(module, "FS");
-        noFollowUtimes(imports, fsOf, utimensatOf(module), () => memory);
-        kernelAccess(imports, fsOf, () => memory);
-        const glue = ownValue(module, "sliccFdImports");
-        syncFsync(imports, () => ownValue(module, "FS"), glue);
-        positionalIo(imports, {
-          glue,
-          fs: () => ownValue(module, "FS"),
+        kernelWrappers(imports, module, {
+          init,
+          transport,
           sys,
-          memory: () => memory
+          memory: () => memory,
+          ppid: () => identify(transport, init).ppid
         });
-        reportGrowth(imports, () => publishMemory(init.sab, memory?.buffer.byteLength ?? 0));
         return WebAssembly.instantiate(init.program.module, imports);
       }).then((instance) => {
         memory = wasmMemory(instance, imports);
@@ -4814,6 +4843,16 @@ var init_process_runtime = __esm({
       "  ioctl: typeof ___syscall_ioctl === 'function' ? ___syscall_ioctl : undefined,",
       "  setitimer: typeof __setitimer_js === 'function' ? __setitimer_js : undefined,",
       "};",
+      "Module.sliccKernelImports ??= {",
+      "  openat: typeof ___syscall_openat === 'function' ? ___syscall_openat : undefined,",
+      "  mkdirat: typeof ___syscall_mkdirat === 'function' ? ___syscall_mkdirat : undefined,",
+      "  mknodat: typeof ___syscall_mknodat === 'function' ? ___syscall_mknodat : undefined,",
+      "  umask: typeof ___syscall_umask === 'function' ? ___syscall_umask : undefined,",
+      "  faccessat: typeof ___syscall_faccessat === 'function' ? ___syscall_faccessat : undefined,",
+      "  utimensat: typeof ___syscall_utimensat === 'function' ? ___syscall_utimensat : undefined,",
+      "  getppid: typeof _slicc_getppid_js === 'function' ? _slicc_getppid_js : undefined,",
+      "  resizeHeap: typeof _emscripten_resize_heap === 'function' ? _emscripten_resize_heap : undefined,",
+      "};",
       "Module.sliccFdImports ??= {",
       "  fd_sync: typeof _fd_sync === 'function' ? _fd_sync : undefined,",
       "  fd_pread: typeof _fd_pread === 'function' ? _fd_pread : undefined,",