@ai-ecoverse/slicc-kernel 1.118.1 → 1.119.1

package/dist/kernel-worker.js

@@ -1183,12 +1183,14 @@ var OpfsFs = class {
   mounts = {};
   locks;
   lockPrefix;
+  rootName;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
     this.meta = sidecar(meta);
     this.ranged = options.ranged === true;
     this.locks = options.locks === void 0 ? lockManager() : options.locks ?? void 0;
     this.lockPrefix = `slicc-excl:${channel ?? ""}:`;
+    this.rootName = channel;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`);
     if (this.remote) this.remote.quiet = () => this.quiet();
@@ -6364,7 +6366,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.118.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.119.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
@@ -13302,6 +13304,12 @@ var FlockTable = class {
       await changedAt(this.wakers, key, signal);
     }
   }
+  entries() {
+    const out = [];
+    for (const [key, holders] of this.held)
+      for (const [owner, kind] of holders) out.push([key, owner, kind]);
+    return out;
+  }
   drop(owner) {
     const key = this.keys.get(owner);
     if (key === void 0) return;
@@ -13380,6 +13388,9 @@ var LockTable = class {
     if (locks.length === 0) this.records.delete(key);
     else this.records.set(key, locks);
   }
+  entries() {
+    return [...this.records].map(([key, locks]) => [key, locks.map((l) => ({ ...l }))]);
+  }
   holds(owner) {
     for (const locks of this.records.values())
       if (locks.some((l) => l.owner === owner)) return true;
@@ -13624,7 +13635,7 @@ async function flock(req, ctx) {
   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");
+  else if (!await locks.flocks.set(key, owner, req.kind)) throw new KernelError("EAGAIN");
   return done2;
 }
 async function recordLock2(req, ctx) {
@@ -13642,7 +13653,7 @@ async function recordLock2(req, ctx) {
   const range2 = lockRange(req.start, req.len);
   const key = await fileKey(target, req.kind, req.op === "lk-set" && req.fd !== void 0);
   if (req.op === "lk-get") {
-    const held = locks.holder(key, owner, { key, kind: req.kind, ...range2 });
+    const held = await locks.holder(key, owner, { key, kind: req.kind, ...range2 });
     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 });
@@ -13651,7 +13662,8 @@ async function recordLock2(req, ctx) {
     await locks.wait(key, owner, req.kind, range2, ctx.blocking);
     return done2;
   }
-  if (!locks.set(key, owner, req.kind, range2.start, range2.end)) throw new KernelError("EAGAIN");
+  if (!await locks.set(key, owner, req.kind, range2.start, range2.end))
+    throw new KernelError("EAGAIN");
   return done2;
 }
 
@@ -19802,6 +19814,343 @@ var JobTable = class {
   }
 };
 
+// src/kernel/lock-service.ts
+var PRUNE_MS = 1e3;
+var LOCKS_PROTOCOL = "v1";
+var LockService = class {
+  kernel = crypto.randomUUID();
+  table = new LockTable();
+  leader = false;
+  role;
+  channel;
+  locks;
+  root;
+  pending = /* @__PURE__ */ new Map();
+  next = 0;
+  owners = /* @__PURE__ */ new Map();
+  ownerOf = /* @__PURE__ */ new Map();
+  nextRemote = -1;
+  tokens = /* @__PURE__ */ new Map();
+  flockIds = /* @__PURE__ */ new WeakMap();
+  flockOwners = /* @__PURE__ */ new Map();
+  nextFlock = 1;
+  granted = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Map();
+  settled = Promise.resolve();
+  pruner;
+  flocks;
+  constructor(options) {
+    this.root = options.root;
+    this.locks = options.locks;
+    this.channel = (options.channel ?? ((n) => new BroadcastChannel(n)))(
+      `slicc-locks:${LOCKS_PROTOCOL}:${this.root}`
+    );
+    this.channel.unref?.();
+    this.channel.onmessage = ({ data }) => {
+      if (isMessage(data)) void this.receive(data);
+    };
+    void this.locks.request(this.aliveOf(this.kernel), () => new Promise(() => {
+    }));
+    this.role = this.elect();
+    this.flocks = {
+      set: (key, owner, kind) => this.flockSet(key, owner, kind),
+      wait: (key, owner, kind, blocking) => this.flockWait(key, owner, kind, blocking),
+      drop: (owner) => this.flockDrop(owner)
+    };
+  }
+  aliveOf(kernel) {
+    return `slicc-locks-alive:${LOCKS_PROTOCOL}:${this.root}:${kernel}`;
+  }
+  elect() {
+    const name2 = `slicc-locks-leader:${LOCKS_PROTOCOL}:${this.root}`;
+    return new Promise((decided) => {
+      void this.locks.request(name2, { ifAvailable: true }, async (lock) => {
+        this.leader = lock !== null;
+        decided();
+        if (this.leader) await new Promise(() => {
+        });
+      });
+    }).then(() => {
+      if (this.leader) return;
+      void this.locks.request(name2, async () => {
+        await this.lead();
+        await new Promise(() => {
+        });
+      });
+    });
+  }
+  async lead() {
+    this.leader = true;
+    this.settled = new Promise((resolve2) => setTimeout(resolve2, ANNOUNCE_WAIT_MS));
+    this.channel.postMessage({ reassert: true, from: this.kernel });
+    const pending = [...this.pending.entries()];
+    this.pending.clear();
+    await this.settled;
+    for (const [, p] of pending) void this.serve(p.ask, this.kernel).then(p.resolve, p.reject);
+  }
+  async receive(data) {
+    if (data.reassert && data.from !== this.kernel) return this.reassert();
+    if (data.to !== void 0 && data.to !== this.kernel) return;
+    if (data.id !== void 0 && (data.ok !== void 0 || data.errno !== void 0) && data.to === this.kernel) {
+      return this.answered(data);
+    }
+    if (!this.leader || data.from === void 0) return;
+    if (data.adopt) return this.adopt(data.from, data.adopt);
+    if (data.cancel !== void 0) return void this.waiting.get(data.cancel)?.abort();
+    if (data.ask && data.id !== void 0) await this.request(data.from, data.id, data.ask);
+  }
+  answered(data) {
+    const p = this.pending.get(data.id);
+    if (!p) return;
+    this.pending.delete(data.id);
+    if (data.errno !== void 0) p.reject(new KernelError(data.errno));
+    else p.resolve(data.ok);
+  }
+  async request(from, id2, ask) {
+    const known = this.granted.get(id2);
+    if (known) return void this.channel.postMessage({ id: id2, to: from, ...known });
+    await this.settled;
+    let reply;
+    try {
+      reply = { ok: await this.serve(ask, from, id2) ?? null };
+    } catch (err) {
+      reply = { errno: err.code ?? "EIO" };
+    }
+    this.granted.set(id2, reply);
+    if (this.granted.size > 4096) this.granted.delete(this.granted.keys().next().value);
+    this.channel.postMessage({ id: id2, to: from, ...reply });
+  }
+  ownerFor(kernel, owner) {
+    if (kernel === this.kernel) return owner;
+    const name2 = `${kernel}:${owner}`;
+    let id2 = this.owners.get(name2);
+    if (id2 === void 0) {
+      id2 = this.nextRemote--;
+      this.owners.set(name2, id2);
+      this.ownerOf.set(id2, { kernel, owner });
+      this.watchRemotes();
+    }
+    return id2;
+  }
+  tokenFor(kernel, owner) {
+    if (kernel === this.kernel) return this.flockOwners.get(owner) ?? {};
+    const name2 = `${kernel}:${owner}`;
+    let token = this.tokens.get(name2);
+    if (!token) {
+      token = { kernel, owner };
+      this.tokens.set(name2, token);
+      this.watchRemotes();
+    }
+    return token;
+  }
+  async serve(ask, from, id2) {
+    const t = this.table;
+    switch (ask.op) {
+      case "set":
+        return t.set(ask.key, this.ownerFor(from, ask.owner), ask.kind, ask.start, ask.end);
+      case "holder": {
+        const held = t.holder(ask.key, this.ownerFor(from, ask.owner), ask);
+        if (!held) return void 0;
+        return { ...held, owner: this.ownerOf.get(held.owner)?.owner ?? held.owner };
+      }
+      case "wait":
+        return this.blockFor(
+          id2,
+          () => t.wait(ask.key, this.ownerFor(from, ask.owner), ask.kind, ask, () => this.signalOf(id2))
+        );
+      case "drop":
+        return t.dropFile(ask.key, this.ownerFor(from, ask.owner));
+      case "release":
+        return t.release(this.ownerFor(from, ask.owner));
+      case "fset":
+        return t.flocks.set(ask.key, this.tokenFor(from, ask.owner), ask.kind);
+      case "fwait":
+        return this.blockFor(
+          id2,
+          () => t.flocks.wait(ask.key, this.tokenFor(from, ask.owner), ask.kind, () => this.signalOf(id2))
+        );
+      case "fdrop":
+        return t.flocks.drop(this.tokenFor(from, ask.owner));
+    }
+  }
+  signalOf(id2) {
+    if (id2 === void 0) return new AbortController().signal;
+    let c = this.waiting.get(id2);
+    if (!c) {
+      c = new AbortController();
+      this.waiting.set(id2, c);
+    }
+    return c.signal;
+  }
+  async blockFor(id2, run2) {
+    try {
+      await run2();
+    } finally {
+      if (id2 !== void 0) this.waiting.delete(id2);
+    }
+  }
+  watchRemotes() {
+    if (this.pruner || this.ownerOf.size === 0 && this.tokens.size === 0) return;
+    this.pruner = setInterval(() => void this.prune(), PRUNE_MS);
+    this.pruner.unref?.();
+  }
+  async prune() {
+    const held = new Set(((await this.locks.query()).held ?? []).map((l) => l.name));
+    for (const [id2, { kernel, owner }] of [...this.ownerOf]) {
+      if (held.has(this.aliveOf(kernel))) continue;
+      this.table.release(id2);
+      this.ownerOf.delete(id2);
+      this.owners.delete(`${kernel}:${owner}`);
+    }
+    for (const [name2, token] of [...this.tokens]) {
+      if (held.has(this.aliveOf(name2.slice(0, name2.lastIndexOf(":"))))) continue;
+      this.table.flocks.drop(token);
+      this.tokens.delete(name2);
+    }
+    if (this.pruner && this.ownerOf.size === 0 && this.tokens.size === 0) {
+      clearInterval(this.pruner);
+      this.pruner = void 0;
+    }
+  }
+  reassert() {
+    const records = this.table.entries();
+    const flocks = this.table.flocks.entries().map(([key, owner, kind]) => [key, this.flockIdOf(owner), kind]);
+    this.channel.postMessage({ adopt: { records, flocks }, from: this.kernel });
+    for (const [id2, p] of this.pending)
+      this.channel.postMessage({ id: id2, from: this.kernel, ask: p.ask });
+  }
+  adopt(from, held) {
+    for (const [key, locks] of held.records)
+      for (const l of locks)
+        this.table.set(key, this.ownerFor(from, l.owner), l.kind, l.start, l.end);
+    for (const [key, owner, kind] of held.flocks)
+      this.table.flocks.set(key, this.tokenFor(from, owner), kind);
+  }
+  flockIdOf(owner) {
+    let id2 = this.flockIds.get(owner);
+    if (id2 === void 0) {
+      id2 = this.nextFlock++;
+      this.flockIds.set(owner, id2);
+      this.flockOwners.set(id2, owner);
+    }
+    return id2;
+  }
+  async ask(ask, signal) {
+    await this.role;
+    await this.settled;
+    if (this.leader) return this.serve(ask, this.kernel);
+    const id2 = `${this.kernel}:${this.next++}`;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id2, { ask, resolve: resolve2, reject });
+      this.channel.postMessage({ id: id2, from: this.kernel, ask });
+      signal?.addEventListener(
+        "abort",
+        () => {
+          if (!this.pending.delete(id2)) return;
+          this.channel.postMessage({ cancel: id2, from: this.kernel });
+          reject(new KernelError("EINTR"));
+        },
+        { once: true }
+      );
+    });
+  }
+  async holder(key, owner, want) {
+    return await this.ask({
+      op: "holder",
+      key,
+      owner,
+      kind: want.kind,
+      start: want.start,
+      end: want.end
+    }) ?? void 0;
+  }
+  async set(key, owner, kind, start2, end) {
+    const ok4 = await this.ask({ op: "set", key, owner, kind, start: start2, end }) === true;
+    if (ok4 && !this.leader) this.table.set(key, owner, kind, start2, end);
+    return ok4;
+  }
+  async wait(key, owner, kind, range2, blocking) {
+    await this.role;
+    await this.settled;
+    if (this.leader) return this.table.wait(key, owner, kind, range2, blocking);
+    if (await this.set(key, owner, kind, range2.start, range2.end)) return;
+    await this.ask({ op: "wait", key, owner, kind, ...range2 }, blocking());
+    if (!this.leader) this.table.set(key, owner, kind, range2.start, range2.end);
+  }
+  holds(owner) {
+    return this.table.holds(owner);
+  }
+  dropFile(key, owner) {
+    if (!this.leader) this.table.dropFile(key, owner);
+    void this.ask({ op: "drop", key, owner }).catch(() => void 0);
+  }
+  release(pid) {
+    if (!this.leader) this.table.release(pid);
+    void this.ask({ op: "release", owner: pid }).catch(() => void 0);
+  }
+  async flockSet(key, owner, kind) {
+    await this.role;
+    await this.settled;
+    if (this.leader) return this.table.flocks.set(key, owner, kind);
+    const ok4 = await this.ask({ op: "fset", key, owner: this.flockIdOf(owner), kind }) === true;
+    if (ok4) this.table.flocks.set(key, owner, kind);
+    return ok4;
+  }
+  async flockWait(key, owner, kind, blocking) {
+    await this.role;
+    await this.settled;
+    if (this.leader) return this.table.flocks.wait(key, owner, kind, blocking);
+    if (await this.flockSet(key, owner, kind)) return;
+    await this.ask({ op: "fwait", key, owner: this.flockIdOf(owner), kind }, blocking());
+    if (!this.leader) this.table.flocks.set(key, owner, kind);
+  }
+  flockDrop(owner) {
+    if (!this.leader) this.table.flocks.drop(owner);
+    void this.ask({ op: "fdrop", owner: this.flockIdOf(owner) }).catch(() => void 0);
+  }
+  lock(pid, path, exclusive, fd) {
+    return this.table.lock(pid, path, exclusive, fd);
+  }
+  unlock(pid, path) {
+    this.table.unlock(pid, path);
+  }
+  closed(pid, fd) {
+    this.table.closed(pid, fd);
+  }
+};
+function kernelLocks(root) {
+  const locks = globalThis.navigator?.locks;
+  if (root === void 0 || !locks || typeof BroadcastChannel !== "function")
+    return new LockTable();
+  return new LockService({ root, locks });
+}
+var ASK_OPS = /* @__PURE__ */ new Set([
+  "set",
+  "wait",
+  "holder",
+  "drop",
+  "release",
+  "fset",
+  "fwait",
+  "fdrop"
+]);
+function askOk(ask) {
+  if (typeof ask !== "object" || ask === null) return false;
+  const a = ask;
+  if (!ASK_OPS.has(String(a.op)) || typeof a.owner !== "number") return false;
+  return a.key === void 0 || typeof a.key === "string";
+}
+function isMessage(data) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return false;
+  const m = data;
+  for (const field4 of ["id", "from", "to", "cancel", "errno"])
+    if (m[field4] !== void 0 && typeof m[field4] !== "string") return false;
+  if (m.ask !== void 0 && !askOk(m.ask)) return false;
+  const adopt = m.adopt;
+  if (adopt === void 0) return true;
+  return adopt !== null && Array.isArray(adopt.records) && Array.isArray(adopt.flocks);
+}
+
 // src/kernel/net/hosts-file.ts
 var HOSTS_PATH = "/etc/hosts";
 function parseHosts(text) {
@@ -23105,7 +23454,7 @@ var Launcher = class {
   users;
   sudoer;
   jobs = new JobTable();
-  locks = new LockTable();
+  locks;
   fifos = new FifoTable();
   sems = new SemTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
@@ -23161,6 +23510,7 @@ var Launcher = class {
   constructor(options) {
     this.usersMode = usersMode(options.users);
     this.rootFs = options.fs;
+    this.locks = kernelLocks(options.fs.rootName);
     this.dac = this.usersMode === "off" ? void 0 : new Dac(this.usersMode, options.onDenial);
     if (this.dac) this.dac.tagOf = (pid) => this.tagOf(pid);
     this.clipboard = new ClipboardBroker(