@ai-ecoverse/slicc-kernel 1.146.2 → 1.146.3

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.3" : "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)) {
@@ -9768,13 +9793,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))
+      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) ?? 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);
@@ -27988,6 +28024,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;
@@ -28122,6 +28159,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 } } : {}
       }
     );
@@ -30043,6 +30081,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 } } : {}
       }
     );