@ai-ecoverse/slicc-kernel 1.96.0 → 1.97.1

package/dist/kernel-worker.js

@@ -7695,10 +7695,10 @@ function envOf(pkg, raw) {
   }
   return env;
 }
-function envFields(merged) {
+function envFields(merged2) {
   const env = {};
   const unset = [];
-  for (const [key, value] of Object.entries(merged)) {
+  for (const [key, value] of Object.entries(merged2)) {
     if (value === null) unset.push(key);
     else env[key] = value;
   }
@@ -12054,7 +12054,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.96.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.97.1" : "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
@@ -12731,23 +12731,115 @@ async function epollSyscall(req, proc) {
   }
 }
 
-// src/kernel/host-ops.ts
-var HOST_OPS = [
-  "lock",
-  "unlock",
-  "async-submit",
-  "async-wait",
-  "async-take",
-  "async-resolve",
-  "async-hold",
-  "async-cancel",
-  "async-settle",
-  "async-close"
-];
-var json3 = (value) => ({ ok: true, kind: "json", json: value });
-var done2 = { ok: true, kind: "void" };
+// src/kernel/locks.ts
+var overlaps = (a, b) => a.start < b.end && b.start < a.end;
+var clashes = (lock, owner, want) => lock.owner !== owner && overlaps(lock, want) && (lock.kind === "write" || want.kind === "write");
+function lockRange(start2, len) {
+  if (!Number.isSafeInteger(start2) || !Number.isSafeInteger(len)) throw new KernelError("EINVAL");
+  const from = len < 0 ? start2 + len : start2;
+  const end = len === 0 ? Number.POSITIVE_INFINITY : len < 0 ? start2 : start2 + len;
+  if (from < 0) throw new KernelError("EINVAL");
+  return { start: from, end };
+}
 var LockTable = class {
+  records = /* @__PURE__ */ new Map();
+  blocked = /* @__PURE__ */ new Map();
+  wakers = /* @__PURE__ */ new Map();
   held = /* @__PURE__ */ new Map();
+  holder(key, owner, want) {
+    return this.records.get(key)?.find((lock) => clashes(lock, owner, want));
+  }
+  set(key, owner, kind, start2, end) {
+    if (kind !== "unlock" && this.holder(key, owner, { key, kind, start: start2, end })) return false;
+    const range = { start: start2, end };
+    const kept = [];
+    for (const lock of this.records.get(key) ?? []) {
+      if (lock.owner !== owner || !overlaps(lock, range)) kept.push(lock);
+      else {
+        if (lock.start < start2) kept.push({ ...lock, end: start2 });
+        if (lock.end > end) kept.push({ ...lock, start: end });
+      }
+    }
+    if (kind !== "unlock") kept.push({ owner, kind, start: start2, end });
+    this.store(key, merged(kept));
+    this.wake(key);
+    return true;
+  }
+  async wait(key, owner, kind, range, blocking) {
+    const want = { key, kind, ...range };
+    let signal;
+    for (; ; ) {
+      const holder = this.holder(key, owner, want);
+      if (!holder) {
+        this.set(key, owner, kind, range.start, range.end);
+        return;
+      }
+      if (this.waitsOn(holder.owner, owner)) throw new KernelError("EDEADLK");
+      signal ??= blocking();
+      if (signal.aborted) throw new KernelError("EINTR");
+      this.blocked.set(owner, want);
+      try {
+        await this.changed(key, signal);
+      } finally {
+        this.blocked.delete(owner);
+      }
+    }
+  }
+  waitsOn(from, target) {
+    const seen = /* @__PURE__ */ new Set();
+    for (let at = from; at !== void 0 && !seen.has(at); ) {
+      seen.add(at);
+      const want = this.blocked.get(at);
+      if (!want) return false;
+      const holder = this.holder(want.key, at, want);
+      if (!holder) return false;
+      if (holder.owner === target) return true;
+      at = holder.owner;
+    }
+    return false;
+  }
+  changed(key, signal) {
+    return new Promise((resolve2, reject) => {
+      const set2 = this.wakers.get(key) ?? /* @__PURE__ */ new Set();
+      this.wakers.set(key, set2);
+      const done4 = () => {
+        set2.delete(wake);
+        if (set2.size === 0 && this.wakers.get(key) === set2) this.wakers.delete(key);
+        signal.removeEventListener("abort", abort);
+      };
+      const wake = () => {
+        done4();
+        resolve2();
+      };
+      const abort = () => {
+        done4();
+        reject(new KernelError("EINTR"));
+      };
+      set2.add(wake);
+      signal.addEventListener("abort", abort, { once: true });
+    });
+  }
+  wake(key) {
+    for (const wake of [...this.wakers.get(key) ?? []]) wake();
+  }
+  store(key, locks) {
+    if (locks.length === 0) this.records.delete(key);
+    else this.records.set(key, locks);
+  }
+  holds(owner) {
+    for (const locks of this.records.values())
+      if (locks.some((l) => l.owner === owner)) return true;
+    return false;
+  }
+  dropFile(key, owner) {
+    const locks = this.records.get(key);
+    if (!locks?.some((l) => l.owner === owner)) return;
+    this.store(
+      key,
+      locks.filter((l) => l.owner !== owner)
+    );
+    this.wake(key);
+  }
   lock(pid, path, exclusive, fd) {
     const holders = this.held.get(path) ?? /* @__PURE__ */ new Map();
     for (const [other, h] of holders) if (other !== pid && (exclusive || h.exclusive)) return false;
@@ -12771,8 +12863,39 @@ var LockTable = class {
   }
   release(pid) {
     for (const path of [...this.held.keys()]) this.unlock(pid, path);
+    for (const key of [...this.records.keys()]) this.dropFile(key, pid);
   }
 };
+function merged(locks) {
+  const sorted = [...locks].sort((a, b) => a.owner - b.owner || a.start - b.start);
+  const out = [];
+  for (const lock of sorted) {
+    const last = out[out.length - 1];
+    if (last && last.owner === lock.owner && last.kind === lock.kind && last.end >= lock.start) {
+      last.end = Math.max(last.end, lock.end);
+    } else out.push({ ...lock });
+  }
+  return out;
+}
+
+// src/kernel/host-ops.ts
+var HOST_OPS = [
+  "lock",
+  "unlock",
+  "lk-set",
+  "lk-get",
+  "lk-close",
+  "async-submit",
+  "async-wait",
+  "async-take",
+  "async-resolve",
+  "async-hold",
+  "async-cancel",
+  "async-settle",
+  "async-close"
+];
+var json3 = (value) => ({ ok: true, kind: "json", json: value });
+var done2 = { ok: true, kind: "void" };
 var KEPT_OPS = /* @__PURE__ */ new Set(["fd-write"]);
 var unknownSettled = false;
 var AsyncOps = class {
@@ -12909,6 +13032,10 @@ async function hostSyscall(req, ctx) {
     case "unlock":
       ctx.locks?.unlock(ctx.pid, req.path);
       return done2;
+    case "lk-set":
+    case "lk-get":
+    case "lk-close":
+      return recordLock2(req, ctx);
     case "async-submit":
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
       if (req.ack) ctx.ops.ack(req.ack);
@@ -12931,6 +13058,33 @@ async function hostSyscall(req, ctx) {
       return done2;
   }
 }
+async function recordLock2(req, ctx) {
+  const { locks, fileKey } = ctx;
+  if (!locks || !fileKey) throw new KernelError("ENOLCK");
+  const owner = ctx.owner?.() ?? ctx.pid;
+  const target = {
+    ...req.path !== void 0 ? { path: req.path } : {},
+    ...req.fd !== void 0 ? { fd: req.fd } : {}
+  };
+  if (req.op === "lk-close") {
+    locks.dropFile(await fileKey(target, "close"), owner);
+    return done2;
+  }
+  const range = lockRange(req.start, req.len);
+  const key = await fileKey(target, req.kind);
+  if (req.op === "lk-get") {
+    const held = locks.holder(key, owner, { key, kind: req.kind, ...range });
+    if (!held) return json3(null);
+    const len = held.end === Number.POSITIVE_INFINITY ? 0 : held.end - held.start;
+    return json3({ kind: held.kind, pid: held.owner, start: held.start, len });
+  }
+  if (req.kind !== "unlock" && req.wait) {
+    await locks.wait(key, owner, req.kind, range, ctx.blocking);
+    return done2;
+  }
+  if (!locks.set(key, owner, req.kind, range.start, range.end)) throw new KernelError("EAGAIN");
+  return done2;
+}
 
 // src/kernel/net/loopback-transport.ts
 var LOOPBACK_TRAITS = {
@@ -15461,6 +15615,8 @@ var WasmProcess = class {
       if (isHostSyscall(req)) {
         return await hostSyscall(req, {
           pid: this.pid,
+          owner: () => this.lockOwner(),
+          fileKey: (target, kind) => this.lockKey(target, kind),
           locks: this.options.locks,
           ops: this.asyncOps,
           blocking: () => this.blockingSignal(cancelled),
@@ -15487,6 +15643,44 @@ var WasmProcess = class {
       throw e;
     }
   }
+  lockOwners = /* @__PURE__ */ new Set();
+  lockChecked = /* @__PURE__ */ new Set();
+  lockOwner() {
+    const owner = this.options.jobs?.shown(this.pid) ?? this.pid;
+    this.lockOwners.add(owner);
+    return owner;
+  }
+  async lockPath(target, want) {
+    if (target.fd !== void 0) {
+      const st = await this.fds.get(target.fd).file.stat?.();
+      if (!st || st.orphan) throw new KernelError("EBADF");
+      return st.path;
+    }
+    if (target.path === void 0) throw new KernelError("EINVAL");
+    if (!target.path.startsWith("/")) throw new KernelError("EINVAL");
+    const path = target.path;
+    const g = this.guarded();
+    const checked = `${want}:${path}`;
+    if (g && want !== 0 && !this.lockChecked.has(checked)) {
+      await openable(g, "lock", path, want, false);
+      this.lockChecked.add(checked);
+    }
+    return path;
+  }
+  async lockKey(target, kind) {
+    const want = kind === "read" ? R_OK : kind === "write" ? W_OK : 0;
+    const path = await this.lockPath(target, want);
+    const st = await this.options.fs.stat?.(path);
+    if (!st) throw new KernelError("ENOENT");
+    return st.ino === void 0 ? path : `${st.dev ?? 0}:${st.ino}`;
+  }
+  async dropRecordLocks(fd) {
+    const { locks } = this.options;
+    const owner = this.options.jobs?.shown(this.pid) ?? this.pid;
+    if (!locks?.holds(owner) || !this.fds.has(fd)) return;
+    const key = await this.lockKey({ fd }, "close").catch(() => void 0);
+    if (key !== void 0) locks.dropFile(key, owner);
+  }
   refuseIfPending(restart) {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
@@ -15798,6 +15992,7 @@ var WasmProcess = class {
         };
       case "fd-close": {
         this.options.locks?.closed(this.pid, req.fd);
+        await this.dropRecordLocks(req.fd);
         const channel = this.fds.get(req.fd).file.clipboard;
         if (channel) channel.stamp = await this.clipboardStamp();
         await Promise.resolve(this.fds.close(req.fd)).catch(async (err) => {
@@ -16390,6 +16585,7 @@ var WasmProcess = class {
     this.clearAlarm();
     this.interrupt.abort();
     this.options.locks?.release(this.pid);
+    for (const owner of this.lockOwners) this.options.locks?.release(owner);
     this.asyncOps.close();
     for (const [target, sig] of this.deathSignals) this.sendDeath(target, sig);
     this.deathSignals.clear();