@ai-ecoverse/slicc-kernel 1.116.1 → 1.117.0

package/dist/node.js

@@ -931,7 +931,8 @@ function openPipe(capacity) {
       },
       close: () => pipe.closeRead(),
       poll: () => ({ readable: pipe.readReady, writable: false, hangup: pipe.writersGone }),
-      changed: (signal) => pipe.changed(signal)
+      changed: (signal) => pipe.changed(signal),
+      identity: pipe
     }),
     write: new OpenFile({
       write: async (bytes, signal) => {
@@ -943,7 +944,8 @@ function openPipe(capacity) {
       },
       close: () => pipe.closeWrite(),
       poll: () => ({ readable: false, writable: pipe.writeReady, hangup: pipe.readersGone }),
-      changed: (signal) => pipe.changed(signal)
+      changed: (signal) => pipe.changed(signal),
+      identity: pipe
     })
   };
 }
@@ -4817,13 +4819,20 @@ var OpfsFs = class {
     if (handle.kind === "directory") throw fsError("EISDIR", path);
     return handle;
   }
+  async refuseNode(path, empty) {
+    if (!empty) return;
+    const [entry] = await this.meta.get([(await this.locate(path, true)).path]);
+    if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+  }
   async readFileBuffer(path) {
     const handle = await this.existing(path);
-    return this.retrying(
+    const bytes = await this.retrying(
       path,
       async () => new Uint8Array(await (await handle.getFile()).arrayBuffer()),
       false
     );
+    await this.refuseNode(path, bytes.length === 0);
+    return bytes;
   }
   async readVersioned(path, cached = false) {
     const handle = await this.existing(path);
@@ -4833,6 +4842,7 @@ var OpfsFs = class {
         const stamp = await this.stamp(path, cached);
         const file = await handle.getFile();
         const bytes = new Uint8Array(await file.arrayBuffer());
+        await this.refuseNode(path, bytes.length === 0);
         return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
       },
       false
@@ -4854,7 +4864,11 @@ var OpfsFs = class {
     const handle = await this.existing(path);
     return this.retrying(
       path,
-      async () => new Uint8Array(await (await handle.getFile()).slice(offset, offset + length2).arrayBuffer()),
+      async () => {
+        const file = await handle.getFile();
+        await this.refuseNode(path, file.size === 0);
+        return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
+      },
       false
     );
   }
@@ -4870,6 +4884,7 @@ var OpfsFs = class {
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
+    await this.refuseNode(path, (await handle.getFile()).size === 0);
     const resolve2 = this.ranged || this.remote?.watched();
     const target = resolve2 || this.counted.length > 0 ? (await this.locate(path, true)).path : path;
     await this.counting(target);
@@ -4922,6 +4937,10 @@ var OpfsFs = class {
   }
   async fileFor(path) {
     const [target, existed] = await this.writeTarget(path);
+    if (existed) {
+      const [entry] = await this.meta.get([target]);
+      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+    }
     const [dir, name2] = await this.parent(target);
     try {
       const handle = await this.inDir(
@@ -6559,7 +6578,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.116.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.117.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9703,6 +9722,7 @@ var FifoTable = class {
     let open = true;
     return new OpenFile({
       fifo: path,
+      identity: fifo,
       ...reads ? {
         read: async (max, signal) => {
           try {
@@ -13136,7 +13156,71 @@ function lockRange(start2, len) {
   if (from < 0) throw new KernelError("EINVAL");
   return { start: from, end };
 }
+function changedAt(wakers, key, signal) {
+  return new Promise((resolve2, reject) => {
+    const set3 = wakers.get(key) ?? /* @__PURE__ */ new Set();
+    wakers.set(key, set3);
+    const done4 = () => {
+      set3.delete(wake);
+      if (set3.size === 0 && wakers.get(key) === set3) wakers.delete(key);
+      signal.removeEventListener("abort", abort);
+    };
+    const wake = () => {
+      done4();
+      resolve2();
+    };
+    const abort = () => {
+      done4();
+      reject(new KernelError("EINTR"));
+    };
+    set3.add(wake);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+}
+function wakeAt(wakers, key) {
+  for (const wake of [...wakers.get(key) ?? []]) wake();
+}
+var FlockTable = class {
+  held = /* @__PURE__ */ new Map();
+  keys = /* @__PURE__ */ new WeakMap();
+  wakers = /* @__PURE__ */ new Map();
+  free(key, owner, kind) {
+    for (const [other, has] of this.held.get(key) ?? [])
+      if (other !== owner && (kind === "exclusive" || has === "exclusive")) return false;
+    return true;
+  }
+  set(key, owner, kind) {
+    const has = this.held.get(key)?.get(owner);
+    if (has === kind) return true;
+    if (has !== void 0) this.drop(owner);
+    if (kind === "unlock") return true;
+    if (!this.free(key, owner, kind)) return false;
+    const holders = this.held.get(key) ?? /* @__PURE__ */ new Map();
+    holders.set(owner, kind);
+    this.held.set(key, holders);
+    this.keys.set(owner, key);
+    return true;
+  }
+  async wait(key, owner, kind, blocking) {
+    if (this.set(key, owner, kind)) return;
+    const signal = blocking();
+    while (!this.set(key, owner, kind)) {
+      if (signal.aborted) throw new KernelError("EINTR");
+      await changedAt(this.wakers, key, signal);
+    }
+  }
+  drop(owner) {
+    const key = this.keys.get(owner);
+    if (key === void 0) return;
+    this.keys.delete(owner);
+    const holders = this.held.get(key);
+    holders?.delete(owner);
+    if (holders?.size === 0) this.held.delete(key);
+    wakeAt(this.wakers, key);
+  }
+};
 var LockTable = class {
+  flocks = new FlockTable();
   records = /* @__PURE__ */ new Map();
   blocked = /* @__PURE__ */ new Map();
   wakers = /* @__PURE__ */ new Map();
@@ -13194,28 +13278,10 @@ var LockTable = class {
     return false;
   }
   changed(key, signal) {
-    return new Promise((resolve2, reject) => {
-      const set3 = this.wakers.get(key) ?? /* @__PURE__ */ new Set();
-      this.wakers.set(key, set3);
-      const done4 = () => {
-        set3.delete(wake);
-        if (set3.size === 0 && this.wakers.get(key) === set3) this.wakers.delete(key);
-        signal.removeEventListener("abort", abort);
-      };
-      const wake = () => {
-        done4();
-        resolve2();
-      };
-      const abort = () => {
-        done4();
-        reject(new KernelError("EINTR"));
-      };
-      set3.add(wake);
-      signal.addEventListener("abort", abort, { once: true });
-    });
+    return changedAt(this.wakers, key, signal);
   }
   wake(key) {
-    for (const wake of [...this.wakers.get(key) ?? []]) wake();
+    wakeAt(this.wakers, key);
   }
   store(key, locks) {
     if (locks.length === 0) this.records.delete(key);
@@ -13280,6 +13346,7 @@ var HOST_OPS = [
   "lk-set",
   "lk-get",
   "lk-close",
+  "flock",
   "async-submit",
   "async-wait",
   "async-take",
@@ -13432,6 +13499,8 @@ async function hostSyscall(req, ctx) {
     case "lk-get":
     case "lk-close":
       return recordLock2(req, ctx);
+    case "flock":
+      return flock(req, ctx);
     case "async-submit":
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
       if (req.ack) ctx.ops.ack(req.ack);
@@ -13454,6 +13523,17 @@ async function hostSyscall(req, ctx) {
       return done2;
   }
 }
+var FLOCK_KINDS = /* @__PURE__ */ new Set(["shared", "exclusive", "unlock"]);
+async function flock(req, ctx) {
+  const { locks, flockOf } = ctx;
+  if (!locks || !flockOf) throw new KernelError("ENOLCK");
+  if (!FLOCK_KINDS.has(req.kind)) throw new KernelError("EINVAL");
+  const { key, owner } = await flockOf(req.fd);
+  if (req.kind !== "unlock" && req.wait)
+    await locks.flocks.wait(key, owner, req.kind, ctx.blocking);
+  else if (!locks.flocks.set(key, owner, req.kind)) throw new KernelError("EAGAIN");
+  return done2;
+}
 async function recordLock2(req, ctx) {
   const { locks, fileKey } = ctx;
   if (!locks || !fileKey) throw new KernelError("ENOLCK");
@@ -17424,6 +17504,18 @@ var fileKeys = /* @__PURE__ */ new WeakMap();
 function identityKey(st, path) {
   return st.ino === void 0 ? path : `${st.dev ?? 0}:${st.ino}`;
 }
+var objectIds = /* @__PURE__ */ new WeakMap();
+var nextObjectId = 1;
+function objectKey(file) {
+  const at = file.tty ?? file.identity ?? file.pty ?? file;
+  let id2 = objectIds.get(at);
+  if (id2 === void 0) {
+    id2 = nextObjectId++;
+    objectIds.set(at, id2);
+  }
+  return `object:${id2}`;
+}
+var flockHooked = /* @__PURE__ */ new WeakSet();
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 function timeLeft(req, started) {
@@ -17724,6 +17816,7 @@ var WasmProcess = class {
           pid: this.pid,
           owner: () => this.lockOwner(),
           fileKey: (target, kind, setting) => this.lockKey(target, kind, setting),
+          flockOf: (fd) => this.flockOf(fd),
           locks: this.options.locks,
           ops: this.asyncOps,
           blocking: () => this.blockingSignal(cancelled),
@@ -17792,6 +17885,7 @@ var WasmProcess = class {
       throw new KernelError("EBADF");
     const known = file ? fileKeys.get(file) : this.pathKeys.get(target.path ?? "");
     if (kind === "close" && !file && target.path !== void 0) this.pathKeys.delete(target.path);
+    if (access2 && !access2.stat) return objectKey(access2);
     const want = kind === "read" ? R_OK : kind === "write" ? W_OK : 0;
     const path = await this.lockPath(target, want);
     if (known !== void 0) return known;
@@ -17806,6 +17900,33 @@ var WasmProcess = class {
     else if (this.pathKeys.size < 4096) this.pathKeys.set(path, key);
     return key;
   }
+  async flockOf(fd) {
+    const open = this.fds.get(fd);
+    const { locks } = this.options;
+    if (locks && !flockHooked.has(open)) {
+      flockHooked.add(open);
+      open.onClose(() => locks.flocks.drop(open));
+    }
+    return { key: await this.objectKeyOf(open), owner: open };
+  }
+  async objectKeyOf(open) {
+    const { file } = open;
+    const meta = file.heldMeta;
+    if (meta && "device" in meta) return `device:${meta.device}`;
+    if (meta && "dir" in meta) {
+      const st2 = await this.options.fs.stat?.(meta.dir).catch(() => void 0);
+      return st2 ? identityKey(st2, meta.dir) : objectKey(file);
+    }
+    const known = fileKeys.get(open);
+    if (known !== void 0) return known;
+    const vfs = await file.stat?.().catch(() => void 0);
+    if (!vfs || vfs.orphan) return objectKey(file);
+    const st = await this.options.fs.stat?.(vfs.path).catch(() => void 0);
+    if (!st) return objectKey(file);
+    const key = identityKey(st, vfs.path);
+    fileKeys.set(open, key);
+    return key;
+  }
   async dropRecordLocks(fd) {
     const { locks } = this.options;
     const owner = this.options.jobs?.shown(this.pid) ?? this.pid;
@@ -20086,6 +20207,7 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
     },
     changed,
     ...file.tty ? { tty: file.tty } : {},
+    identity: file.identity ?? file,
     ...file.clipboard ? { clipboard: file.clipboard } : {},
     ...file.write ? {
       write: async (bytes, signal) => {