@ai-ecoverse/slicc-kernel 1.99.2 → 1.100.0

package/dist/node-process-worker.js

@@ -1484,6 +1484,69 @@ var init_cred = __esm({
   }
 });
 
+// src/process/wasi/slicc-lock.ts
+function kindOf(type) {
+  if (type === F_RDLCK) return "read";
+  if (type === F_WRLCK) return "write";
+  if (type === F_UNLCK) return "unlock";
+  throw new WasiError("EINVAL");
+}
+function baseOf(file, whence) {
+  if (whence === SEEK_SET) return 0;
+  if (whence === SEEK_CUR) return file.offset();
+  if (whence === SEEK_END) return file.size();
+  throw new WasiError("EINVAL");
+}
+function writeHolder(view, at, found) {
+  if (!found) {
+    view.setInt16(at, F_UNLCK, true);
+    return;
+  }
+  view.setInt16(at, found.kind === "read" ? F_RDLCK : F_WRLCK, true);
+  view.setInt16(at + 2, SEEK_SET, true);
+  view.setBigInt64(at + 8, BigInt(found.start), true);
+  view.setBigInt64(at + 16, BigInt(found.len), true);
+  view.setInt32(at + 24, found.pid, true);
+}
+function lockImports(host) {
+  return {
+    fcntl_lock: (fd, cmd, at) => {
+      if (cmd !== F_GETLK && cmd !== F_SETLK && cmd !== F_SETLKW) throw new WasiError("EINVAL");
+      const file = host.file(fd);
+      const view = host.mem.view();
+      const kind = kindOf(view.getInt16(at, true));
+      const start2 = baseOf(file, view.getInt16(at + 2, true)) + Number(view.getBigInt64(at + 8, true));
+      const len = Number(view.getBigInt64(at + 16, true));
+      if (cmd === F_GETLK) {
+        if (kind === "unlock") throw new WasiError("EINVAL");
+        writeHolder(view, at, host.calls.get(file.target, kind, start2, len));
+        return;
+      }
+      if (kind === "read" && file.readable === false || kind === "write" && file.writable === false)
+        throw new WasiError("EBADF");
+      if (kind !== "write") host.flush(file);
+      host.calls.set(file.target, kind, start2, len, cmd === F_SETLKW);
+      if (kind !== "unlock") host.locked();
+    }
+  };
+}
+var F_GETLK, F_SETLK, F_SETLKW, F_RDLCK, F_WRLCK, F_UNLCK, SEEK_SET, SEEK_CUR, SEEK_END;
+var init_slicc_lock = __esm({
+  "src/process/wasi/slicc-lock.ts"() {
+    "use strict";
+    init_wasi_files();
+    F_GETLK = 12;
+    F_SETLK = 13;
+    F_SETLKW = 14;
+    F_RDLCK = 0;
+    F_WRLCK = 1;
+    F_UNLCK = 2;
+    SEEK_SET = 0;
+    SEEK_CUR = 1;
+    SEEK_END = 2;
+  }
+});
+
 // src/process/wasi/slicc-sem.ts
 function remainingMs(deadline, now) {
   if (deadline <= now) return 0;
@@ -2029,6 +2092,17 @@ var init_wasi_fds = __esm({
         }
         return out;
       }
+      locking = false;
+      holdLocks() {
+        this.locking = true;
+      }
+      dropLocks(e) {
+        if (!this.locking || e?.type !== "file") return;
+        try {
+          this.kernel.call({ op: "lk-close", path: e.file.path });
+        } catch {
+        }
+      }
       close(fd) {
         const e = this.get(fd);
         this.table.delete(fd);
@@ -2037,6 +2111,7 @@ var init_wasi_fds = __esm({
           this.kernel.sys.close(fd);
         } finally {
           this.release(e);
+          this.dropLocks(e);
           this.bump();
         }
       }
@@ -2055,6 +2130,7 @@ var init_wasi_fds = __esm({
           if (this.cloexec.delete(from)) this.cloexec.add(to);
         }
         if (old) this.release(old);
+        this.dropLocks(old);
         this.bump();
       }
       release(e) {
@@ -3171,6 +3247,7 @@ var init_wasi_host = __esm({
     init_physical_path();
     init_cpu_clock();
     init_cred();
+    init_slicc_lock();
     init_slicc_sem();
     init_wasi_abi();
     init_wasi_fds();
@@ -3393,6 +3470,26 @@ var init_wasi_host = __esm({
             void this.o.kernel.call({ op: "proc-setcred", change });
           },
           ...semImports(this),
+          ...lockImports({
+            mem,
+            file: (fd) => this.lockedFile(fd),
+            flush: (file) => {
+              if (file.path !== void 0) this.fds.flushPath(file.path);
+              else if (file.target.fd !== void 0) this.o.kernel.sys.flush(file.target.fd);
+            },
+            locked: () => this.fds.holdLocks(),
+            calls: {
+              set: (target, kind, start2, len, wait2) => void this.o.kernel.call({
+                op: "lk-set",
+                ...target,
+                kind,
+                start: start2,
+                len,
+                ...wait2 ? { wait: wait2 } : {}
+              }),
+              get: (target, kind, start2, len) => this.o.kernel.call({ op: "lk-get", ...target, kind, start: start2, len })
+            }
+          }),
           groups_get: (buf, cap, count) => {
             const { groups } = this.o.kernel.call({ op: "proc-cred" });
             if (cap !== 0 && cap < groups.length) throw new WasiError("EINVAL");
@@ -3785,6 +3882,26 @@ var init_wasi_host = __esm({
         }
         e.path = path;
       }
+      lockedFile(fd) {
+        const e = this.fds.get(fd);
+        if (e.type === "file") {
+          const { file } = e;
+          return {
+            target: { path: file.path },
+            path: file.path,
+            readable: file.readable,
+            writable: file.writable,
+            offset: () => file.offset,
+            size: () => file.size()
+          };
+        }
+        if (e.type !== "kernel" || this.fds.kind(fd, e) !== "file") throw new WasiError("EBADF");
+        return {
+          target: { fd },
+          offset: () => this.o.kernel.sys.seek(fd, 0, WHENCE.CUR),
+          size: () => this.kernelStat(fd).size
+        };
+      }
       kernelStat(fd) {
         return this.o.kernel.call({ op: "fd-vfs-stat", fd });
       }
@@ -4650,7 +4767,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.99.2" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.100.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7246,8 +7363,8 @@ function createStreamOps(h) {
     },
     llseek(stream, offset, whence) {
       let pos = offset;
-      if (whence === SEEK_CUR) pos += stream.position;
-      else if (whence === SEEK_END && Fs.isFile(stream.node.mode)) {
+      if (whence === SEEK_CUR2) pos += stream.position;
+      else if (whence === SEEK_END2 && Fs.isFile(stream.node.mode)) {
         const s = stream.node.live;
         pos += rangedOf(stream.node)?.size() ?? (s.loaded ? s.len : statOf(stream.node).size);
       }
@@ -7607,7 +7724,7 @@ function readingLinks(Fs) {
     }
   };
 }
-var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END, EARLY_WHOLE_FILE, O_APPEND4, O_ACCMODE, O_TRUNC, O_PATH, stale, opening;
+var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR2, SEEK_END2, EARLY_WHOLE_FILE, O_APPEND4, O_ACCMODE, O_TRUNC, O_PATH, stale, opening;
 var init_live_vfs_fs = __esm({
   "src/realm/live-vfs-fs.ts"() {
     "use strict";
@@ -7623,8 +7740,8 @@ var init_live_vfs_fs = __esm({
     PERM_MASK = 4095;
     DEFAULT_DIR_PERM = 493;
     UMASK = 18;
-    SEEK_CUR = 1;
-    SEEK_END = 2;
+    SEEK_CUR2 = 1;
+    SEEK_END2 = 2;
     EARLY_WHOLE_FILE = 64 * 1024;
     O_APPEND4 = 1024;
     O_ACCMODE = 3;
@@ -7653,23 +7770,23 @@ function sizeOf(Fs, stream) {
   const st = Fs.fstat?.(stream.fd);
   return st?.size ?? 0;
 }
-function kindOf(type) {
-  if (type === F_RDLCK) return "read";
-  if (type === F_WRLCK) return "write";
-  return type === F_UNLCK ? "unlock" : void 0;
+function kindOf2(type) {
+  if (type === F_RDLCK2) return "read";
+  if (type === F_WRLCK2) return "write";
+  return type === F_UNLCK2 ? "unlock" : void 0;
 }
 function readFlock(view, at, base) {
-  const kind = kindOf(view.getInt16(at, true));
+  const kind = kindOf2(view.getInt16(at, true));
   if (kind === void 0) return void 0;
   const start2 = base(view.getInt16(at + 2, true)) + Number(view.getBigInt64(at + 8, true));
   return { kind, start: start2, len: Number(view.getBigInt64(at + 16, true)) };
 }
-function writeHolder(view, at, found) {
+function writeHolder2(view, at, found) {
   if (!found) {
-    view.setInt16(at, F_UNLCK, true);
+    view.setInt16(at, F_UNLCK2, true);
     return;
   }
-  view.setInt16(at, found.kind === "read" ? F_RDLCK : F_WRLCK, true);
+  view.setInt16(at, found.kind === "read" ? F_RDLCK2 : F_WRLCK2, true);
   view.setInt16(at + 2, 0, true);
   view.setBigInt64(at + 8, BigInt(found.start), true);
   view.setBigInt64(at + 16, BigInt(found.len), true);
@@ -7679,12 +7796,12 @@ function refused2(kind, flags) {
   const access = flags & O_ACCMODE2;
   return kind === "write" && access === O_RDONLY || kind === "read" && access === O_WRONLY4;
 }
-function baseOf(Fs, stream) {
-  return (whence) => whence === SEEK_CUR2 ? stream.position : whence === SEEK_END2 ? sizeOf(Fs, stream) : 0;
+function baseOf2(Fs, stream) {
+  return (whence) => whence === SEEK_CUR3 ? stream.position : whence === SEEK_END3 ? sizeOf(Fs, stream) : 0;
 }
 function recordLock(fcntl, deps) {
   return (fd, cmd, varargs) => {
-    if (cmd !== F_GETLK && cmd !== F_SETLK && cmd !== F_SETLKW) return fcntl(fd, cmd, varargs);
+    if (cmd !== F_GETLK2 && cmd !== F_SETLK2 && cmd !== F_SETLKW2) return fcntl(fd, cmd, varargs);
     const Fs = deps.fs();
     const buffer = deps.memory();
     const stream = Fs?.getStream(fd);
@@ -7692,11 +7809,11 @@ function recordLock(fcntl, deps) {
     if (!Fs || !buffer || !stream || !target) return fcntl(fd, cmd, varargs);
     const view = new DataView(buffer);
     const at = view.getUint32(varargs, true);
-    const lock = readFlock(view, at, baseOf(Fs, stream));
-    if (!lock || cmd === F_GETLK && lock.kind === "unlock") return -wasiErrno("EINVAL");
+    const lock = readFlock(view, at, baseOf2(Fs, stream));
+    if (!lock || cmd === F_GETLK2 && lock.kind === "unlock") return -wasiErrno("EINVAL");
     try {
-      if (cmd === F_GETLK) {
-        writeHolder(
+      if (cmd === F_GETLK2) {
+        writeHolder2(
           view,
           at,
           deps.kernel.getLock(target, lock.kind, lock.start, lock.len)
@@ -7705,7 +7822,7 @@ function recordLock(fcntl, deps) {
       }
       if (refused2(lock.kind, stream.flags)) return -wasiErrno("EBADF");
       if (lock.kind !== "write") deps.flush();
-      deps.kernel.setLock(target, lock.kind, lock.start, lock.len, cmd === F_SETLKW);
+      deps.kernel.setLock(target, lock.kind, lock.start, lock.len, cmd === F_SETLKW2);
       if (lock.kind !== "unlock") held.set(Fs, true);
       return 0;
     } catch (err) {
@@ -7726,20 +7843,20 @@ function closeDropsLocks(Fs, kernel) {
     }
   };
 }
-var F_GETLK, F_SETLK, F_SETLKW, F_RDLCK, F_WRLCK, F_UNLCK, SEEK_CUR2, SEEK_END2, O_ACCMODE2, O_RDONLY, O_WRONLY4, held;
+var F_GETLK2, F_SETLK2, F_SETLKW2, F_RDLCK2, F_WRLCK2, F_UNLCK2, SEEK_CUR3, SEEK_END3, O_ACCMODE2, O_RDONLY, O_WRONLY4, held;
 var init_process_locks = __esm({
   "src/process/process-locks.ts"() {
     "use strict";
     init_live_vfs_fs();
     init_wasi_errno();
-    F_GETLK = 12;
-    F_SETLK = 13;
-    F_SETLKW = 14;
-    F_RDLCK = 0;
-    F_WRLCK = 1;
-    F_UNLCK = 2;
-    SEEK_CUR2 = 1;
-    SEEK_END2 = 2;
+    F_GETLK2 = 12;
+    F_SETLK2 = 13;
+    F_SETLKW2 = 14;
+    F_RDLCK2 = 0;
+    F_WRLCK2 = 1;
+    F_UNLCK2 = 2;
+    SEEK_CUR3 = 1;
+    SEEK_END3 = 2;
     O_ACCMODE2 = 3;
     O_RDONLY = 0;
     O_WRONLY4 = 1;
@@ -8387,14 +8504,14 @@ function cString(memory, at) {
   const bytes = new Uint8Array(memory.buffer, at);
   return new TextDecoder().decode(bytes.subarray(0, bytes.indexOf(0)));
 }
-function baseOf2(Fs, dirfd) {
+function baseOf3(Fs, dirfd) {
   return dirfd === AT_FDCWD ? Fs.cwd?.() ?? "/" : Fs.getStream?.(dirfd)?.path ?? "/";
 }
 function readonlyRefusal(Fs, memory, call2) {
   if (!(call2.amode & W_ACCESS)) return 0;
   try {
     const name2 = cString(memory, call2.path);
-    const abs = name2.startsWith("/") ? name2 : `${baseOf2(Fs, call2.dirfd)}/${name2}`;
+    const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call2.dirfd)}/${name2}`;
     const follow2 = (call2.flags & AT_SYMLINK_NOFOLLOW2) === 0;
     const { node } = Fs.lookupPath.call(Fs, abs, {
       follow: follow2
@@ -8409,7 +8526,7 @@ function readonlyRefusal(Fs, memory, call2) {
 }
 function kernelChecks(Fs, memory, call2) {
   const name2 = cString(memory, call2.path);
-  const abs = name2.startsWith("/") ? name2 : `${baseOf2(Fs, call2.dirfd)}/${name2}`;
+  const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call2.dirfd)}/${name2}`;
   const lookupPath = Fs.lookupPath;
   const { node } = lookupPath.call(Fs, abs, { follow: (call2.flags & AT_SYMLINK_NOFOLLOW2) === 0 });
   const bridge = node.live ? node.mount.opts.bridge : void 0;
@@ -8445,7 +8562,7 @@ function kernelLink(imports, fs, memory, glue) {
       if (!Fs?.lookupPath || !heap) return own(olddirfd, oldpath, newdirfd, newpath, flags);
       const at = (dirfd, ptr) => {
         const name2 = cString(heap, ptr);
-        return name2.startsWith("/") ? name2 : `${baseOf2(Fs, dirfd)}/${name2}`;
+        return name2.startsWith("/") ? name2 : `${baseOf3(Fs, dirfd)}/${name2}`;
       };
       try {
         const from = at(olddirfd, oldpath);