@ai-ecoverse/slicc-kernel 1.146.1 → 1.146.3

package/README.md

@@ -1128,7 +1128,7 @@ A character device (`0666`), there in every `users` mode, through which programs
   - **No hash known:** when `lookup` has none (`undefined`), `unknown: 'allow'` (the default) runs the file and reports `{ op: 'exec-unverified', errno: 'ENODATA', … }` once per path, while `unknown: 'deny'` refuses it as a mismatch.
   - **The cache:** a result is kept per real path and the file's version: what OPFS itself reports (its `lastModified` and `size`), plus the count of writes kernels made to the file, which the metadata store keeps (Chrome doesn't move `lastModified` for a write through a sync access handle). A kernel with `integrity` set counts a write to a protected file before its bytes change, and again once the write is over (also when it failed), at wherever the file is by then; the count follows a rename, and no `utimes` turns it back. The version also holds the count of moves into protection: a rename or a symlink at or above a protected path counts one before and after it, so a move into a protected path re-verifies every protected program once. So a change made around the kernel, same size included, is checked again at the next start. A kernel without `integrity` counts nothing (so writes into protected paths cost no metadata update), and its writes don't move the version another kernel on the origin reads: give every kernel on one origin the same `integrity`. The cache is the kernel's own, in memory, so nothing verified outlives it. The compiled module is cached by the same key, so a program that hasn't changed costs nothing more to start.
   - **Revoking:** a result is kept until the file changes, so when `lookup`'s answers change (an updated hash list, a package revoked or reinstalled), call `await kernel.integrity.revoke(path?)` (on the page and in Node). It drops what the kernel verified for that path, or for everything under it when it's a directory (its real path and the name a link reached it by both count), or for every path without one, and rebuilds the command catalog from the manifests as checked again. A load that was under way when `revoke` was called keeps nothing. It takes effect at the next start: running processes keep what they loaded. `path` must be absolute; without `integrity` it does nothing.
-  - **Where `lookup` gets its hashes:** from a source independent of the installed files, such as the per-file hashes the embedder derives from the certified package tarball when it builds its catalog. Hashes read back from the installed files prove nothing.
+  - **Where `lookup` gets its hashes:** from a source independent of the installed files, such as the per-file hashes the embedder derives from the published package tarball when it builds its catalog. Hashes read back from the installed files prove nothing.
   - **Links out of the paths:** a file reached through a protected path but whose real path lies outside every path (a symlink at or below a protected path, or one of its directories, pointing elsewhere, a command of the catalog included) is still checked, under the last protected name on the way: the kernel asks `lookup(name)` for the bytes of the real file, `unknown` applies when it has no hash, and `onDenial` reports the name as `path`. Writes outside the paths aren't counted, so such a result isn't cached: the file is hashed again at every start.
   - **Sources a program reads itself** ([#454](https://github.com/ai-ecoverse/slicc-kernel/issues/454)): a runtime that loads code on its own is checked too, when a process reads the file through the kernel. That covers jsh's and slicc-node's modules and the `package.json` files whose `main`/`exports` they follow, python's `.py`, `.pyc`, `.pth` and zip imports, `dlopen`'s side modules, and a script's interpreter reading the script after its exec check (a file swapped in between is refused then).
     - **Which files:** those under a path whose name ends in one of `integrity.sources`, plus every regular file with an execute bit (a `#!` script without a suffix, a sourced script). The default is `['.js', '.mjs', '.cjs', '.json', '.py', '.pyc', '.pth', '.zip', '.so', '.wasm', '.sh']`. An embedder can replace the list, and `sources: []` turns these checks off and leaves only the ones above. Data files aren't checked, since a package can hold files no `lookup` knows (lock files, caches), which `unknown: 'deny'` would make unreadable.

package/dist/kernel-worker.js

@@ -7728,7 +7728,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.146.1" : "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
@@ -8600,6 +8600,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 = parentOf5(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 = parentOf5(p)) {
+      if (this.flying.has(p)) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
+};
 function webLocks() {
   return globalThis.navigator?.locks;
 }
@@ -8653,14 +8702,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;
@@ -8682,7 +8730,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);
@@ -8693,10 +8740,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);
       }
@@ -8747,25 +8793,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 && counted2(st)])
     };
@@ -8777,24 +8813,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 = parentOf5(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 = parentOf5(p)) {
@@ -13610,13 +13635,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, open2, real) ?? null);
     }
   }
   entry.hold?.(path, on, open2, void 0, req.handle);
   return done2;
 }
+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);
@@ -28971,6 +29007,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;
@@ -29105,6 +29142,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 } } : {}
       }
     );
@@ -31026,6 +31064,7 @@ var Launcher = class {
         locks: webLocks(),
         busy: (path) => [...this.openFiles].some((open2) => open2.holds(path)),
         owner: this.unlinkOwnerOption,
+        marks: this.pathMarks,
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );