@ai-ecoverse/slicc-kernel 1.146.2 → 1.146.4

package/dist/node.js

@@ -3305,7 +3305,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.146.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.146.4" : "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
@@ -4177,6 +4177,55 @@ var Crontabs = class {
 
 // src/fs/unlinked.ts
 var UNLINKED_DIR = ".slicc-unlinked";
+var PathMarks = class {
+  gen = 0;
+  floor = 0;
+  touched = /* @__PURE__ */ new Map();
+  flying = /* @__PURE__ */ new Map();
+  generation() {
+    return this.gen;
+  }
+  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;
+  }
+  changedSince(path, gen) {
+    if (gen < this.floor) return true;
+    for (let p = path; this.touched.size > 0; p = parentOf2(p)) {
+      if ((this.touched.get(p) ?? 0) > gen) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
+  async around(paths, op) {
+    for (const p of paths) {
+      this.flying.set(p, (this.flying.get(p) ?? 0) + 1);
+      this.touch(p);
+    }
+    try {
+      return await op();
+    } finally {
+      for (const p of paths) {
+        const n = (this.flying.get(p) ?? 1) - 1;
+        if (n > 0) this.flying.set(p, n);
+        else this.flying.delete(p);
+        this.touch(p);
+      }
+    }
+  }
+  inFlight(path) {
+    for (let p = path; this.flying.size > 0; p = parentOf2(p)) {
+      if (this.flying.has(p)) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
+};
 function pidOwner(proc) {
   return {
     id: `p${proc.pid}`,
@@ -4243,14 +4292,13 @@ var UnlinkedKeeper = class {
   queue = Promise.resolve();
   count = 0;
   replacing = /* @__PURE__ */ new Map();
-  gen = 0;
-  floor = 0;
-  touched = /* @__PURE__ */ new Map();
+  marks;
   replaced = 0;
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
   dirOwner;
   constructor(fs, holders, rootOf, options = {}) {
+    this.marks = options.marks ?? new PathMarks();
     const { locks, owner } = options;
     this.dirOwner = options.dirOwner;
     this.fs = fs;
@@ -4272,7 +4320,6 @@ 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);
@@ -4283,10 +4330,9 @@ var UnlinkedKeeper = class {
         if (mine) mine.sealed = true;
       };
       try {
-        await op(gated, sealed);
+        await keeper.marks.around([target], () => op(gated, sealed));
       } finally {
         keeper.replaced += 1;
-        keeper.touch(target);
         resolve2();
         if (mine && replacing.get(target) === mine) replacing.delete(target);
       }
@@ -4337,25 +4383,15 @@ var UnlinkedKeeper = class {
         const target = fs.resolvePath("/", to);
         const source = fs.resolvePath("/", from);
         if (target === source) return fs.rename(from, to);
-        keeper.touch(source);
-        try {
-          await replace(target, async (gated, sealed) => {
+        await keeper.marks.around(
+          [source],
+          () => replace(target, async (gated, sealed) => {
             const pinned = await keeper.pin(target, gated, sealed);
             await keeper.settle(pinned, () => fs.rename(from, to));
-          });
-        } finally {
-          keeper.touch(source);
-        }
-      },
-      async symlink(target, path, owner) {
-        const at = fs.resolvePath("/", path);
-        keeper.touch(at);
-        try {
-          await fs.symlink(target, path, owner);
-        } finally {
-          keeper.touch(at);
-        }
+          })
+        );
       },
+      symlink: (target, path, owner) => keeper.marks.around([fs.resolvePath("/", path)], () => fs.symlink(target, path, owner)),
       readdir: async (path) => visible(await fs.readdir(path)),
       readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted3(st)])
     };
@@ -4367,24 +4403,13 @@ var UnlinkedKeeper = class {
     }
   }
   generation() {
-    return this.gen;
+    return this.marks.generation();
   }
   changedSince(path, gen) {
-    if (gen < this.floor) return true;
-    for (let p = path; this.touched.size > 0; p = parentOf2(p)) {
-      if ((this.touched.get(p) ?? 0) > gen) return true;
-      if (p === "/") return false;
-    }
-    return false;
+    return this.marks.changedSince(path, gen);
   }
-  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;
+  inFlight(path) {
+    return this.marks.inFlight(path);
   }
   missed(path) {
     for (let p = path; this.replacing.size > 0; p = parentOf2(p)) {
@@ -6361,16 +6386,16 @@ var FreshModules = class {
         if (size < MAGIC.length && this.fresh.has(normalizePath(path))) await decide(path);
       };
     }
-    const bound2 = /* @__PURE__ */ new WeakMap();
+    const bound3 = /* @__PURE__ */ new WeakMap();
     return new Proxy(fs, {
       get(target, key, receiver) {
         if (Object.hasOwn(overrides, key)) return overrides[key];
         const value2 = Reflect.get(target, key, receiver);
         if (typeof value2 !== "function") return value2;
-        let method = bound2.get(value2);
+        let method = bound3.get(value2);
         if (method === void 0) {
           method = value2.bind(target);
-          bound2.set(value2, method);
+          bound3.set(value2, method);
         }
         return method;
       }
@@ -8013,6 +8038,12 @@ var HeldSet = class extends Set {
     holds2.onIdle = this.idle;
     return super.add(holds2);
   }
+  doubt(paths, over) {
+    for (const holds2 of this) {
+      for (const path of paths) holds2.doubt(path, true);
+      if (over !== void 0) holds2.doubt(over);
+    }
+  }
   delete(holds2) {
     const removed = super.delete(holds2);
     for (const path of /* @__PURE__ */ new Set([...holds2.keys(), ...holds2.opens.keys()])) this.idle(path);
@@ -8034,6 +8065,9 @@ var HeldPaths = class extends Map {
   uses = /* @__PURE__ */ new Map();
   lastHandle = 0;
   owning;
+  bound = /* @__PURE__ */ new Map();
+  doubted = /* @__PURE__ */ new Map();
+  doubts = 0;
   onIdle;
   keyOf(path) {
     return this.aliases.get(path) ?? path;
@@ -8054,6 +8088,21 @@ var HeldPaths = class extends Map {
   handlesAt(path) {
     return [...this.handles].filter(([, key]) => key === path).map(([id2]) => id2);
   }
+  doubt(over, exact = false) {
+    if (this.bound.size === 0) return;
+    for (const [handle, key] of this.handles) {
+      if (!this.bound.has(handle) || this.keptHandles.has(handle)) continue;
+      if (exact ? key === over : within5(key, over)) this.doubted.set(handle, ++this.doubts);
+    }
+  }
+  boundIno(handle) {
+    const doubt = this.doubted.get(handle);
+    const ino = this.bound.get(handle);
+    return doubt === void 0 || ino === void 0 ? void 0 : { ino, doubt };
+  }
+  trust(handle, doubt) {
+    if (this.doubted.get(handle) === doubt) this.doubted.delete(handle);
+  }
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
@@ -8090,8 +8139,16 @@ var HeldPaths = class extends Map {
     for (const file of [...this.uses.keys()]) this.letGo(file, true);
     this.keptHandles.clear();
   }
-  hold(path, on, open = false, real, handle) {
-    if (open) return this.holdOpen(path, on, real, handle);
+  hold(path, on, open = false, real, handle, ino) {
+    if (open) {
+      const made2 = this.holdOpen(path, on, real, handle);
+      if (handle !== void 0) {
+        this.bound.delete(handle);
+        this.doubted.delete(handle);
+      }
+      if (made2 !== void 0 && ino !== void 0) this.bound.set(made2, ino);
+      return made2;
+    }
     this.holdWrite(path, on);
     return void 0;
   }
@@ -9768,13 +9825,24 @@ async function holdOp(entry, path, req) {
       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);
+      if (req.nofollow && !await ownEntry(entry, path, real ?? path)) continue;
+      if (!r || !r.missed(path) && !r.changedSince(path, gen) && !r.inFlight?.(path))
+        return json2(entry.hold?.(path, on, open, real, void 0, req.ino) ?? null);
     }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+async function ownEntry(entry, path, real) {
+  const own = await entry.fs.realpath?.(path, false).catch((err) => {
+    if (err.code !== "ENOENT") throw err;
+    return path;
+  });
+  if (own !== void 0 && own !== real) return false;
+  const st = await entry.fs.lstat(path);
+  if (st.isSymbolicLink) throw syncError("ELOOP", path);
+  return true;
+}
 async function followed(g, path) {
   const st = await g.fs.lstat(path).catch(() => void 0);
   if (st?.isSymbolicLink && !trustedLink(permOf(st), g.links)) deny(g, "follow", path);
@@ -9909,10 +9977,26 @@ async function linkedElsewhere(fs, path, from) {
   return !(source && source.ino === st.ino && source.dev === st.dev);
 }
 async function keptOr(entry, path, handle) {
-  if (handle !== void 0) return entry.keptFor?.(handle)?.hidden ?? path;
+  if (handle !== void 0) {
+    const hidden = entry.keptFor?.(handle)?.hidden;
+    if (hidden !== void 0) return hidden;
+    await bound(entry, path, handle);
+    return path;
+  }
   const kept = entry.unlinked?.(path);
   return kept && !await entry.fs.exists(path) ? kept.hidden : path;
 }
+async function bound(entry, path, handle) {
+  const bound3 = entry.boundIno?.(handle);
+  if (bound3 === void 0) return;
+  const now = await entry.fs.stat(path).catch(() => void 0);
+  if (now?.ino === bound3.ino) {
+    entry.trust?.(handle, bound3.doubt);
+    return;
+  }
+  staleFds++;
+  throw syncError("ESTALE", path);
+}
 async function keptStat(entry, req) {
   const hidden = entry.keptFor?.(req.handle ?? -1)?.hidden;
   if (hidden === void 0)
@@ -9939,6 +10023,10 @@ var served = 0;
 function servedFsCalls() {
   return served;
 }
+var staleFds = 0;
+function staleFdCount() {
+  return staleFds;
+}
 async function dispatchSyncFs(req) {
   served++;
   const entry = resolveSyncFsToken(req.token);
@@ -10714,6 +10802,8 @@ var SYS_TREE = {
     slicc_cwd_checks: (listing) => `${listing.cwdChecks ?? 0}
 `,
     slicc_rename_ack_busy: (listing) => `${listing.renameAcks?.busy ?? 0}
+`,
+    slicc_stale_fds: (listing) => `${listing.staleFds ?? 0}
 `,
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
@@ -15226,7 +15316,7 @@ async function writeAll2(file, bytes) {
   const write = file.write;
   for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
-function bound(file, key) {
+function bound2(file, key) {
   const method = file[key];
   return typeof method === "function" ? { [key]: method.bind(file) } : {};
 }
@@ -15318,9 +15408,9 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
     later(stream2.idle());
   };
   return new OpenFile({
-    ...bound(file, "read"),
-    ...bound(file, "peek"),
-    ...bound(file, "stat"),
+    ...bound2(file, "read"),
+    ...bound2(file, "peek"),
+    ...bound2(file, "stat"),
     poll: () => {
       const state = pollFile(file);
       return quiet3() ? state : { ...state, writable: false };
@@ -21039,7 +21129,9 @@ function holdingToken(opts, holds2, caller) {
     ...opts.statfs ? { statfs: opts.statfs } : {},
     ...opts.renames ? { renames: opts.renames } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
-    hold: (path, on, open, real, handle) => holds2.hold(path, on, open, real, handle),
+    hold: (path, on, open, real, handle, ino) => holds2.hold(path, on, open, real, handle, ino),
+    boundIno: holds2.boundIno.bind(holds2),
+    trust: holds2.trust.bind(holds2),
     keptFor: (handle) => holds2.keptFor(handle),
     unlinked: (path) => holds2.keptAt(path),
     gate: (path, op) => opts.unlinkGate && holds2.holding(path) ? opts.unlinkGate.run(holds2.keyOf(path), op) : op(),
@@ -27988,6 +28080,7 @@ var Launcher = class {
   fstabRetries;
   inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
+  pathMarks = new PathMarks();
   deciding = /* @__PURE__ */ new Map();
   identities = { asked: 0, timedOut: 0 };
   nodes;
@@ -28108,6 +28201,7 @@ var Launcher = class {
     this.openFiles.add(this.nodes);
     options.fs.onPeer?.(() => this.flushOpen());
     options.fs.remoteChanges?.((change) => {
+      this.held.doubt(change.paths, change.moved?.to);
       if (change.moved) this.moved(change.moved.from, change.moved.to);
       this.changes.flush();
       this.cwds.touched(change.paths, change.trees);
@@ -28122,6 +28216,7 @@ var Launcher = class {
         locks: webLocks(),
         busy: (path) => [...this.openFiles].some((nodes) => nodes.holds(path)),
         owner: options.unlinkOwner,
+        marks: this.pathMarks,
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );
@@ -29119,7 +29214,8 @@ var Launcher = class {
         opfsCalls: this.rootFs.opfsCalls?.() ?? 0,
         opfsOps: this.rootFs.opfsOps?.() ?? 0,
         cwdChecks: this.cwds.checks,
-        renameAcks: this.rootFs.renameWaits?.()
+        renameAcks: this.rootFs.renameWaits?.(),
+        staleFds: staleFdCount()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -30043,6 +30139,7 @@ var Launcher = class {
         locks: webLocks(),
         busy: (path) => [...this.openFiles].some((open) => open.holds(path)),
         owner: this.unlinkOwnerOption,
+        marks: this.pathMarks,
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );
@@ -30096,6 +30193,7 @@ var Launcher = class {
     this.renameLog.add(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
+    for (const holds2 of this.held) holds2.renamed(from, to);
     this.watchers.moved(from, to);
   }
   processChain(fs, nodes, unlinked) {