@ai-ecoverse/slicc-kernel 1.99.2 → 1.100.0

package/dist/process-worker.js

@@ -2475,7 +2475,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";
   }
 });
@@ -6665,6 +6665,69 @@ var init_wasi_files = __esm({
   }
 });
 
+// src/process/wasi/slicc-lock.ts
+function kindOf2(type) {
+  if (type === F_RDLCK2) return "read";
+  if (type === F_WRLCK2) return "write";
+  if (type === F_UNLCK2) return "unlock";
+  throw new WasiError("EINVAL");
+}
+function baseOf3(file, whence) {
+  if (whence === SEEK_SET) return 0;
+  if (whence === SEEK_CUR3) return file.offset();
+  if (whence === SEEK_END3) return file.size();
+  throw new WasiError("EINVAL");
+}
+function writeHolder2(view, at, found) {
+  if (!found) {
+    view.setInt16(at, F_UNLCK2, true);
+    return;
+  }
+  view.setInt16(at, found.kind === "read" ? F_RDLCK2 : F_WRLCK2, 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_GETLK2 && cmd !== F_SETLK2 && cmd !== F_SETLKW2) throw new WasiError("EINVAL");
+      const file = host.file(fd);
+      const view = host.mem.view();
+      const kind = kindOf2(view.getInt16(at, true));
+      const start2 = baseOf3(file, view.getInt16(at + 2, true)) + Number(view.getBigInt64(at + 8, true));
+      const len = Number(view.getBigInt64(at + 16, true));
+      if (cmd === F_GETLK2) {
+        if (kind === "unlock") throw new WasiError("EINVAL");
+        writeHolder2(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_SETLKW2);
+      if (kind !== "unlock") host.locked();
+    }
+  };
+}
+var F_GETLK2, F_SETLK2, F_SETLKW2, F_RDLCK2, F_WRLCK2, F_UNLCK2, SEEK_SET, SEEK_CUR3, SEEK_END3;
+var init_slicc_lock = __esm({
+  "src/process/wasi/slicc-lock.ts"() {
+    "use strict";
+    init_wasi_files();
+    F_GETLK2 = 12;
+    F_SETLK2 = 13;
+    F_SETLKW2 = 14;
+    F_RDLCK2 = 0;
+    F_WRLCK2 = 1;
+    F_UNLCK2 = 2;
+    SEEK_SET = 0;
+    SEEK_CUR3 = 1;
+    SEEK_END3 = 2;
+  }
+});
+
 // src/process/wasi/slicc-sem.ts
 function remainingMs(deadline, now) {
   if (deadline <= now) return 0;
@@ -7133,6 +7196,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);
@@ -7141,6 +7215,7 @@ var init_wasi_fds = __esm({
           this.kernel.sys.close(fd);
         } finally {
           this.release(e);
+          this.dropLocks(e);
           this.bump();
         }
       }
@@ -7159,6 +7234,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) {
@@ -8229,6 +8305,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();
@@ -8451,6 +8528,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");
@@ -8843,6 +8940,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 });
       }