@zenfs/core 1.2.9 → 1.3.0

package/dist/backends/store/fs.js

@@ -46,13 +46,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { credentials } from '../../credentials.js';
-import { S_IFDIR, S_IFREG } from '../../emulation/constants.js';
-import { basename, dirname, join, resolve } from '../../emulation/path.js';
+import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID } from '../../emulation/constants.js';
+import { basename, dirname, parse, resolve } from '../../emulation/path.js';
 import { Errno, ErrnoError } from '../../error.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
-import { Inode, randomIno, rootIno } from '../../inode.js';
-import { decodeDirListing, encodeUTF8, encodeDirListing } from '../../utils.js';
+import { Inode, rootIno } from '../../inode.js';
+import { decodeDirListing, encodeDirListing, encodeUTF8, randomBigInt } from '../../utils.js';
+import { serialize } from 'utilium';
 const maxInodeAllocTries = 5;
 /**
  * A file system which uses a key-value store.
@@ -106,40 +107,40 @@ export class StoreFS extends FileSystem {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_1, this.store.transaction(), true);
-            const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
+            const _old = parse(oldPath), _new = parse(newPath), 
             // Remove oldPath from parent's directory listing.
-            oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
-            if (!oldDirList[oldName]) {
+            oldDirNode = await this.findInode(tx, _old.dir, 'rename'), oldDirList = decodeDirListing(await this.get(tx, oldDirNode.data, _old.dir, 'rename'));
+            if (!oldDirList[_old.base]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
-            const nodeId = oldDirList[oldName];
-            delete oldDirList[oldName];
+            const ino = oldDirList[_old.base];
+            delete oldDirList[_old.base];
             /*
                 Can't move a folder inside itself.
-                This ensures that the check passes only if `oldPath` is a subpath of `newParent`.
+                This ensures that the check passes only if `oldPath` is a subpath of `_new.dir`.
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
-            if ((newParent + '/').indexOf(oldPath + '/') === 0) {
-                throw new ErrnoError(Errno.EBUSY, oldParent);
+            if ((_new.dir + '/').indexOf(oldPath + '/') === 0) {
+                throw new ErrnoError(Errno.EBUSY, _old.dir);
             }
             // Add newPath to parent's directory listing.
-            const sameParent = newParent === oldParent;
-            // Prevent us from re-grabbing the same directory listing, which still contains `oldName.`
-            const newDirNode = sameParent ? oldDirNode : await this.findINode(tx, newParent);
-            const newDirList = sameParent ? oldDirList : await this.getDirListing(tx, newDirNode, newParent);
-            if (newDirList[newName]) {
+            const sameParent = _new.dir == _old.dir;
+            // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
+            const newDirNode = sameParent ? oldDirNode : await this.findInode(tx, _new.dir, 'rename');
+            const newDirList = sameParent ? oldDirList : decodeDirListing(await this.get(tx, newDirNode.data, _new.dir, 'rename'));
+            if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
-                if (!newNameNode.toStats().isFile()) {
+                const existing = new Inode(await this.get(tx, newDirList[_new.base], newPath, 'rename'));
+                if (!existing.toStats().isFile()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
-                await tx.remove(newNameNode.ino);
-                await tx.remove(newDirList[newName]);
+                await tx.remove(existing.data);
+                await tx.remove(newDirList[_new.base]);
             }
-            newDirList[newName] = nodeId;
+            newDirList[_new.base] = ino;
             // Commit the two changed directory listings.
-            await tx.set(oldDirNode.ino, encodeDirListing(oldDirList));
-            await tx.set(newDirNode.ino, encodeDirListing(newDirList));
+            await tx.set(oldDirNode.data, encodeDirListing(oldDirList));
+            await tx.set(newDirNode.data, encodeDirListing(newDirList));
             await tx.commit();
         }
         catch (e_1) {
@@ -156,40 +157,40 @@ export class StoreFS extends FileSystem {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_2, this.store.transaction(), false);
-            const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
+            const _old = parse(oldPath), _new = parse(newPath), 
             // Remove oldPath from parent's directory listing.
-            oldDirNode = this.findINodeSync(tx, oldParent), oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
-            if (!oldDirList[oldName]) {
+            oldDirNode = this.findInodeSync(tx, _old.dir, 'rename'), oldDirList = decodeDirListing(this.getSync(tx, oldDirNode.data, _old.dir, 'rename'));
+            if (!oldDirList[_old.base]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
-            const ino = oldDirList[oldName];
-            delete oldDirList[oldName];
+            const ino = oldDirList[_old.base];
+            delete oldDirList[_old.base];
             /*
                 Can't move a folder inside itself.
-                This ensures that the check passes only if `oldPath` is a subpath of `newParent`.
+                This ensures that the check passes only if `oldPath` is a subpath of `_new.dir`.
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
-            if ((newParent + '/').indexOf(oldPath + '/') == 0) {
-                throw new ErrnoError(Errno.EBUSY, oldParent);
+            if ((_new.dir + '/').indexOf(oldPath + '/') == 0) {
+                throw new ErrnoError(Errno.EBUSY, _old.dir);
             }
             // Add newPath to parent's directory listing.
-            const sameParent = newParent === oldParent;
-            // Prevent us from re-grabbing the same directory listing, which still contains `oldName.`
-            const newDirNode = sameParent ? oldDirNode : this.findINodeSync(tx, newParent);
-            const newDirList = sameParent ? oldDirList : this.getDirListingSync(tx, newDirNode, newParent);
-            if (newDirList[newName]) {
+            const sameParent = _new.dir === _old.dir;
+            // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
+            const newDirNode = sameParent ? oldDirNode : this.findInodeSync(tx, _new.dir, 'rename');
+            const newDirList = sameParent ? oldDirList : decodeDirListing(this.getSync(tx, newDirNode.data, _new.dir, 'rename'));
+            if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
-                if (!newNameNode.toStats().isFile()) {
+                const existing = new Inode(this.getSync(tx, newDirList[_new.base], newPath, 'rename'));
+                if (!existing.toStats().isFile()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
-                tx.removeSync(newNameNode.ino);
-                tx.removeSync(newDirList[newName]);
+                tx.removeSync(existing.data);
+                tx.removeSync(newDirList[_new.base]);
             }
-            newDirList[newName] = ino;
+            newDirList[_new.base] = ino;
             // Commit the two changed directory listings.
-            tx.setSync(oldDirNode.ino, encodeDirListing(oldDirList));
-            tx.setSync(newDirNode.ino, encodeDirListing(newDirList));
+            tx.setSync(oldDirNode.data, encodeDirListing(oldDirList));
+            tx.setSync(newDirNode.data, encodeDirListing(newDirList));
             tx.commitSync();
         }
         catch (e_2) {
@@ -204,7 +205,7 @@ export class StoreFS extends FileSystem {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_3, this.store.transaction(), true);
-            return (await this.findINode(tx, path)).toStats();
+            return (await this.findInode(tx, path, 'stat')).toStats();
         }
         catch (e_3) {
             env_3.error = e_3;
@@ -220,7 +221,7 @@ export class StoreFS extends FileSystem {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_4, this.store.transaction(), false);
-            return this.findINodeSync(tx, path).toStats();
+            return this.findInodeSync(tx, path, 'stat').toStats();
         }
         catch (e_4) {
             env_4.error = e_4;
@@ -231,21 +232,19 @@ export class StoreFS extends FileSystem {
         }
     }
     async createFile(path, flag, mode) {
-        const node = await this.commitNew(path, S_IFREG, mode, new Uint8Array(0));
-        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array(0));
+        const node = await this.commitNew(path, S_IFREG, mode, new Uint8Array(), 'createFile');
+        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
     }
     createFileSync(path, flag, mode) {
-        this.commitNewSync(path, S_IFREG, mode);
-        return this.openFileSync(path, flag);
+        const node = this.commitNewSync(path, S_IFREG, mode, new Uint8Array(), 'createFile');
+        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
     }
     async openFile(path, flag) {
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_5, this.store.transaction(), true);
-            const node = await this.findINode(tx, path), data = await tx.get(node.ino);
-            if (!data) {
-                throw ErrnoError.With('ENOENT', path, 'openFile');
-            }
+            const node = await this.findInode(tx, path, 'openFile');
+            const data = await this.get(tx, node.data, path, 'openFile');
             return new PreloadFile(this, path, flag, node.toStats(), data);
         }
         catch (e_5) {
@@ -262,10 +261,8 @@ export class StoreFS extends FileSystem {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_6, this.store.transaction(), false);
-            const node = this.findINodeSync(tx, path), data = tx.getSync(node.ino);
-            if (!data) {
-                throw ErrnoError.With('ENOENT', path, 'openFile');
-            }
+            const node = this.findInodeSync(tx, path, 'openFile');
+            const data = this.getSync(tx, node.data, path, 'openFile');
             return new PreloadFile(this, path, flag, node.toStats(), data);
         }
         catch (e_6) {
@@ -277,35 +274,35 @@ export class StoreFS extends FileSystem {
         }
     }
     async unlink(path) {
-        return this.remove(path, false);
+        return this.remove(path, false, 'unlink');
     }
     unlinkSync(path) {
-        this.removeSync(path, false);
+        this.removeSync(path, false, 'unlink');
     }
     async rmdir(path) {
         if ((await this.readdir(path)).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        await this.remove(path, true);
+        await this.remove(path, true, 'rmdir');
     }
     rmdirSync(path) {
         if (this.readdirSync(path).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        this.removeSync(path, true);
+        this.removeSync(path, true, 'rmdir');
     }
     async mkdir(path, mode) {
-        await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'));
+        await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
     }
     mkdirSync(path, mode) {
-        this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'));
+        this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
     }
     async readdir(path) {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_7, this.store.transaction(), true);
-            const node = await this.findINode(tx, path);
-            return Object.keys(await this.getDirListing(tx, node, path));
+            const node = await this.findInode(tx, path, 'readdir');
+            return Object.keys(decodeDirListing(await this.get(tx, node.data, path, 'readdir')));
         }
         catch (e_7) {
             env_7.error = e_7;
@@ -321,8 +318,8 @@ export class StoreFS extends FileSystem {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_8, this.store.transaction(), false);
-            const node = this.findINodeSync(tx, path);
-            return Object.keys(this.getDirListingSync(tx, node, path));
+            const node = this.findInodeSync(tx, path, 'readdir');
+            return Object.keys(decodeDirListing(this.getSync(tx, node.data, path, 'readdir')));
         }
         catch (e_8) {
             env_8.error = e_8;
@@ -341,12 +338,12 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_9, this.store.transaction(), true);
             // We use _findInode because we actually need the INode id.
-            const fileInodeId = await this._findINode(tx, dirname(path), basename(path)), fileInode = await this.getINode(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+            const fileInodeId = await this._findInode(tx, path, 'sync'), fileInode = new Inode(await this.get(tx, fileInodeId, path, 'sync')), inodeChanged = fileInode.update(stats);
             // Sync data.
-            await tx.set(fileInode.ino, data);
+            await tx.set(fileInode.data, data);
             // Sync metadata.
             if (inodeChanged) {
-                await tx.set(fileInodeId, fileInode.data);
+                await tx.set(fileInodeId, serialize(fileInode));
             }
             await tx.commit();
         }
@@ -369,12 +366,12 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_10, this.store.transaction(), false);
             // We use _findInode because we actually need the INode id.
-            const fileInodeId = this._findINodeSync(tx, dirname(path), basename(path)), fileInode = this.getINodeSync(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+            const fileInodeId = this._findInodeSync(tx, path, 'sync'), fileInode = new Inode(this.getSync(tx, fileInodeId, path, 'sync')), inodeChanged = fileInode.update(stats);
             // Sync data.
-            tx.setSync(fileInode.ino, data);
+            tx.setSync(fileInode.data, data);
             // Sync metadata.
             if (inodeChanged) {
-                tx.setSync(fileInodeId, fileInode.data);
+                tx.setSync(fileInodeId, serialize(fileInode));
             }
             tx.commitSync();
         }
@@ -390,13 +387,13 @@ export class StoreFS extends FileSystem {
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_11, this.store.transaction(), true);
-            const newDir = dirname(link), newDirNode = await this.findINode(tx, newDir), listing = await this.getDirListing(tx, newDirNode, newDir);
-            const ino = await this._findINode(tx, dirname(target), basename(target));
-            const node = await this.getINode(tx, ino, target);
+            const newDir = dirname(link), newDirNode = await this.findInode(tx, newDir, 'link'), listing = decodeDirListing(await this.get(tx, newDirNode.data, newDir, 'link'));
+            const ino = await this._findInode(tx, target, 'link');
+            const node = new Inode(await this.get(tx, ino, target, 'link'));
             node.nlink++;
             listing[basename(link)] = ino;
-            tx.setSync(ino, node.data);
-            tx.setSync(newDirNode.ino, encodeDirListing(listing));
+            tx.setSync(ino, serialize(node));
+            tx.setSync(newDirNode.data, encodeDirListing(listing));
             tx.commitSync();
         }
         catch (e_11) {
@@ -413,13 +410,13 @@ export class StoreFS extends FileSystem {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_12, this.store.transaction(), false);
-            const newDir = dirname(link), newDirNode = this.findINodeSync(tx, newDir), listing = this.getDirListingSync(tx, newDirNode, newDir);
-            const ino = this._findINodeSync(tx, dirname(target), basename(target));
-            const node = this.getINodeSync(tx, ino, target);
+            const newDir = dirname(link), newDirNode = this.findInodeSync(tx, newDir, 'link'), listing = decodeDirListing(this.getSync(tx, newDirNode.data, newDir, 'link'));
+            const ino = this._findInodeSync(tx, target, 'link');
+            const node = new Inode(this.getSync(tx, ino, target, 'link'));
             node.nlink++;
             listing[basename(link)] = ino;
-            tx.setSync(ino, node.data);
-            tx.setSync(newDirNode.ino, encodeDirListing(listing));
+            tx.setSync(ino, serialize(node));
+            tx.setSync(newDirNode.data, encodeDirListing(listing));
             tx.commitSync();
         }
         catch (e_12) {
@@ -442,10 +439,11 @@ export class StoreFS extends FileSystem {
             }
             // Create new inode. o777, owned by root:root
             const inode = new Inode();
+            inode.ino = rootIno;
             inode.mode = 0o777 | S_IFDIR;
             // If the root doesn't exist, the first random ID shouldn't exist either.
-            await tx.set(inode.ino, encodeUTF8('{}'));
-            await tx.set(rootIno, inode.data);
+            await tx.set(inode.data, encodeUTF8('{}'));
+            await tx.set(rootIno, serialize(inode));
             await tx.commit();
         }
         catch (e_13) {
@@ -470,10 +468,11 @@ export class StoreFS extends FileSystem {
             }
             // Create new inode, mode o777, owned by root:root
             const inode = new Inode();
+            inode.ino = rootIno;
             inode.mode = 0o777 | S_IFDIR;
             // If the root doesn't exist, the first random ID shouldn't exist either.
-            tx.setSync(inode.ino, encodeUTF8('{}'));
-            tx.setSync(rootIno, inode.data);
+            tx.setSync(inode.data, encodeUTF8('{}'));
+            tx.setSync(rootIno, serialize(inode));
             tx.commitSync();
         }
         catch (e_14) {
@@ -490,19 +489,19 @@ export class StoreFS extends FileSystem {
      * @param filename The filename of the inode we are attempting to find, minus
      *   the parent.
      */
