@ai-ecoverse/slicc-kernel 1.124.7 → 1.124.8

package/dist/node.js

@@ -5776,6 +5776,7 @@ var LOOKUP_OPS = [
   "realpath"
 ];
 var within4 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var TOUCHED_MAX = 4096;
 var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
@@ -5814,6 +5815,9 @@ var UnlinkedKeeper = class {
   queue = Promise.resolve();
   count = 0;
   replacing = /* @__PURE__ */ new Map();
+  gen = 0;
+  floor = 0;
+  touched = /* @__PURE__ */ new Map();
   replaced = 0;
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
@@ -5840,28 +5844,28 @@ var UnlinkedKeeper = class {
     const { replacing } = this;
     const replace = async (target, op) => {
       const { promise, resolve: resolve2 } = Promise.withResolvers();
+      keeper.touch(target);
       let mine;
       const gated = () => {
         const before = replacing.get(target);
-        mine = { done: Promise.all([before?.done, promise]).then(() => void 0) };
+        mine = { done: Promise.all([before?.done, promise]).then(() => void 0), sealed: false };
         replacing.set(target, mine);
       };
+      const sealed = () => {
+        if (mine) mine.sealed = true;
+      };
       try {
-        await op(gated);
+        await op(gated, sealed);
       } finally {
         keeper.replaced += 1;
+        keeper.touch(target);
         resolve2();
         if (mine && replacing.get(target) === mine) replacing.delete(target);
       }
     };
     const unreplaced = async (path, op) => {
       const at = fs.resolvePath("/", path);
-      const pending = async () => {
-        for (let p = at; replacing.size > 0; p = parentOf5(p)) {
-          await replacing.get(p)?.done;
-          if (p === "/") return;
-        }
-      };
+      const pending = () => keeper.settled(at);
       for (let attempt = 1; ; attempt++) {
         await pending();
         const seen = keeper.replaced;
@@ -5895,8 +5899,8 @@ var UnlinkedKeeper = class {
       lstat: (path) => unreplaced(path, async () => counted3(await fs.lstat(path))),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
-        await replace(target, async (gated) => {
-          const pinned = await keeper.pin(target, gated);
+        await replace(target, async (gated, sealed) => {
+          const pinned = await keeper.pin(target, gated, sealed);
           if (pinned.moved.has(target)) pinned.commit();
           else await keeper.settle(pinned, () => fs.rm(path, options));
         });
@@ -5904,8 +5908,8 @@ var UnlinkedKeeper = class {
       async rename(from, to) {
         const target = fs.resolvePath("/", to);
         if (target === fs.resolvePath("/", from)) return fs.rename(from, to);
-        await replace(target, async (gated) => {
-          const pinned = await keeper.pin(target, gated);
+        await replace(target, async (gated, sealed) => {
+          const pinned = await keeper.pin(target, gated, sealed);
           await keeper.settle(pinned, () => fs.rename(from, to));
         });
       },
@@ -5913,6 +5917,39 @@ var UnlinkedKeeper = class {
       readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted3(st)])
     };
   }
+  async settled(path) {
+    for (let p = path; this.replacing.size > 0; p = parentOf5(p)) {
+      await this.replacing.get(p)?.done;
+      if (p === "/") return;
+    }
+  }
+  generation() {
+    return this.gen;
+  }
+  changedSince(path, gen) {
+    if (gen < this.floor) return true;
+    for (let p = path; this.touched.size > 0; p = parentOf5(p)) {
+      if ((this.touched.get(p) ?? 0) > gen) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
+  touch(target) {
+    this.gen += 1;
+    this.touched.delete(target);
+    this.touched.set(target, this.gen);
+    if (this.touched.size <= TOUCHED_MAX) return;
+    const [oldest, at] = this.touched.entries().next().value;
+    this.touched.delete(oldest);
+    this.floor = at;
+  }
+  missed(path) {
+    for (let p = path; this.replacing.size > 0; p = parentOf5(p)) {
+      if (this.replacing.get(p)?.sealed) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
   async settle(pinned, op) {
     try {
       await op();
@@ -5933,33 +5970,41 @@ var UnlinkedKeeper = class {
     }
     return held;
   }
-  async pin(target, gated = () => void 0) {
+  async pin(target, gated = () => void 0, sealed = () => void 0) {
     const paths = [];
     const releases = [];
-    for (; ; ) {
-      const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
-      if (fresh2.length === 0) break;
-      fresh2.sort();
-      if (paths.some((path) => path > fresh2[0])) {
-        for (const release of releases.splice(0)) release();
-        fresh2.push(...paths.splice(0));
+    const take = async () => {
+      for (; ; ) {
+        const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
+        if (fresh2.length === 0) return;
         fresh2.sort();
+        if (paths.some((path) => path > fresh2[0])) {
+          for (const release of releases.splice(0)) release();
+          fresh2.push(...paths.splice(0));
+          fresh2.sort();
+        }
+        for (const path of fresh2) {
+          paths.push(path);
+          releases.push(await this.gate.acquire(path));
+        }
       }
-      for (const path of fresh2) {
-        paths.push(path);
-        releases.push(await this.gate.acquire(path));
-      }
-    }
+    };
+    await take();
     gated();
-    const now = this.heldWithin(target);
-    const held = new Map(
-      paths.flatMap((path) => now.has(path) ? [[path, now.get(path)]] : [])
-    );
+    const held = /* @__PURE__ */ new Map();
     const hidden = /* @__PURE__ */ new Map();
-    for (const path of held.keys()) {
-      const at = await this.hide(path);
-      if (at !== void 0) hidden.set(path, at);
+    for (; ; ) {
+      await take();
+      const now = this.heldWithin(target);
+      const next3 = paths.filter((path) => now.has(path) && !held.has(path));
+      if (next3.length === 0) break;
+      for (const path of next3) {
+        held.set(path, now.get(path));
+        const at = await this.hide(path);
+        if (at !== void 0) hidden.set(path, at);
+      }
     }
+    sealed();
     const done4 = () => {
       for (const release of releases) release();
     };
@@ -7025,7 +7070,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.7" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.8" : "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
@@ -10409,6 +10454,9 @@ var HeldPaths = class extends Map {
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
+  holdsHandle(handle) {
+    return this.handles.has(handle);
+  }
   keeps(hidden) {
     for (const file of this.uses.keys()) if (file.hidden === hidden) return true;
     for (const file of this.unlinked.values()) if (file.hidden === hidden) return true;
@@ -11855,10 +11903,16 @@ async function run(entry, path, req) {
       return done;
     case "exists":
       return json2(await fs.exists(path));
-    case "stat":
-      return json2(statJson(await shownAs(entry, path, await fs.stat(path))));
-    case "lstat":
-      return json2(statJson(await shownAs(entry, path, await fs.lstat(path))));
+    case "stat": {
+      const gen = entry.replacements?.generation();
+      const st = statJson(await shownAs(entry, path, await fs.stat(path)));
+      return json2(gen === void 0 ? st : { ...st, gen });
+    }
+    case "lstat": {
+      const gen = entry.replacements?.generation();
+      const st = statJson(await shownAs(entry, path, await fs.lstat(path)));
+      return json2(gen === void 0 ? st : { ...st, gen });
+    }
     case "readdir":
       return json2(await fs.readdir(path));
     case "readdir-stat":
@@ -12033,14 +12087,26 @@ async function opening(entry, path, mode) {
     await need(g, "open", path, want, { directory: false });
   }
 }
+async function stillThere(entry, path, req) {
+  if (req.gen === void 0 || !entry.replacements?.changedSince(path, req.gen)) return;
+  const st = await entry.fs.stat(path).catch(() => void 0);
+  if (!st) throw syncError("ENOENT", path);
+}
 async function holdOp(entry, path, req) {
   const mode = req.mode ?? 0;
   const [on, open] = [(mode & 1) === 1, (mode & 2) === 2];
   if (on && open) {
-    await opening(entry, path, mode);
-    const real = await entry.fs.realpath?.(path, true).catch(() => path);
-    await entry.source?.open(path, real);
-    return json2(entry.hold?.(path, on, open, real) ?? null);
+    for (; ; ) {
+      const r = entry.replacements;
+      await r?.settled(path);
+      const gen = r?.generation() ?? 0;
+      await opening(entry, path, mode);
+      const real = await entry.fs.realpath?.(path, true).catch(() => path);
+      await entry.source?.open(path, real);
+      await stillThere(entry, path, req);
+      if (!r || !r.missed(path) && !r.changedSince(path, gen))
+        return json2(entry.hold?.(path, on, open, real) ?? null);
+    }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
@@ -17621,6 +17687,7 @@ var VfsNode = class {
   path;
   orphaned;
   id;
+  ino;
   onDirty;
   onDirtyState;
   counted = false;
@@ -17973,8 +18040,12 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable2 = false, id2) {
-    const node = this.named(path, id2) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
+  open(path, pin, writable2 = false, id2, ino) {
+    const found = this.named(path, id2);
+    const same = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
+    if (found && !same) this.orphan(found);
+    const node = (same ? found : void 0) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
+    node.ino ??= ino;
     node.opens++;
     if (writable2) node.writers++;
     return node;
@@ -18268,7 +18339,7 @@ function vfsFile(fs, opts, nodes) {
   const access2 = opts.flags & O_ACCMODE;
   const readable2 = access2 !== O_WRONLY;
   const writable2 = access2 === O_WRONLY || access2 === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id);
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id, opts.ino);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -19038,6 +19109,7 @@ var WasmProcess = class {
     const fd = this.fds.install(heldFile(), 3);
     try {
       const nodes = this.nodes;
+      const gen = this.replacements?.generation() ?? 0;
       const path = await this.openPath(req, marked);
       if (inProc(path)) {
         this.fds.installAt(fd, await this.procFile(req, path));
@@ -19062,7 +19134,15 @@ var WasmProcess = class {
           }
         });
       } else {
-        this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
+        await this.unmissed(
+          () => this.openPath(req, marked),
+          async (at) => {
+            await this.stillOpen(at, req.handle);
+            return nodes.identify(at);
+          },
+          (id2, at) => this.fds.installAt(fd, this.openVfsFile({ ...open, path: at }, id2, fs)),
+          { at: path, gen }
+        );
       }
       if (req.existing && !await present2(fs, path, true)) {
         throw new KernelError("ENOENT");
@@ -19243,7 +19323,8 @@ var WasmProcess = class {
         ...req.truncate ? { truncate: true } : {},
         ...req.create ? { create: true } : {},
         ...req.pin ? { pin: req.pin } : {},
-        ...id2 !== void 0 && !req.orphan ? { id: id2 } : {}
+        ...id2 !== void 0 && !req.orphan ? { id: id2 } : {},
+        ...req.ino !== void 0 && !req.orphan ? { ino: req.ino } : {}
       },
       this.nodes
     );
@@ -19414,9 +19495,27 @@ var WasmProcess = class {
     return false;
   }
   keptHandle;
+  holdsHandle;
+  replacements;
+  async unmissed(path, look, make, first) {
+    let given = first;
+    for (; ; ) {
+      const r = this.replacements;
+      const gen = given?.gen ?? r?.generation() ?? 0;
+      const at = given?.at ?? await path();
+      given = void 0;
+      await r?.settled(at);
+      const found = await look(at);
+      if (!r || !r.missed(at) && !r.changedSince(at, gen)) return make(found, at);
+    }
+  }
+  async stillOpen(at, handle) {
+    if (handle === void 0 || this.keptHandle?.(handle) !== void 0) return;
+    if (this.holdsHandle?.(handle) !== false) return;
+    if (!await present2(this.options.fs, at, true)) throw new KernelError("ENOENT");
+  }
   async keptOr(path, handle) {
-    const held = handle === void 0 ? void 0 : this.keptHandle?.(handle);
-    if (held !== void 0) return held;
+    if (handle !== void 0) return this.keptHandle?.(handle) ?? path;
     const kept = this.keptPath?.(path);
     return kept !== void 0 && !await present2(this.options.fs, path, true) ? kept : path;
   }
@@ -19426,25 +19525,37 @@ var WasmProcess = class {
       await this.fds.dup2Clipboard(req.share, req.fd);
       return;
     }
-    if (req.path === void 0) throw new KernelError("EINVAL");
-    const path = req.orphan ? req.path : await this.keptOr(await this.nodes.targetKey(req.path), req.handle);
-    const id2 = req.orphan ? void 0 : await this.nodes.identify(path);
-    if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
-    const file = vfsFile(
-      this.options.fs,
-      {
-        path,
-        flags: req.flags ?? 0,
-        position: req.position ?? 0,
-        ...req.contents !== void 0 ? { contents: req.contents } : {},
-        ...req.orphan ? { orphan: true } : {},
-        ...req.dirty ? { dirty: true } : {},
-        ...req.pin ? { pin: req.pin } : {},
-        ...id2 !== void 0 ? { id: id2 } : {}
+    const asked = req.path;
+    if (asked === void 0) throw new KernelError("EINVAL");
+    const install = ([path, id2]) => {
+      if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
+      const file = vfsFile(
+        this.options.fs,
+        {
+          path,
+          flags: req.flags ?? 0,
+          position: req.position ?? 0,
+          ...req.contents !== void 0 ? { contents: req.contents } : {},
+          ...req.orphan ? { orphan: true } : {},
+          ...req.dirty ? { dirty: true } : {},
+          ...req.pin ? { pin: req.pin } : {},
+          ...id2 !== void 0 ? { id: id2 } : {},
+          ...req.ino !== void 0 && path === asked ? { ino: req.ino } : {}
+        },
+        this.nodes
+      );
+      this.fds.installAt(req.fd, file);
+    };
+    if (req.orphan) return install([asked, void 0]);
+    await this.unmissed(
+      () => this.nodes.targetKey(asked),
+      async (target) => {
+        const at = await this.keptOr(target, req.handle);
+        await this.stillOpen(at, req.handle);
+        return [at, await this.nodes.identify(at)];
       },
-      this.nodes
+      install
     );
-    this.fds.installAt(req.fd, file);
   }
   reserve(fd, min = 3, meta) {
     if (fd === void 0) return this.fds.install(heldFile(meta), Math.max(3, min));
@@ -20097,6 +20208,12 @@ function inherited(opts) {
     ...opts.cred ? { cred: opts.cred } : {}
   };
 }
+function heldBy(process2, holds2, replacements) {
+  process2.keptPath = (path) => holds2.keptAt(path)?.hidden;
+  process2.keptHandle = (handle) => holds2.keptFor(handle)?.hidden;
+  process2.holdsHandle = (handle) => holds2.holdsHandle(handle);
+  if (replacements) process2.replacements = replacements;
+}
 function holdingToken(opts, holds2, caller) {
   return mintSyncFsToken({
     ...opts.owners ? caller : { umask: caller.umask },
@@ -20104,6 +20221,7 @@ function holdingToken(opts, holds2, caller) {
     ...opts.links !== void 0 ? { links: opts.links } : {},
     ...opts.fresh ? { fresh: (path) => opts.fresh?.(path, caller.umask()) } : {},
     ...opts.source ? { source: opts.source } : {},
+    ...opts.replacements ? { replacements: opts.replacements } : {},
     fs: opts.fs,
     noLinks: opts.noLinks,
     cwd: opts.cwd,
@@ -20242,8 +20360,7 @@ function spawnWasmProcess(opts) {
     created: created3,
     holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds2.keeps(path) || await process2.holds(path))
   });
-  process2.keptPath = (path) => holds2.keptAt(path)?.hidden;
-  process2.keptHandle = (handle2) => holds2.keptFor(handle2)?.hidden;
+  heldBy(process2, holds2, opts.replacements);
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req, block) => dying.serve(
@@ -25431,6 +25548,7 @@ var Launcher = class {
       nodes: stack.nodes,
       held: this.held,
       unlinkGate: stack.unlinked.gate,
+      replacements: stack.unlinked,
       statfs: (path) => this.mounts.statfs(path),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),