@zenfs/core 2.7.6 → 2.8.0

package/dist/vfs/async.js

@@ -53,16 +53,16 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { rethrow, setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
-import { contextOf } from '../internal/contexts.js';
-import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { applyUmask, contextOf } from '../internal/contexts.js';
+import { assertRemovable, assertSearchable, hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
-import { normalizeMode, normalizePath } from '../utils.js';
-import { checkAccess } from './config.js';
+import { normalizeMode, normalizePath, normalizeTime } from '../utils.js';
+import { checkAccess, resolveFullWalk } from './config.js';
 import { Dirent, ifToDt } from './dir.js';
 import { Handle } from './file.js';
 import * as flags from './flags.js';
 import { resolveMount } from './shared.js';
-import { cacheOf, lockPath } from './vcache.js';
+import { cacheOf } from './vcache.js';
 import { emitChange } from './watchers.js';
 /**
  * Resolves the mount and real path for a path.
@@ -71,38 +71,44 @@ import { emitChange } from './watchers.js';
  */
 export async function resolve($, path, preserveSymlinks, extra) {
     path = resolvePath.call($, path);
-    if (preserveSymlinks) {
-        const resolved = resolveMount(path, $, extra);
-        const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? (await resolved.fs.stat(resolved.path).catch(() => undefined));
-        return { ...resolved, fullPath: path, stats };
-    }
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
-    try {
-        const resolved = resolveMount(path, $);
-        const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? (await resolved.fs.stat(resolved.path));
-        if (!isSymbolicLink(stats)) {
-            return { ...resolved, fullPath: path, stats };
+    if (!resolveFullWalk)
+        try {
+            const resolved = resolveMount(path, $);
+            const stats = await resolved.cache.stat(resolved.path);
+            if (!isSymbolicLink(stats) || preserveSymlinks) {
+                return { ...resolved, fullPath: path, stats };
+            }
+            const target = resolvePath.call($, dirname(path), await readlink.call($, path));
+            return await resolve($, target, preserveSymlinks, extra);
+        }
+        catch {
+            // Go the long way
         }
-        const target = resolvePath.call($, dirname(path), await readlink.call($, path));
-        return await resolve($, target, preserveSymlinks, extra);
+    const { base, dir } = parse(path);
+    const $ex = { syscall: 'stat', path, ...extra };
+    let realDir = '/';
+    if (dir != '/') {
+        const parent = await resolve($, dir, false, extra);
+        if (parent.stats && isDirectory(parent.stats))
+            assertSearchable($, parent.stats, $ex);
+        realDir = parent.fullPath;
     }
-    catch {
-        // Go the long way
+    else if (base && checkAccess) {
+        const root = resolveMount('/', $);
+        assertSearchable($, await root.cache.stat(root.path), $ex);
     }
-    const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : (await resolve($, dir, false, extra)).fullPath;
     const maybePath = join(realDir, base);
     const resolved = resolveMount(maybePath, $);
-    const stats = cacheOf(resolved.fs).get(resolved.path)?.inode
-        ?? (await resolved.fs.stat(resolved.path).catch((e) => {
-            if (e.code == 'ENOENT')
-                return;
-            throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
-        }));
+    const stats = await resolved.cache.stat(resolved.path).catch((e) => {
+        if (e.code == 'ENOENT')
+            return;
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
+    });
     if (!stats)
         return { ...resolved, fullPath: maybePath };
-    if (!isSymbolicLink(stats)) {
+    if (!isSymbolicLink(stats) || preserveSymlinks) {
         return { ...resolved, fullPath: maybePath, stats };
     }
     const target = resolvePath.call($, realDir, await readlink.call($, maybePath));
@@ -117,7 +123,7 @@ export async function open($, path, opt) {
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     const $ex = { syscall: 'open', path };
     // eslint-disable-next-line prefer-const
-    let { fs, path: resolved, stats } = await resolve($, path, opt.preserveSymlinks, $ex);
+    let { fs, cache, path: resolved, stats } = await resolve($, path, opt.preserveSymlinks, $ex);
     if (!stats) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
@@ -125,25 +131,25 @@ export async function open($, path, opt) {
                 throw UV('ENOENT', $ex);
             // Create the file
             const parentPath = dirname(resolved);
-            const parentStats = await fs.stat(parentPath);
-            if (checkAccess && !hasAccess($, parentStats, constants.W_OK))
+            const parentStats = await cache.stat(parentPath, $ex);
+            if (checkAccess && !hasAccess($, parentStats, constants.W_OK | constants.X_OK))
                 throw UV('EACCES', 'open', dirname(path));
             if (!isDirectory(parentStats))
                 throw UV('ENOTDIR', 'open', dirname(path));
             if (!opt.allowDirectory && isDirectory({ mode }))
                 throw UV('EISDIR', 'open', path);
             // Serialize entry creation with other operations on the parent directory
-            const _ = __addDisposableResource(env_1, await lockPath(fs, parentPath, 'rw', parentStats), false);
-            stats = cacheOf(fs).get(resolved)?.inode ?? (await fs.stat(resolved).catch(() => undefined));
+            const _ = __addDisposableResource(env_1, await cache.lock(parentPath, 'rw', parentStats), false);
+            stats = await cache.stat(resolved).catch(() => undefined);
             if (!stats) {
                 const { euid: uid, egid: gid } = contextOf($).credentials;
                 const inode = await fs.createFile(resolved, {
-                    mode,
+                    mode: applyUmask($, mode),
                     uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
                     gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
                 });
                 emitChange($, 'rename', path);
-                return new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
+                return new Handle($, path, resolved, flag, cache.ref(resolved, inode));
             }
         }
         catch (e_1) {
@@ -158,9 +164,9 @@ export async function open($, path, opt) {
         throw UV('EACCES', $ex);
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', $ex);
-    if (!opt.allowDirectory && isDirectory({ mode }))
+    if (!opt.allowDirectory && isDirectory(stats))
         throw UV('EISDIR', 'open', path);
-    const handle = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
+    const handle = new Handle($, path, resolved, flag, cache.ref(resolved, stats));
     if (flag & constants.O_TRUNC)
         await handle.truncate(0);
     return handle;
@@ -183,20 +189,21 @@ export async function readlink(path) {
 export async function mkdir(path, options = {}) {
     const original = normalizePath.call(this, path);
     const { euid: uid, egid: gid } = contextOf(this).credentials;
-    const { mode = 0o777, recursive } = options;
+    const { recursive } = options;
+    const mode = applyUmask(this, options.mode ?? 0o777);
     const $ex = { syscall: 'mkdir', path: original };
     const { fullPath: realParent } = await resolve(this, dirname(original), false, $ex);
-    const { fs, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
+    const { fs, cache, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
     const followed = realParent != dirname(original);
     let firstCreated;
     const __create = async (path, resolved) => {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const parentPath = dirname(resolved);
-            const parent = recursive && parentPath != '/' ? await __create(dirname(path), parentPath) : await fs.stat(parentPath);
-            const _ = __addDisposableResource(env_2, await lockPath(fs, parentPath, 'rw', parent), false);
+            const parent = recursive && parentPath != '/' ? await __create(dirname(path), parentPath) : await cache.stat(parentPath, $ex);
+            const _ = __addDisposableResource(env_2, await cache.lock(parentPath, 'rw', parent), false);
             if (recursive) {
-                const existing = cacheOf(fs).get(resolved)?.inode ?? (await fs.stat(resolved).catch(() => null));
+                const existing = await cache.stat(resolved).catch(() => null);
                 if (existing) {
                     const stats = isSymbolicLink(existing) ? (await resolve(this, path, false, $ex)).stats : existing;
                     if (!stats)
@@ -209,7 +216,7 @@ export async function mkdir(path, options = {}) {
                 if (followed && (await fs.exists(join(parentPath, basename(path)))))
                     throw UV('ENOTDIR', 'mkdir', path);
             }
-            if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+            if (checkAccess && !hasAccess(this, parent, constants.W_OK | constants.X_OK))
                 throw UV('EACCES', 'mkdir', path);
             const inode = await fs
                 .mkdir(resolved, {
@@ -237,7 +244,7 @@ export async function mkdir(path, options = {}) {
 export async function readdir(path, options = {}) {
     path = normalizePath.call(this, path);
     const $ex = { syscall: 'scandir', path };
-    const { fs, path: resolved, stats } = await resolve(this, path, false, $ex);
+    const { fs, cache, path: resolved, stats } = await resolve(this, path, false, $ex);
     if (!stats)
         throw UV('ENOENT', $ex);
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
@@ -248,7 +255,7 @@ export async function readdir(path, options = {}) {
     {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_3, await lockPath(fs, resolved, 'ro', stats), false);
+            const _ = __addDisposableResource(env_3, await cache.lock(resolved, 'ro', stats), false);
             entries = await fs.readdir(resolved);
         }
         catch (e_3) {
@@ -261,7 +268,7 @@ export async function readdir(path, options = {}) {
     }
     const values = [];
     const addEntry = async (entry) => {
-        const entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
+        const entryStats = await cache.stat(join(resolved, entry), $ex).catch((e) => {
             if (e.code == 'ENOENT')
                 return;
             throw e;
@@ -290,7 +297,7 @@ export async function rename(oldPath, newPath) {
         newPath = normalizePath.call(this, newPath);
         const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
         const src = await resolve(this, oldPath, true, $ex);
-        const dst = resolveMount(newPath, this, $ex);
+        const dst = await resolve(this, newPath, true, $ex);
         if (src.fs.uuid !== dst.fs.uuid)
             throw UV('EXDEV', $ex);
         // A directory can not be moved inside itself
@@ -298,22 +305,26 @@ export async function rename(oldPath, newPath) {
             throw UV('EINVAL', $ex);
         if (!src.stats)
             throw UV('ENOENT', $ex);
-        const fs = src.fs;
-        const oldParent = await fs.stat(dirname(src.path));
-        const newParent = await fs.stat(dirname(dst.path));
-        const newStats = await fs.stat(dst.path).catch((e) => {
+        const srcDir = dirname(src.path);
+        const dstDir = dirname(dst.path);
+        const oldParent = await src.cache.stat(srcDir, $ex);
+        const newParent = await src.cache.stat(dstDir, $ex);
+        const newStats = await src.cache.stat(dst.path, $ex).catch((e) => {
             if (e.code == 'ENOENT')
                 return null;
             throw e;
         });
-        if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
+        assertRemovable(this, oldParent, src.stats, $ex);
+        if (newStats)
+            assertRemovable(this, newParent, newStats, $ex);
+        if (checkAccess && !hasAccess(this, newParent, constants.W_OK | constants.X_OK))
+            throw UV('EACCES', $ex);
+        if (checkAccess && isDirectory(src.stats) && srcDir != dstDir && !hasAccess(this, src.stats, constants.W_OK))
             throw UV('EACCES', $ex);
         if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
             throw UV('EISDIR', $ex);
         if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
             throw UV('ENOTDIR', $ex);
-        const srcDir = dirname(src.path);
-        const dstDir = dirname(dst.path);
         // Lock both parent directories, ordered by inode number to avoid ABBA deadlocks (like Linux's `lock_two_nondirectories`)
         const parents = [
             [srcDir, oldParent],
@@ -321,10 +332,10 @@ export async function rename(oldPath, newPath) {
         ];
         if (oldParent.ino > newParent.ino)
             parents.reverse();
-        const _first = __addDisposableResource(env_4, await lockPath(fs, parents[0][0], 'rw', parents[0][1]), false);
-        const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : await lockPath(fs, parents[1][0], 'rw', parents[1][1]), false);
+        const _first = __addDisposableResource(env_4, await src.cache.lock(parents[0][0], 'rw', parents[0][1]), false);
+        const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : await src.cache.lock(parents[1][0], 'rw', parents[1][1]), false);
         await src.fs.rename(src.path, dst.path);
-        cacheOf(fs).rename(src.path, dst.path);
+        src.cache.rename(src.path, dst.path);
         emitChange(this, 'rename', oldPath);
         emitChange(this, 'rename', newPath);
     }
@@ -342,24 +353,24 @@ export async function link(target, link) {
         target = normalizePath.call(this, target);
         link = normalizePath.call(this, link);
         const $ex = { syscall: 'link', path: target, dest: link };
-        const { fs, path: resolved } = resolveMount(target, this, $ex);
-        const dst = resolveMount(link, this, $ex);
+        const { fs, cache, path: resolved } = await resolve(this, target, true, $ex);
+        const dst = await resolve(this, link, true, $ex);
         if (fs.uuid != dst.fs.uuid)
             throw UV('EXDEV', $ex);
-        const stats = await fs.stat(resolved);
+        const stats = await cache.stat(resolved, $ex);
         if (checkAccess) {
             if (!hasAccess(this, stats, constants.R_OK))
                 throw UV('EACCES', $ex);
-            const dirStats = await fs.stat(dirname(resolved));
+            const dirStats = await cache.stat(dirname(resolved), $ex);
             if (!hasAccess(this, dirStats, constants.R_OK))
                 throw UV('EACCES', $ex);
-            const destStats = await fs.stat(dirname(dst.path));
+            const destStats = await cache.stat(dirname(dst.path), $ex);
             if (!hasAccess(this, destStats, constants.W_OK))
                 throw UV('EACCES', $ex);
         }
-        const _ = __addDisposableResource(env_5, await lockPath(fs, dirname(dst.path), 'rw'), false);
+        const _ = __addDisposableResource(env_5, await cache.lock(dirname(dst.path), 'rw'), false);
         await fs.link(resolved, dst.path);
-        cacheOf(fs).link(resolved, dst.path);
+        cache.link(resolved, dst.path);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -377,13 +388,82 @@ export async function stat(path, lstat) {
         stats = (await resolve(this, path, false, extra)).stats;
     else {
         const { base, dir } = parse(path);
-        const { fs, path: parent } = await resolve(this, dir, false, extra);
-        const target = base ? join(parent, base) : parent;
-        stats = cacheOf(fs).get(target)?.inode ?? (await fs.stat(target).catch(rethrow(extra)));
+        const parent = await resolve(this, dir, false, extra);
+        if (parent.stats && isDirectory(parent.stats))
+            assertSearchable(this, parent.stats, extra);
+        const { root, mounts } = contextOf(this);
+        const mounted = base && mounts.get(join(root, parent.fullPath, base));
+        const fs = mounted || parent.fs;
+        const target = mounted ? '/' : join(parent.path, base);
+        stats = await cacheOf(fs).stat(target).catch(rethrow(extra));
     }
     if (!stats)
         throw UV('ENOENT', extra);
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', extra);
     return stats;
 }
+/**
+ * Opens a handle for changing metadata, which does not need read or write access to the file.
+ */
+async function _openMetadata($, path, syscall, noFollow) {
+    const { fullPath, cache, path: resolved, stats } = await resolve($, path, noFollow, { syscall });
+    if (!stats)
+        throw UV('ENOENT', syscall, path);
+    return new Handle($, fullPath, resolved, constants.O_RDONLY, cache.ref(resolved, stats));
+}
+export async function chmod(path, mode, noFollow) {
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const numMode = normalizeMode(mode, -1);
+        if (numMode < 0)
+            throw UV('EINVAL', 'chmod', path);
+        const handle = __addDisposableResource(env_6, await _openMetadata(this, path, 'chmod', noFollow), true);
+        await handle.chmod(numMode);
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_6);
+        if (result_1)
+            await result_1;
+    }
+}
+export async function chown(path, uid, gid, noFollow) {
+    const env_7 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const handle = __addDisposableResource(env_7, await _openMetadata(this, path, 'chown', noFollow), true);
+        await handle.chown(uid, gid);
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_7);
+        if (result_2)
+            await result_2;
+    }
+}
+export async function utimes(path, atime, mtime, noFollow) {
+    const env_8 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const handle = __addDisposableResource(env_8, await _openMetadata(this, path, 'utimes', noFollow), true);
+        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_8);
+        if (result_3)
+            await result_3;
+    }
+}

package/dist/vfs/config.d.ts

@@ -1,6 +1,15 @@
 /** Whether to perform access checks */
 export declare let checkAccess: boolean;
+/** If set, path resolution will always do a full walk. More correct but potentially very slow. */
+export declare let resolveFullWalk: boolean;
 /**
  * @internal @hidden
  */
-export declare function _setAccessChecks(value: boolean): void;
+export interface _VFSConfig {
+    checkAccess: boolean;
+    resolveFullWalk: boolean;
+}
+/**
+ * @internal @hidden
+ */
+export declare function _setVFSConfig(cfg: _VFSConfig): void;

package/dist/vfs/config.js

@@ -1,9 +1,12 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 /** Whether to perform access checks */
 export let checkAccess = true;
+/** If set, path resolution will always do a full walk. More correct but potentially very slow. */
+export let resolveFullWalk = false;
 /**
  * @internal @hidden
  */
-export function _setAccessChecks(value) {
-    checkAccess = value;
+export function _setVFSConfig(cfg) {
+    checkAccess = cfg.checkAccess;
+    resolveFullWalk = cfg.resolveFullWalk;
 }

package/dist/vfs/file.js

@@ -89,7 +89,7 @@ import { UV, withErrno } from 'kerium';
 import { memoize } from 'utilium';
 import * as c from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
-import { _chown, InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
+import { _chmod, _chown, assertCanChown, assertOwner, InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
 import '../polyfills.js';
 import { validateFD } from '../utils.js';
 import { cacheOf } from './vcache.js';
@@ -328,9 +328,10 @@ let Handle = (() => {
             try {
                 if (this.closed)
                     throw UV('EBADF', 'chmod', this.path);
+                assertOwner(this.context, this.inode, { syscall: 'chmod', path: this.path });
                 const _ = __addDisposableResource(env_5, this.vnode.lockSync('rw'), false);
                 this.vnode.metadataDirty = true;
-                this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+                _chmod(this.context, this.inode, mode);
                 if (this._isSync || mode > c.S_IFMT)
                     this.vnode.syncSync();
             }
@@ -346,7 +347,8 @@ let Handle = (() => {
             const env_6 = { stack: [], error: void 0, hasError: false };
             try {
                 if (this.closed)
-                    throw UV('EBADF', 'chmod', this.path);
+                    throw UV('EBADF', 'chown', this.path);
+                assertCanChown(this.context, this.inode, uid, gid, { syscall: 'chown', path: this.path });
                 const _ = __addDisposableResource(env_6, this.vnode.lockSync('rw'), false);
                 this.vnode.metadataDirty = true;
                 _chown(this.inode, uid, gid);
@@ -369,6 +371,7 @@ let Handle = (() => {
             try {
                 if (this.closed)
                     throw UV('EBADF', 'utimes', this.path);
+                assertOwner(this.context, this.inode, { syscall: 'utimes', path: this.path });
                 const _ = __addDisposableResource(env_7, this.vnode.lockSync('rw'), false);
                 this.vnode.metadataDirty = true;
                 this.inode.atimeMs = atime;
@@ -542,9 +545,10 @@ let Handle = (() => {
             try {
                 if (this.closed)
                     throw UV('EBADF', 'chmod', this.path);
+                assertOwner(this.context, this.inode, { syscall: 'chmod', path: this.path });
                 const _ = __addDisposableResource(env_12, await this.vnode.lock('rw'), false);
                 this.vnode.metadataDirty = true;
-                this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+                _chmod(this.context, this.inode, mode);
                 if (this._isSync || mode > c.S_IFMT)
                     await this.vnode.sync();
             }
@@ -561,6 +565,7 @@ let Handle = (() => {
             try {
                 if (this.closed)
                     throw UV('EBADF', 'chown', this.path);
+                assertCanChown(this.context, this.inode, uid, gid, { syscall: 'chown', path: this.path });
                 const _ = __addDisposableResource(env_13, await this.vnode.lock('rw'), false);
                 this.vnode.metadataDirty = true;
                 _chown(this.inode, uid, gid);
@@ -583,6 +588,7 @@ let Handle = (() => {
             try {
                 if (this.closed)
                     throw UV('EBADF', 'utimes', this.path);
+                assertOwner(this.context, this.inode, { syscall: 'utimes', path: this.path });
                 const _ = __addDisposableResource(env_14, await this.vnode.lock('rw'), false);
                 this.vnode.metadataDirty = true;
                 this.inode.atimeMs = atime;

package/dist/vfs/ioctl.js

@@ -30,7 +30,7 @@ export async function ioctl(path, command, ...args) {
         const mnt = await resolveAsync(this, path, false, { syscall: 'ioctl', path });
         if (!mnt.stats)
             throw UV('ENOENT', { syscall: 'ioctl', path });
-        vcache = cacheOf(mnt.fs);
+        vcache = mnt.cache;
         vnode = vcache.ref(mnt.path, vcache.get(mnt.path)?.inode ?? mnt.stats);
     }
     const context = {
@@ -68,7 +68,7 @@ export function ioctlSync(path, command, ...args) {
         const mnt = resolveSync(this, path, false, { syscall: 'ioctl', path });
         if (!mnt.stats)
             throw UV('ENOENT', { syscall: 'ioctl', path });
-        vcache = cacheOf(mnt.fs);
+        vcache = mnt.cache;
         vnode = vcache.ref(mnt.path, vcache.get(mnt.path)?.inode ?? mnt.stats);
     }
     const context = {

package/dist/vfs/shared.d.ts

@@ -4,6 +4,7 @@ import type { FileSystem } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import { type ExceptionExtra } from 'kerium';
 import { type AbsolutePath } from '../path.js';
+import { VCache } from './vcache.js';
 /**
  * @internal @hidden
  */
@@ -33,6 +34,7 @@ export declare function umount(this: V_Context, mountPoint: string): void;
  */
 export interface ResolvedMount {
     fs: FileSystem;
+    cache: VCache;
     path: string;
     mountPoint: string;
     root: string;

package/dist/vfs/shared.js

@@ -9,7 +9,7 @@ import { credentialsAllowRoot } from '../internal/credentials.js';
 import { withExceptionContext } from '../internal/error.js';
 import { join, resolve } from '../path.js';
 import { normalizePath } from '../utils.js';
-import { caches, VCache } from './vcache.js';
+import { cacheOf, caches, VCache } from './vcache.js';
 /**
  * The map of mount points
  * @category Backends and Configuration
@@ -34,8 +34,7 @@ export function mount(mountPoint, fs) {
         throw err(withErrno('EINVAL', 'Mount point is already in use: ' + mountPoint));
     fs._mountPoint = mountPoint;
     $.mounts.set(mountPoint, fs);
-    if (!caches.has(fs.uuid))
-        caches.set(fs.uuid, new VCache(fs));
+    caches.getOrInsertComputed(fs.uuid, () => new VCache(fs));
     info(`Mounted ${fs.name} on ${mountPoint}`);
     debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : k)).join(', ')}`);
 }
@@ -91,7 +90,7 @@ export function resolveMount(path, ctx, extra) {
             path = path.toLowerCase();
         if (case_fold === 'upper')
             path = path.toUpperCase();
-        return { fs: withExceptionContext(fs, _exceptionContext), path, mountPoint, root };
+        return { fs: withExceptionContext(fs, _exceptionContext), cache: cacheOf(fs), path, mountPoint, root };
     }
     throw alert(new Exception(Errno.EIO, 'No file system for ' + path));
 }

package/dist/vfs/sync.d.ts

@@ -1,4 +1,4 @@
-import type { PathLike } from 'node:fs';
+import type { Mode, PathLike, TimeLike } from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { MkdirOptions, OpenOptions, ReaddirOptions, ResolvedPath } from './shared.js';
@@ -23,3 +23,6 @@ export declare function readdir(this: V_Context, path: PathLike, options?: Readd
 export declare function rename(this: V_Context, oldPath: PathLike, newPath: PathLike): void;
 export declare function link(this: V_Context, target: PathLike, link: PathLike): void;
 export declare function stat(this: V_Context, path: PathLike, lstat: boolean): InodeLike;
+export declare function chmod(this: V_Context, path: PathLike, mode: Mode, noFollow?: boolean): void;
+export declare function chown(this: V_Context, path: PathLike, uid: number, gid: number, noFollow?: boolean): void;
+export declare function utimes(this: V_Context, path: PathLike, atime: TimeLike, mtime: TimeLike, noFollow?: boolean): void;