-    async _findINode(tx, parent, filename, visited = new Set()) {
-        const currentPath = join(parent, filename);
-        if (visited.has(currentPath)) {
-            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+    async _findInode(tx, path, syscall, visited = new Set()) {
+        if (visited.has(path)) {
+            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
         }
-        visited.add(currentPath);
-        if (parent == '/' && filename === '') {
+        visited.add(path);
+        if (path == '/') {
             return rootIno;
         }
-        const inode = parent == '/' ? await this.getINode(tx, rootIno, parent) : await this.findINode(tx, parent, visited);
-        const dirList = await this.getDirListing(tx, inode, parent);
+        const { dir: parent, base: filename } = parse(path);
+        const inode = parent == '/' ? new Inode(await this.get(tx, rootIno, parent, syscall)) : await this.findInode(tx, parent, syscall, visited);
+        const dirList = decodeDirListing(await this.get(tx, inode.data, parent, syscall));
         if (!(filename in dirList)) {
-            throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
+            throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);
         }
         return dirList[filename];
     }
@@ -513,19 +512,19 @@ export class StoreFS extends FileSystem {
      *   the parent.
      * @return string The ID of the file's inode in the file system.
      */
-    _findINodeSync(tx, parent, filename, visited = new Set()) {
-        const currentPath = join(parent, filename);
-        if (visited.has(currentPath)) {
-            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+    _findInodeSync(tx, path, syscall, visited = new Set()) {
+        if (visited.has(path)) {
+            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
         }
-        visited.add(currentPath);
-        if (parent == '/' && filename === '') {
+        visited.add(path);
+        if (path == '/') {
             return rootIno;
         }
-        const inode = parent == '/' ? this.getINodeSync(tx, rootIno, parent) : this.findINodeSync(tx, parent, visited);
-        const dir = this.getDirListingSync(tx, inode, parent);
+        const { dir: parent, base: filename } = parse(path);
+        const inode = parent == '/' ? new Inode(this.getSync(tx, rootIno, parent, syscall)) : this.findInodeSync(tx, parent, syscall, visited);
+        const dir = decodeDirListing(this.getSync(tx, inode.data, parent, syscall));
         if (!(filename in dir)) {
-            throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
+            throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);
         }
         return dir[filename];
     }
@@ -534,9 +533,9 @@ export class StoreFS extends FileSystem {
      * @param path The path to look up.
      * @todo memoize/cache
      */
-    async findINode(tx, path, visited = new Set()) {
-        const id = await this._findINode(tx, dirname(path), basename(path), visited);
-        return this.getINode(tx, id, path);
+    async findInode(tx, path, syscall, visited = new Set()) {
+        const ino = await this._findInode(tx, path, syscall, visited);
+        return new Inode(await this.get(tx, ino, path, syscall));
     }
     /**
      * Finds the Inode of `path`.
@@ -544,92 +543,64 @@ export class StoreFS extends FileSystem {
      * @return The Inode of the path p.
      * @todo memoize/cache
      */
-    findINodeSync(tx, path, visited = new Set()) {
-        const ino = this._findINodeSync(tx, dirname(path), basename(path), visited);
-        return this.getINodeSync(tx, ino, path);
+    findInodeSync(tx, path, syscall, visited = new Set()) {
+        const ino = this._findInodeSync(tx, path, syscall, visited);
+        return new Inode(this.getSync(tx, ino, path, syscall));
     }
     /**
-     * Given the ID of a node, retrieves the corresponding Inode.
+     * Given an ID, retrieves the corresponding data.
      * @param tx The transaction to use.
      * @param path The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    async getINode(tx, id, path) {
+    async get(tx, id, path, syscall) {
         const data = await tx.get(id);
         if (!data) {
-            throw ErrnoError.With('ENOENT', path, 'getINode');
+            throw ErrnoError.With('ENOENT', path, syscall);
         }
-        return new Inode(data.buffer);
+        return data;
     }
     /**
-     * Given the ID of a node, retrieves the corresponding Inode.
+     * Given an ID, retrieves the corresponding data.
      * @param tx The transaction to use.
      * @param path The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    getINodeSync(tx, id, path) {
+    getSync(tx, id, path, syscall) {
         const data = tx.getSync(id);
         if (!data) {
-            throw ErrnoError.With('ENOENT', path, 'getINode');
-        }
-        const inode = new Inode(data.buffer);
-        return inode;
-    }
-    /**
-     * Given the Inode of a directory, retrieves the corresponding directory
-     * listing.
-     */
-    async getDirListing(tx, inode, path) {
-        const data = await tx.get(inode.ino);
-        /*
-            Occurs when data is undefined,or corresponds to something other than a directory listing.
-            The latter should never occur unless the file system is corrupted.
-         */
-        if (!data) {
-            throw ErrnoError.With('ENOENT', path, 'getDirListing');
-        }
-        return decodeDirListing(data);
-    }
-    /**
-     * Given the Inode of a directory, retrieves the corresponding directory listing.
-     */
-    getDirListingSync(tx, inode, p) {
-        const data = tx.getSync(inode.ino);
-        if (!data) {
-            throw ErrnoError.With('ENOENT', p, 'getDirListing');
+            throw ErrnoError.With('ENOENT', path, syscall);
         }
-        return decodeDirListing(data);
+        return data;
     }
     /**
      * Adds a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random ino.
+     * the exceedingly unlikely chance that we try to reuse a random id.
      */
-    async addNew(tx, data, path) {
+    async allocNew(tx, path, syscall) {
         for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomIno();
+            const ino = randomBigInt();
             if (await tx.get(ino)) {
                 continue;
             }
-            await tx.set(ino, data);
             return ino;
         }
-        throw new ErrnoError(Errno.ENOSPC, 'No inode IDs available', path, 'addNewNode');
+        throw new ErrnoError(Errno.ENOSPC, 'No IDs available', path, syscall);
     }
     /**
      * Creates a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random ino.
+     * the exceedingly unlikely chance that we try to reuse a random id.
      * @return The ino that the data was stored under.
      */
-    addNewSync(tx, data, path) {
+    allocNewSync(tx, path, syscall) {
         for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomIno();
+            const ino = randomBigInt();
             if (tx.getSync(ino)) {
                 continue;
             }
-            tx.setSync(ino, data);
             return ino;
         }
-        throw new ErrnoError(Errno.ENOSPC, 'No inode IDs available', path, 'addNewNode');
+        throw new ErrnoError(Errno.ENOSPC, 'No IDs available', path, syscall);
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
@@ -639,7 +610,7 @@ export class StoreFS extends FileSystem {
      * @param mode The mode to create the new file with.
      * @param data The data to store at the file's data node.
      */
-    async commitNew(path, type, mode, data) {
+    async commitNew(path, type, mode, data, syscall) {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
             /*
@@ -648,26 +619,29 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root if path is '/'.
             */
             if (path == '/') {
-                throw ErrnoError.With('EEXIST', path, 'commitNew');
+                throw ErrnoError.With('EEXIST', path, syscall);
             }
             const tx = __addDisposableResource(env_15, this.store.transaction(), true);
-            const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
-            const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
+            const { dir: parentPath, base: fname } = parse(path);
+            const parent = await this.findInode(tx, parentPath, syscall);
+            const listing = decodeDirListing(await this.get(tx, parent.data, parentPath, syscall));
             // Check if file already exists.
             if (listing[fname]) {
-                await tx.abort();
-                throw ErrnoError.With('EEXIST', path, 'commitNew');
+                throw ErrnoError.With('EEXIST', path, syscall);
             }
             // Commit data.
             const inode = new Inode();
-            inode.ino = await this.addNew(tx, data, path);
+            inode.ino = await this.allocNew(tx, path, syscall);
+            inode.data = await this.allocNew(tx, path, syscall);
             inode.mode = mode | type;
-            inode.uid = credentials.uid;
-            inode.gid = credentials.gid;
+            inode.uid = parent.mode & S_ISUID ? parent.uid : credentials.uid;
+            inode.gid = parent.mode & S_ISGID ? parent.gid : credentials.gid;
             inode.size = data.length;
+            await tx.set(inode.ino, serialize(inode));
+            await tx.set(inode.data, data);
             // Update and commit parent directory listing.
-            listing[fname] = await this.addNew(tx, inode.data, path);
-            await tx.set(parent.ino, encodeDirListing(listing));
+            listing[fname] = inode.ino;
+            await tx.set(parent.data, encodeDirListing(listing));
             await tx.commit();
             return inode;
         }
@@ -690,7 +664,7 @@ export class StoreFS extends FileSystem {
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    commitNewSync(path, type, mode, data = new Uint8Array()) {
+    commitNewSync(path, type, mode, data, syscall) {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
             /*
@@ -699,27 +673,31 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root if path is '/'.
             */
             if (path == '/') {
-                throw ErrnoError.With('EEXIST', path, 'commitNew');
+                throw ErrnoError.With('EEXIST', path, syscall);
             }
             const tx = __addDisposableResource(env_16, this.store.transaction(), false);
-            const parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
-            const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
+            const { dir: parentPath, base: fname } = parse(path);
+            const parent = this.findInodeSync(tx, parentPath, syscall);
+            const listing = decodeDirListing(this.getSync(tx, parent.data, parentPath, syscall));
             // Check if file already exists.
             if (listing[fname]) {
-                throw ErrnoError.With('EEXIST', path, 'commitNew');
+                throw ErrnoError.With('EEXIST', path, syscall);
             }
             // Commit data.
-            const node = new Inode();
-            node.ino = this.addNewSync(tx, data, path);
-            node.size = data.length;
-            node.mode = mode | type;
-            node.uid = credentials.uid;
-            node.gid = credentials.gid;
+            const inode = new Inode();
+            inode.ino = this.allocNewSync(tx, path, syscall);
+            inode.data = this.allocNewSync(tx, path, syscall);
+            inode.size = data.length;
+            inode.mode = mode | type;
+            inode.uid = parent.mode & S_ISUID ? parent.uid : credentials.uid;
+            inode.gid = parent.mode & S_ISGID ? parent.gid : credentials.gid;
             // Update and commit parent directory listing.
-            listing[fname] = this.addNewSync(tx, node.data, path);
-            tx.setSync(parent.ino, encodeDirListing(listing));
+            tx.setSync(inode.ino, serialize(inode));
+            tx.setSync(inode.data, data);
+            listing[fname] = inode.ino;
+            tx.setSync(parent.data, encodeDirListing(listing));
             tx.commitSync();
-            return node;
+            return inode;
         }
         catch (e_16) {
             env_16.error = e_16;
@@ -735,26 +713,26 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    async remove(path, isDir) {
+    async remove(path, isDir, syscall) {
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_17, this.store.transaction(), true);
-            const parent = dirname(path), parentNode = await this.findINode(tx, parent), listing = await this.getDirListing(tx, parentNode, parent), fileName = basename(path);
+            const { dir: parent, base: fileName } = parse(path), parentNode = await this.findInode(tx, parent, syscall), listing = decodeDirListing(await this.get(tx, parentNode.data, parent, syscall));
             if (!listing[fileName]) {
                 throw ErrnoError.With('ENOENT', path, 'remove');
             }
             const fileIno = listing[fileName];
             // Get file inode.
-            const fileNode = await this.getINode(tx, fileIno, path);
+            const fileNode = new Inode(await this.get(tx, fileIno, path, syscall));
             // Remove from directory listing of parent.
             delete listing[fileName];
             if (!isDir && fileNode.toStats().isDirectory()) {
                 throw ErrnoError.With('EISDIR', path, 'remove');
             }
-            await tx.set(parentNode.ino, encodeDirListing(listing));
+            await tx.set(parentNode.data, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
                 // remove file
-                await tx.remove(fileNode.ino);
+                await tx.remove(fileNode.data);
                 await tx.remove(fileIno);
             }
             // Success.
@@ -776,26 +754,26 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    removeSync(path, isDir) {
+    removeSync(path, isDir, syscall) {
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_18, this.store.transaction(), false);
-            const parent = dirname(path), parentNode = this.findINodeSync(tx, parent), listing = this.getDirListingSync(tx, parentNode, parent), fileName = basename(path), fileIno = listing[fileName];
+            const { dir: parent, base: fileName } = parse(path), parentNode = this.findInodeSync(tx, parent, syscall), listing = decodeDirListing(this.getSync(tx, parentNode.data, parent, syscall)), fileIno = listing[fileName];
             if (!fileIno) {
                 throw ErrnoError.With('ENOENT', path, 'remove');
             }
             // Get file inode.
-            const fileNode = this.getINodeSync(tx, fileIno, path);
+            const fileNode = new Inode(this.getSync(tx, fileIno, path, syscall));
             // Remove from directory listing of parent.
             delete listing[fileName];
             if (!isDir && fileNode.toStats().isDirectory()) {
                 throw ErrnoError.With('EISDIR', path, 'remove');
             }
             // Update directory listing.
-            tx.setSync(parentNode.ino, encodeDirListing(listing));
+            tx.setSync(parentNode.data, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
                 // remove file
-                tx.removeSync(fileNode.ino);
+                tx.removeSync(fileNode.data);
                 tx.removeSync(fileIno);
             }
             // Success.