@ai-ecoverse/slicc-kernel 1.54.1 → 1.54.3

package/dist/process-worker.js

@@ -3289,6 +3289,7 @@ var init_process_signals = __esm({
         }
       }
       interrupt() {
+        this.report();
         const header = this.header;
         const pending = Atomics.load(header, SAB_I_SIGNALS) | Atomics.load(header, SAB_I_TIMERS) | Atomics.load(header, SAB_I_KILLED);
         if (pending === 0) return false;
@@ -4812,7 +4813,7 @@ function openAccess(existing, oflags, rights) {
   return { readable: (rights & RIGHTS.FD_READ) !== 0n || !writable2, writable: writable2 };
 }
 function promoteRequest(fd, f, handed) {
-  const orphan = f.buffer.isOrphan();
+  const orphan = f.buffer.isOrphan() || (f.buffer.handle ?? 0) < 0;
   if (!orphan && f.buffer.isRanged) f.buffer.flush();
   const joins = !orphan && (handed.has(f.buffer) || f.buffer.isRanged);
   return {
@@ -5550,7 +5551,7 @@ function readTermios(mem, ptr) {
     c_cc: Array.from({ length: NCCS }, (_, i) => v.getUint8(ptr + C_CC + i))
   };
 }
-function sliccTty(mem, fds, kernel) {
+function sliccTty(mem, fds, kernel, interrupted = () => void 0) {
   const { sys } = kernel;
   const terminal = (fd) => {
     const e = fds.find(fd);
@@ -5562,13 +5563,19 @@ function sliccTty(mem, fds, kernel) {
     if (value2 === void 0) throw new WasiError("ENOTTY");
     return value2;
   };
+  const getAttr = (fd, ptr) => {
+    interrupted();
+    writeTermios(mem, ptr, needs(sys.tcgets?.(terminal(fd))));
+  };
   const setAttr = (fd, actions, ptr) => {
+    interrupted();
     if (actions < 0 || actions > TCSAFLUSH) throw new WasiError("EINVAL");
     const at = terminal(fd);
     needs(sys.tcsets);
     sys.tcsets?.(at, readTermios(mem, ptr), actions === TCSAFLUSH);
   };
   const size = (fd, ptr) => {
+    interrupted();
     const [rows, cols] = needs(sys.winsize?.(terminal(fd)));
     mem.bytes(ptr, 8).fill(0);
     const v = mem.view();
@@ -5576,7 +5583,7 @@ function sliccTty(mem, fds, kernel) {
     v.setUint16(ptr + 2, cols, true);
   };
   return {
-    tcgetattr: (fd, ptr) => void writeTermios(mem, ptr, needs(sys.tcgets?.(terminal(fd)))),
+    tcgetattr: (fd, ptr) => void getAttr(fd, ptr),
     tcsetattr: (fd, actions, ptr) => void setAttr(fd, actions, ptr),
     winsize: (fd, ptr) => void size(fd, ptr)
   };
@@ -5725,7 +5732,7 @@ var init_wasi_host = __esm({
         if (umask !== DEFAULT_UMASK) this.o.fs.chmod(path, mode & ~umask);
       }
       sliccTtyImports() {
-        return wrap(sliccTty(this.mem, this.fds, this.o.kernel));
+        return wrap(sliccTty(this.mem, this.fds, this.o.kernel, () => this.interrupted?.()));
       }
       sliccFsImports() {
         const { mem, fds } = this;
@@ -5946,6 +5953,7 @@ var init_wasi_host = __esm({
         return {
           path_open: (dirfd, _lookup, p, l, oflags, rights, _inheriting, fdflags, out) => {
             const path = at(dirfd, p, l);
+            if (deviceOf(path)) this.interrupted?.();
             const fresh = (oflags & OFLAGS.CREAT) !== 0 && !o.fs.exists(path);
             mem.view().setUint32(out, fds.open(path, oflags, rights, fdflags), true);
             if (fresh) this.created(path, 438);
@@ -6061,7 +6069,9 @@ var init_wasi_host = __esm({
       }
       positional(fd, access) {
         const e = this.fds.get(fd);
-        if (e.type !== "kernel" || this.fds.kind(fd, e) !== "file") return this.file(fd, access);
+        const kind = e.type === "kernel" ? this.fds.kind(fd, e) : e.type;
+        if (kind === "device") this.interrupted?.();
+        if (kind !== "file" || e.type !== "kernel") return this.file(fd, access);
         const kernel = this.o.kernel;
         return {
           pread: (max, at) => {
@@ -6089,6 +6099,7 @@ var init_wasi_host = __esm({
           }
         }
         if (e.type === "device") {
+          this.interrupted?.();
           if (e.access === "read") throw new WasiError("EBADF");
           if (e.device === "full" && data.length > 0) throw new WasiError("ENOSPC");
           return data.length;
@@ -6101,6 +6112,7 @@ var init_wasi_host = __esm({
           return this.o.kernel.sys.read(fd, Math.min(max, MAX_READ), { nonblock: e.nonblock });
         }
         if (e.type === "device") {
+          this.interrupted?.();
           if (e.access === "write") throw new WasiError("EBADF");
           if (e.device === "null") return new Uint8Array(0);
           const out = new Uint8Array(Math.min(max, 65536));
@@ -6108,15 +6120,19 @@ var init_wasi_host = __esm({
         }
         return this.file(fd, "read").read(max);
       }
+      local(answer2) {
+        this.interrupted?.();
+        return answer2;
+      }
       seek(fd, offset, whence) {
         const e = this.fds.get(fd);
         if (e.type === "kernel") {
           const kind = this.fds.kind(fd, e);
-          if (kind === "device") return 0;
+          if (kind === "device") return this.local(0);
           if (kind !== "file") throw new WasiError("ESPIPE");
           return this.o.kernel.sys.seek(fd, offset, whence);
         }
-        if (e.type === "device") return 0;
+        if (e.type === "device") return this.local(0);
         const file = this.file(fd);
         const base = whence === WHENCE.SET ? 0 : whence === WHENCE.CUR ? file.offset : file.size();
         if (whence > WHENCE.END || base + offset < 0) throw new WasiError("EINVAL");
@@ -6126,15 +6142,23 @@ var init_wasi_host = __esm({
       sync(fd) {
         const e = this.fds.get(fd);
         if (e.type === "file") e.file.flush();
-        else if (e.type === "kernel" && this.fds.kind(fd, e) === "file") this.o.kernel.sys.flush(fd);
+        else if (e.type === "device") this.interrupted?.();
+        else if (e.type === "kernel") {
+          const kind = this.fds.kind(fd, e);
+          if (kind === "file") this.o.kernel.sys.flush(fd);
+          else if (kind === "device") this.interrupted?.();
+        }
       }
       fdstat(fd, out) {
         const e = this.fds.get(fd);
+        if (e.type === "device") this.interrupted?.();
         let filetype = FILETYPE.CHARACTER_DEVICE;
         let seeks = true;
         let flags = 0;
         if (e.type === "kernel") {
-          ({ filetype, seeks } = kernelFiletype(this.fds.kind(fd, e)));
+          const kind = this.fds.kind(fd, e);
+          if (kind === "device") this.interrupted?.();
+          ({ filetype, seeks } = kernelFiletype(kind));
           if (e.nonblock) flags |= FDFLAGS.NONBLOCK;
           if (e.append) flags |= FDFLAGS.APPEND;
         } else if (e.type === "file") {
@@ -6169,7 +6193,7 @@ var init_wasi_host = __esm({
           if (vfs.path) return this.statOrphanable(vfs.path, vfs.size, vfs.orphan);
         }
         const filetype = kind ? kernelFiletype(kind).filetype : FILETYPE.CHARACTER_DEVICE;
-        return { filetype, size: 0n, ino: BigInt(fd + 1), mtimeNs: 0n };
+        return this.local({ filetype, size: 0n, ino: BigInt(fd + 1), mtimeNs: 0n });
       }
       statOrphanable(path, size, orphan = false) {
         let s;
@@ -6186,7 +6210,12 @@ var init_wasi_host = __esm({
       }
       pathFilestat(path, lookup) {
         if (deviceOf(path)) {
-          return { filetype: FILETYPE.CHARACTER_DEVICE, size: 0n, ino: pathInode(path), mtimeNs: 0n };
+          return this.local({
+            filetype: FILETYPE.CHARACTER_DEVICE,
+            size: 0n,
+            ino: pathInode(path),
+            mtimeNs: 0n
+          });
         }
         this.fds.flushPath(path);
         const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
@@ -6771,60 +6800,201 @@ var init_wasi_module = __esm({
 function inProc(path) {
   return path === "/proc" || path.startsWith("/proc/");
 }
+function* procWalk(path, follow2) {
+  let done = [];
+  let todo = path.split("/").filter((part) => part !== "");
+  let hops = 0;
+  while (todo.length > 0) {
+    const part = todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      done.pop();
+      continue;
+    }
+    const at = `/${[...done, part].join("/")}`;
+    const whole = normalize(`/${[...done, part, ...todo].join("/")}`);
+    if (inProc(at) && inProc(whole)) return whole;
+    if (!follow2 && todo.length === 0) return void 0;
+    const target = yield at;
+    if (target === null) return void 0;
+    if (target === void 0) done.push(part);
+    else {
+      if (++hops > MAX_HOPS2) return void 0;
+      if (target.startsWith("/")) done = [];
+      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+    }
+  }
+  return void 0;
+}
+function procPath(fs, path, follow2) {
+  const walk = procWalk(path, follow2);
+  let step = walk.next();
+  while (!step.done) {
+    let target;
+    try {
+      target = fs.lstat(step.value).isSymbolicLink ? fs.readlink(step.value) : void 0;
+    } catch {
+      target = null;
+    }
+    step = walk.next(target);
+  }
+  return step.value;
+}
+function frozen(bytes) {
+  const refuse = () => {
+    throw syncError("EROFS", "/proc");
+  };
+  return {
+    readFile: () => bytes,
+    pread: (_p, at, n) => bytes.subarray(at, at + n),
+    writeFile: refuse,
+    pwrite: refuse,
+    truncate: refuse
+  };
+}
 function procfsBridge(fs, tree) {
+  const toProc = (path, follow2) => procPath(fs, path, follow2);
+  const shadowing = () => {
+    try {
+      return fs.exists("/proc");
+    } catch {
+      return false;
+    }
+  };
+  const via = (p, proc, own, follow2 = true) => {
+    if (inProc(p)) return proc(p);
+    if (shadowing()) {
+      const real = toProc(p, follow2);
+      if (real !== void 0) return proc(real);
+    }
+    try {
+      return own();
+    } catch (err) {
+      const real = toProc(p, follow2);
+      if (real === void 0) throw err;
+      return proc(real);
+    }
+  };
+  const readOnly = (paths, run) => {
+    const physical = shadowing();
+    for (const [p, follow2] of paths) {
+      if (inProc(p) || physical && toProc(p, follow2) !== void 0) throw syncError("EROFS", p);
+    }
+    return run();
+  };
+  const snapshots = /* @__PURE__ */ new Map();
+  let lastSnapshot = 0;
+  const snapshot = (q) => {
+    lastSnapshot--;
+    snapshots.set(lastSnapshot, tree.read(q));
+    return lastSnapshot;
+  };
+  const late = (p) => {
+    const q = toProc(p, true);
+    return q === void 0 ? void 0 : snapshot(q);
+  };
   const over = {
-    readFile: (p) => inProc(p) ? tree.read(p) : fs.readFile(p),
-    stat: (p) => inProc(p) ? tree.stat(p) : fs.stat(p),
-    lstat: (p) => inProc(p) ? tree.stat(p, false) : fs.lstat(p),
-    readdir: (p) => {
-      if (inProc(p)) return tree.readdir(p);
-      const names = fs.readdir(p);
-      return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
-    },
-    exists: (p) => inProc(p) ? tree.exists(p) : fs.exists(p),
-    readlink: (p) => inProc(p) ? tree.readlink(p) : fs.readlink(p),
-    readdirStat: (p) => {
-      if (!inProc(p)) {
-        const listed = fs.readdirStat(p);
-        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
-        return [...listed, ["proc", tree.stat("/proc")]];
+    readFile: (p) => via(
+      p,
+      (q) => tree.read(q),
+      () => fs.readFile(p)
+    ),
+    stat: (p) => via(
+      p,
+      (q) => tree.stat(q),
+      () => fs.stat(p)
+    ),
+    lstat: (p) => via(
+      p,
+      (q) => tree.stat(q, false),
+      () => fs.lstat(p),
+      false
+    ),
+    readdir: (p) => via(
+      p,
+      (q) => tree.readdir(q),
+      () => {
+        const names = fs.readdir(p);
+        return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
       }
-      return tree.readdir(p).map((name2) => {
+    ),
+    exists: (p) => {
+      if (inProc(p)) return tree.exists(p);
+      const real = shadowing() ? toProc(p, true) : void 0;
+      if (real !== void 0) return tree.exists(real);
+      if (fs.exists(p)) return true;
+      const late2 = toProc(p, true);
+      return late2 !== void 0 && tree.exists(late2);
+    },
+    readlink: (p) => via(
+      p,
+      (q) => tree.readlink(q),
+      () => fs.readlink(p),
+      false
+    ),
+    readdirStat: (p) => via(
+      p,
+      (q) => tree.readdir(q).map((name2) => {
         try {
-          return [name2, tree.stat(`${p}/${name2}`, false)];
+          return [name2, tree.stat(`${q}/${name2}`, false)];
         } catch {
           return [name2, null];
         }
-      });
+      }),
+      () => {
+        const listed = fs.readdirStat(p);
+        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
+        return [...listed, ["proc", tree.stat("/proc")]];
+      }
+    ),
+    rename: (from, to) => readOnly(
+      [
+        [from, false],
+        [to, false]
+      ],
+      () => fs.rename(from, to)
+    ),
+    symlink: (target, link) => readOnly([[link, false]], () => fs.symlink(target, link)),
+    hold: (p, held, open, handle) => {
+      if (handle !== void 0 && snapshots.delete(handle)) return void 0;
+      if (!held) return fs.hold?.(p, held, open, handle);
+      return via(p, snapshot, () => fs.hold?.(p, held, open) ?? late(p));
     },
-    rename: (from, to) => {
-      if (inProc(from) || inProc(to)) throw syncError("EROFS", from);
-      fs.rename(from, to);
+    kept: (handle) => snapshots.has(handle) || fs.kept?.(handle) === true,
+    pinned: (handle) => {
+      const bytes = snapshots.get(handle);
+      return bytes ? frozen(bytes) : fs.pinned?.(handle) ?? fs;
     },
-    hold: (p, ...rest2) => inProc(p) ? void 0 : fs.hold?.(p, ...rest2),
     ...fs.pread ? {
-      pread: (p, at, n, version) => inProc(p) ? tree.read(p).subarray(at, at + n) : fs.pread(p, at, n, version)
+      pread: (p, at, n, version) => via(
+        p,
+        (q) => tree.read(q).subarray(at, at + n),
+        () => fs.pread(p, at, n, version)
+      )
     } : {}
   };
-  for (const name2 of READ_ONLY) {
-    const fn = fs[name2];
-    if (!fn) continue;
-    over[name2] = (p, ...rest2) => {
-      if (inProc(p)) throw syncError("EROFS", p);
-      return fn.call(fs, p, ...rest2);
-    };
+  for (const [names, follow2] of [
+    [FOLLOWING, true],
+    [NOT_FOLLOWING, false]
+  ]) {
+    for (const name2 of names) {
+      const fn = fs[name2];
+      if (!fn) continue;
+      over[name2] = (p, ...rest2) => readOnly([[p, follow2]], () => fn.call(fs, p, ...rest2));
+    }
   }
   return new Proxy(fs, {
     get: (target, key, receiver) => key in over ? over[key] : Reflect.get(target, key, receiver)
   });
 }
-var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, READ_ONLY;
+var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, FOLLOWING, NOT_FOLLOWING, MAX_HOPS2;
 var init_wasi_procfs = __esm({
   "src/process/wasi/wasi-procfs.ts"() {
     "use strict";
     init_sync_fs_wire();
     init_process_fds();
     init_procfs();
+    init_wasi_files();
     DIR_MODE3 = 16749;
     FILE_MODE2 = 33060;
     LINK_MODE3 = 41471;
@@ -6935,20 +7105,9 @@ var init_wasi_procfs = __esm({
         }
       }
     };
-    READ_ONLY = [
-      "writeFile",
-      "mkdir",
-      "rm",
-      "unlink",
-      "rmdir",
-      "symlink",
-      "chmod",
-      "utimes",
-      "lutimes",
-      "create",
-      "pwrite",
-      "truncate"
-    ];
+    FOLLOWING = ["writeFile", "chmod", "utimes", "pwrite", "truncate"];
+    NOT_FOLLOWING = ["mkdir", "rm", "unlink", "rmdir", "lutimes", "create"];
+    MAX_HOPS2 = 40;
   }
 });
 
@@ -8762,6 +8921,7 @@ var init_wasix_host = __esm({
       }
       ttyGet(ptr) {
         const { host, mem } = this;
+        host.interrupted?.();
         const v = mem.view();
         mem.bytes(ptr, 24).fill(0);
         const fd = this.ttyFd();
@@ -8781,6 +8941,7 @@ var init_wasix_host = __esm({
         v.setUint8(ptr + 20, termios && termios.c_lflag & ICANON ? 1 : 0);
       }
       ttySet(ptr) {
+        this.host.interrupted?.();
         const fd = this.ttyFd();
         if (fd === void 0) throw new WasiError("ENOTTY");
         const { sys } = this.host.o.kernel;