@volter/browser-wali 0.1.15 → 0.1.17

package/dist/filesystem.js

@@ -3,6 +3,7 @@ import { WaliDescriptionRegistry, WaliProcessDescriptorTable } from "./descripto
 import { createProcessFilesystemMutationGuard } from "@volter/browser-runtime/browser-process-filesystem-policy.js";
 import { BufferedWaliStdin } from "./stdin.js";
 import { readWaliSymlink, resolveWaliSymlinkPath, writeWaliSymlink } from "./symlink.js";
+import { PR_WALI, PR_WALI_TREE_ADOPT, PR_WALI_TREE_CONFIRM, PR_WALI_TREE_DECLINE, PR_WALI_TREE_RELEASE, PRIVATE_TREE_INODES, PRIVATE_TREE_WINDOW_BASE, PRIVATE_TREE_WINDOW_SIZE, decodePrivateTree, encodePrivateTree, inPrivateTreeWindow, } from "./private-tree.js";
 let reportedDroppedEnvironment = false;
 const AT_FDCWD = -100;
 const O_ACCMODE = 3;
@@ -58,6 +59,9 @@ export class WaliFileDescriptorTable {
     cwd;
     guestFilesystem;
     assertWritable;
+    /** The private root the program's libc holds, while it holds it (ADR-0047). */
+    privateTree;
+    privateTreeDeclined = false;
     constructor(options) {
         this.options = options;
         this.descriptors = options.descriptors ?? new WaliProcessDescriptorTable(new WaliDescriptionRegistry());
@@ -93,6 +97,8 @@ export class WaliFileDescriptorTable {
             renameSync: (from, to) => fs.renameSync(this.assertWritable(from), this.assertWritable(to)),
             ...(fs.chmodSync ? { chmodSync: (path, mode) => fs.chmodSync(this.assertWritable(path), mode) } : {}),
             ...(fs.utimesSync ? { utimesSync: (path, atime, mtime) => fs.utimesSync(this.assertWritable(path), atime, mtime) } : {}),
+            ...(fs.reserveInodes ? { reserveInodes: fs.reserveInodes.bind(fs) } : {}),
+            ...(fs.restoreNodeSync ? { restoreNodeSync: (path, node) => fs.restoreNodeSync(this.assertWritable(path), node) } : {}),
         } : fs;
         this.stdin = "read" in options.stdin ? options.stdin : new BufferedWaliStdin(options.stdin);
         if (!options.descriptors) {
@@ -166,6 +172,9 @@ export class WaliFileDescriptorTable {
             SYS_fsync: (fd) => this.hasFd(Number(fd)) ? 0n : -9n,
             SYS_fdatasync: (fd) => this.hasFd(Number(fd)) ? 0n : -9n,
             SYS_flock: (fd, operation) => this.flock(Number(fd), Number(operation)),
+            // ADR-0047's handshake; every other prctl answers 0, as before.
+            SYS_prctl: (option, operation, pointer, length) => Number(option) === PR_WALI
+                ? this.privateTreeCall(Number(operation), Number(pointer), Number(length)) : 0n,
         };
     }
     writeEnvironmentFile(env, pid) {
@@ -462,6 +471,11 @@ export class WaliFileDescriptorTable {
     allocateFd(minimum = 3) {
         const maximum = this.options.descriptorMaximum ?? 65_535;
         for (let fd = Math.max(minimum, 0); fd <= maximum; fd += 1) {
+            // A private tree's numbers are its libc's, held or given back (ADR-0047).
+            if (inPrivateTreeWindow(fd)) {
+                fd = PRIVATE_TREE_WINDOW_BASE + PRIVATE_TREE_WINDOW_SIZE - 1;
+                continue;
+            }
             // `stdioFd` covers 0-2, this table's own aliases and the shared registry.
             if (this.descriptors.get(fd) || this.files.has(fd) || this.specialDescriptors.has(fd)
                 || this.stdioFd(fd) !== undefined)
@@ -695,7 +709,8 @@ export class WaliFileDescriptorTable {
                 throw errno("EINVAL");
             const base = whence === SEEK_SET ? 0 : whence === SEEK_CUR ? file.position
                 : whence === SEEK_END ? this.fs().statSync(file.path).size : undefined;
-            if (base === undefined || base + offset < 0)
+            // An offset or a position past 2^53 - 1 is not one a double holds (musl 0005's lseek says the same).
+            if (base === undefined || !Number.isSafeInteger(offset) || base + offset < 0 || !Number.isSafeInteger(base + offset))
                 throw errno("EINVAL");
             file.position = base + offset;
             return BigInt(file.position);
@@ -935,7 +950,36 @@ export class WaliFileDescriptorTable {
         }
     }
     rename(from, to) {
-        return this.mutate(() => this.fs().renameSync(this.resolveFilesystemPath(this.resolve(from), false), this.resolveFilesystemPath(this.resolve(to), false)));
+        return this.mutate(() => {
+            const source = this.resolveFilesystemPath(this.resolve(from), false);
+            const destination = this.resolveFilesystemPath(this.resolve(to), false);
+            // Moving a directory the held tree is under moves the tree: the libc's to release first (ADR-0047).
+            if (this.privateTree && (underRoot(this.privateTree.root, source) || underRoot(this.privateTree.root, destination)))
+                throw errno("EREMOTE");
+            const fs = this.fs();
+            // Linux's rules, before the store's move: a file never replaces a
+            // directory nor a directory a file, a directory only an empty one, and
+            // never into itself. The store's move sets the source over whatever the
+            // destination held and leaves that directory's children named under a
+            // file, a tree no later snapshot can be laid out from.
+            if (fs.existsSync(source)) {
+                if (source === destination)
+                    return;
+                const directory = fs.statSync(source).isDirectory();
+                if (directory && destination.startsWith(`${source}/`))
+                    throw errno("EINVAL");
+                if (fs.existsSync(destination)) {
+                    const into = fs.statSync(destination).isDirectory();
+                    if (directory && !into)
+                        throw errno("ENOTDIR");
+                    if (!directory && into)
+                        throw errno("EISDIR");
+                    if (directory && fs.readdirSync(destination).length > 0)
+                        throw errno("ENOTEMPTY");
+                }
+            }
+            fs.renameSync(source, destination);
+        });
     }
     utimensat(dirfd, pathPointer, timesPointer, flags) {
         try {
@@ -984,6 +1028,8 @@ export class WaliFileDescriptorTable {
             if (!Number.isSafeInteger(size) || size < 0)
                 throw errno("EINVAL");
             const resolved = this.resolveAt(dirfd, path);
+            if (this.privateTree && underRoot(resolved, this.privateTree.root))
+                throw errno("EREMOTE");
             let target;
             if (resolved === "/proc/self/exe")
                 target = this.options.executablePath ?? "/usr/bin/wali-program";
@@ -1018,7 +1064,13 @@ export class WaliFileDescriptorTable {
         }
     }
     resolveFilesystemPath(path, followFinal = true) {
-        return resolveWaliSymlinkPath(this.fs(), path, followFinal);
+        const resolved = resolveWaliSymlinkPath(this.fs(), path, followFinal);
+        // A held private tree is the libc's: a path that reaches it here (a symlink
+        // elsewhere, a directory descriptor) is EREMOTE, and the libc releases the
+        // tree and asks again (ADR-0047 §3).
+        if (this.privateTree && underRoot(resolved, this.privateTree.root))
+            throw errno("EREMOTE");
+        return resolved;
     }
     readSymlink(path) {
         return readWaliSymlink(this.fs(), path);
@@ -1028,7 +1080,7 @@ export class WaliFileDescriptorTable {
         const stdio = this.stdioFd(fd);
         if (stdio !== undefined) {
             const next = target ?? this.allocateFd(minimum);
-            if (next < 0 || next > maximum)
+            if (next < 0 || (next > maximum && !inPrivateTreeWindow(next)))
                 return -9n;
             if (next === fd)
                 return BigInt(next);
@@ -1040,7 +1092,7 @@ export class WaliFileDescriptorTable {
         if (!this.descriptors.get(fd))
             return -9n;
         const next = target ?? this.allocateFd(minimum);
-        if (next < 0 || next > maximum)
+        if (next < 0 || (next > maximum && !inPrivateTreeWindow(next)))
             return -9n;
         if (next === fd)
             return BigInt(next);
@@ -1283,6 +1335,194 @@ export class WaliFileDescriptorTable {
             return negativeErrno(error);
         }
     }
+    privateTreeCall(operation, pointer, length) {
+        try {
+            if (operation === PR_WALI_TREE_ADOPT)
+                return this.adoptPrivateTree(pointer, length);
+            if (operation === PR_WALI_TREE_RELEASE)
+                return this.releasePrivateTree(pointer, length);
+            if (operation === PR_WALI_TREE_CONFIRM)
+                return this.confirmPrivateTree();
+            if (operation === PR_WALI_TREE_DECLINE) {
+                // The libc could not take the tree: it stays the kernel's, as it was,
+                // with anything a CONFIRM that failed part-way had removed put back.
+                const handed = this.privateTree?.handed;
+                if (!handed)
+                    return -22n;
+                const fs = this.fs();
+                for (const node of handed)
+                    if (!fs.existsSync(node.path)) {
+                        if (fs.restoreNodeSync)
+                            fs.restoreNodeSync(node.path, node);
+                        else {
+                            if (node.directory)
+                                fs.mkdirSync(node.path, { recursive: true });
+                            else
+                                fs.writeFileSync(node.path, node.content);
+                            fs.chmodSync?.(node.path, node.mode & 0o7777);
+                            fs.utimesSync?.(node.path, node.atimeMs, node.mtimeMs);
+                        }
+                    }
+                this.privateTree = undefined;
+                return 0n;
+            }
+            return -22n;
+        }
+        catch (error) {
+            return negativeErrno(error);
+        }
+    }
+    /**
+     * ADOPT (ADR-0047 §3): the first private root, offered only while nothing
+     * else can see it. The reply is the window, the inode range, the root, the
+     * working directory, and what the kernel's tree already held there (a run's
+     * environment file), which leaves the kernel's tree. 0 declines, as an
+     * older kernel's answer to every prctl does.
+     */
+    adoptPrivateTree(pointer, length) {
+        const decline = (why) => {
+            if (!this.privateTreeDeclined) {
+                this.privateTreeDeclined = true;
+                this.options.onDiagnostic?.(`[WALI] the private tree is not the program's (ADR-0047): ${why}; its file calls cross into the kernel.`);
+            }
+            return 0n;
+        };
+        if (this.privateTree)
+            return decline("it is held already");
+        const root = this.options.privateRoots?.[0];
+        if (!root)
+            return decline("the run names no private root");
+        if (root === "/")
+            return decline("the root is the whole filesystem");
+        if (this.options.privateTreeAdoptable && !this.options.privateTreeAdoptable())
+            return decline("a forked process shares the filesystem");
+        const fs = this.fs();
+        for (let fd = 0; fd < this.descriptors.entries.length; fd += 1) {
+            const file = this.files.get(fd);
+            if (file && underRoot(file.path, root))
+                return decline(`a descriptor is open under ${root}`);
+        }
+        try {
+            this.assertWritable(`${root}/.wali-private-tree`);
+        }
+        catch {
+            return decline(`the run's filesystem grant does not allow writes under ${root}`);
+        }
+        if (fs.existsSync(root) && (!fs.statSync(root).isDirectory() || readWaliSymlink(fs, root) !== undefined))
+            return decline(`${root} is not a directory`);
+        // Made only once nothing declines: the offer is the one change.
+        if (!fs.existsSync(root))
+            fs.mkdirSync(root, { recursive: true });
+        const nodes = [];
+        const walk = (path) => {
+            const stat = fs.statSync(path);
+            const directory = stat.isDirectory();
+            nodes.push({ path, directory, mode: stat.mode ?? (directory ? 0o755 : 0o644), atimeMs: stat.atimeMs ?? stat.mtimeMs ?? 0, mtimeMs: stat.mtimeMs ?? 0, ino: stat.ino ?? 1, content: directory ? new Uint8Array() : fs.readFileSync(path) });
+            if (directory)
+                for (const name of fs.readdirSync(path))
+                    walk(`${path === "/" ? "" : path}/${name}`);
+        };
+        walk(root);
+        const tree = encodePrivateTree(nodes);
+        const encoder = new TextEncoder();
+        const rootBytes = encoder.encode(root);
+        const cwdBytes = encoder.encode(this.cwd);
+        const size = 4 + 4 + 8 + 4 + rootBytes.byteLength + 4 + cwdBytes.byteLength + tree.byteLength;
+        if (size > length)
+            return decline(`what ${root} already holds is larger than the libc's ${length}-byte reply`);
+        const inodes = fs.reserveInodes?.(PRIVATE_TREE_INODES) ?? 2 ** 40;
+        const reply = new Uint8Array(size);
+        const view = new DataView(reply.buffer);
+        let at = 0;
+        view.setUint32(at, PRIVATE_TREE_WINDOW_BASE, true);
+        at += 4;
+        view.setUint32(at, PRIVATE_TREE_WINDOW_SIZE, true);
+        at += 4;
+        view.setBigUint64(at, BigInt(inodes), true);
+        at += 8;
+        view.setUint32(at, rootBytes.byteLength, true);
+        at += 4;
+        reply.set(rootBytes, at);
+        at += rootBytes.byteLength;
+        view.setUint32(at, cwdBytes.byteLength, true);
+        at += 4;
+        reply.set(cwdBytes, at);
+        at += cwdBytes.byteLength;
+        reply.set(tree, at);
+        this.copyIn(pointer, reply);
+        // Held from here; the kernel's copy stays until the libc says it took it
+        // (CONFIRM), so a libc that could not (DECLINE) loses nothing.
+        this.privateTree = { root, handed: nodes };
+        return BigInt(PRIVATE_TREE_WINDOW_BASE);
+    }
+    /** CONFIRM: the libc holds what ADOPT handed it, and the kernel's copy empties. */
+    confirmPrivateTree() {
+        const held = this.privateTree;
+        if (!held?.handed)
+            return -22n;
+        const fs = this.fs();
+        for (const node of held.handed.slice(1).reverse()) {
+            if (node.directory)
+                fs.rmdirSync(node.path);
+            else
+                fs.unlinkSync(node.path);
+        }
+        held.handed = undefined;
+        return 0n;
+    }
+    /**
+     * RELEASE (ADR-0047 §4): the tree and every descriptor on it, installed in
+     * this one call: the same paths, modes, times and inodes, the same
+     * descriptor numbers, positions and flags, and a dup's descriptors sharing
+     * one description again. From here every call on it is this kernel's.
+     */
+    releasePrivateTree(pointer, length) {
+        const held = this.privateTree;
+        if (!held || held.handed)
+            return -22n;
+        assertRange(this.options.memory(), pointer, length);
+        const { nodes, descriptors } = decodePrivateTree(this.copyOut(pointer, length), held.root);
+        const fs = this.fs();
+        for (const node of nodes) {
+            // Made in the tree, so made by this process, as the kernel's own open
+            // records: the first lock on it must not pull the page's (absent) copy
+            // over it (WaliCoherentFileLockClient).
+            if (!node.directory)
+                this.options.fileLocks?.created?.(node.path);
+            if (fs.restoreNodeSync)
+                fs.restoreNodeSync(node.path, node);
+            else {
+                if (node.directory)
+                    fs.mkdirSync(node.path, { recursive: true });
+                else
+                    fs.writeFileSync(node.path, node.content);
+                fs.chmodSync?.(node.path, node.mode & 0o7777);
+                fs.utimesSync?.(node.path, node.atimeMs, node.mtimeMs);
+            }
+        }
+        for (const descriptor of descriptors) {
+            if (this.descriptors.get(descriptor.fd))
+                this.descriptors.close(descriptor.fd);
+            if (descriptor.group === descriptor.fd) {
+                this.files.set(descriptor.fd, {
+                    path: descriptor.path, flags: descriptor.flags, position: descriptor.position,
+                    directory: descriptor.directory, description: this.nextDescription++,
+                });
+            }
+            else {
+                const shared = this.descriptors.get(descriptor.group);
+                if (!shared)
+                    throw errno("EINVAL");
+                this.descriptors.set(descriptor.fd, shared);
+            }
+            this.descriptors.entries[descriptor.fd].flags = descriptor.closeOnExec ? 1 : 0;
+        }
+        this.privateTree = undefined;
+        return 0n;
+    }
+}
+function underRoot(path, root) {
+    return path === root || path.startsWith(root === "/" ? "/" : `${root}/`);
 }
 function normalizePath(cwd, path) {
     if (!path)
@@ -1437,10 +1677,10 @@ function errno(errnoName) {
     return error;
 }
 const ERRNO_NUMBERS = {
-    EPERM: 1n, ENOENT: 2n, EIO: 5n, EAGAIN: 11n, ENOMEM: 12n, EACCES: 13n,
+    EPERM: 1n, ENOENT: 2n, EIO: 5n, EBADF: 9n, EAGAIN: 11n, ENOMEM: 12n, EACCES: 13n,
     EFAULT: 14n, EBUSY: 16n, EEXIST: 17n, EXDEV: 18n, ENOTDIR: 20n, EISDIR: 21n,
     EINVAL: 22n, EMFILE: 24n, ENOSPC: 28n, ESPIPE: 29n, EROFS: 30n, ERANGE: 34n,
-    ENOSYS: 38n, ENOTEMPTY: 39n, ELOOP: 40n, ENAMETOOLONG: 36n,
+    ENOSYS: 38n, ENOTEMPTY: 39n, ELOOP: 40n, ENAMETOOLONG: 36n, EREMOTE: 66n,
 };
 function negativeErrno(error) {
     // The errno's own name first, and the message parsed only for an error that has none.