@zenfs/core 1.2.9 → 1.3.0

package/src/backends/store/fs.ts

@@ -1,14 +1,15 @@
 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 type { File } from '../../file.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
-import { type Ino, Inode, randomIno, rootIno } from '../../inode.js';
+import { Inode, rootIno } from '../../inode.js';
 import type { FileType, Stats } from '../../stats.js';
-import { decodeDirListing, encodeUTF8, encodeDirListing } from '../../utils.js';
+import { decodeDirListing, encodeDirListing, encodeUTF8, randomBigInt } from '../../utils.js';
 import type { Store, Transaction } from './store.js';
-import type { File } from '../../file.js';
+import { serialize } from 'utilium';
 
 const maxInodeAllocTries = 5;
 
@@ -67,182 +68,174 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 */
 	public async rename(oldPath: string, newPath: string): Promise<void> {
 		await using tx = this.store.transaction();
-		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);
+			oldDirNode = await this.findInode(tx, _old.dir, 'rename'),
+			oldDirList = decodeDirListing(await this.get(tx, oldDirNode.data, _old.dir, 'rename'));
 
-		if (!oldDirList[oldName]) {
+		if (!oldDirList[_old.base]) {
 			throw ErrnoError.With('ENOENT', oldPath, 'rename');
 		}
-		const nodeId: Ino = oldDirList[oldName];
-		delete oldDirList[oldName];
+		const ino: bigint = 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;
+		const sameParent = _new.dir == _old.dir;
 
-		// Prevent us from re-grabbing the same directory listing, which still contains `oldName.`
-		const newDirNode: Inode = sameParent ? oldDirNode : await this.findINode(tx, newParent);
-		const newDirList: typeof oldDirList = sameParent ? oldDirList : await this.getDirListing(tx, newDirNode, newParent);
+		// Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
+		const newDirNode: Inode = sameParent ? oldDirNode : await this.findInode(tx, _new.dir, 'rename');
+		const newDirList: typeof oldDirList = sameParent ? oldDirList : decodeDirListing(await this.get(tx, newDirNode.data, _new.dir, 'rename'));
 
-		if (newDirList[newName]) {
+		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();
 	}
 
 	public renameSync(oldPath: string, newPath: string): void {
 		using tx = this.store.transaction();
-		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);
+			oldDirNode = this.findInodeSync(tx, _old.dir, 'rename'),
+			oldDirList = decodeDirListing(this.getSync(tx, oldDirNode.data, _old.dir, 'rename'));
 
-		if (!oldDirList[oldName]) {
+		if (!oldDirList[_old.base]) {
 			throw ErrnoError.With('ENOENT', oldPath, 'rename');
 		}
-		const ino: Ino = oldDirList[oldName];
-		delete oldDirList[oldName];
+		const ino: bigint = 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;
+		const sameParent = _new.dir === _old.dir;
 
-		// Prevent us from re-grabbing the same directory listing, which still contains `oldName.`
-		const newDirNode: Inode = sameParent ? oldDirNode : this.findINodeSync(tx, newParent);
-		const newDirList: typeof oldDirList = sameParent ? oldDirList : this.getDirListingSync(tx, newDirNode, newParent);
+		// Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
+		const newDirNode: Inode = sameParent ? oldDirNode : this.findInodeSync(tx, _new.dir, 'rename');
+		const newDirList: typeof oldDirList = sameParent ? oldDirList : decodeDirListing(this.getSync(tx, newDirNode.data, _new.dir, 'rename'));
 
-		if (newDirList[newName]) {
+		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();
 	}
 
 	public async stat(path: string): Promise<Stats> {
 		await using tx = this.store.transaction();
-		return (await this.findINode(tx, path)).toStats();
+		return (await this.findInode(tx, path, 'stat')).toStats();
 	}
 
 	public statSync(path: string): Stats {
 		using tx = this.store.transaction();
-		return this.findINodeSync(tx, path).toStats();
+		return this.findInodeSync(tx, path, 'stat').toStats();
 	}
 
 	public async createFile(path: string, flag: string, mode: number): Promise<File> {
-		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());
 	}
 
 	public createFileSync(path: string, flag: string, mode: number): File {
-		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());
 	}
 
 	public async openFile(path: string, flag: string): Promise<File> {
 		await using tx = this.store.transaction();
-		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);
 	}
 
 	public openFileSync(path: string, flag: string): File {
 		using tx = this.store.transaction();
-		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);
 	}
 
 	public async unlink(path: string): Promise<void> {
-		return this.remove(path, false);
+		return this.remove(path, false, 'unlink');
 	}
 
 	public unlinkSync(path: string): void {
-		this.removeSync(path, false);
+		this.removeSync(path, false, 'unlink');
 	}
 
 	public async rmdir(path: string): Promise<void> {
 		if ((await this.readdir(path)).length) {
 			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 		}
-		await this.remove(path, true);
+		await this.remove(path, true, 'rmdir');
 	}
 
 	public rmdirSync(path: string): void {
 		if (this.readdirSync(path).length) {
 			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 		}
-		this.removeSync(path, true);
+		this.removeSync(path, true, 'rmdir');
 	}
 
 	public async mkdir(path: string, mode: number): Promise<void> {
-		await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'));
+		await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
 	}
 
 	public mkdirSync(path: string, mode: number): void {
-		this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'));
+		this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
 	}
 
 	public async readdir(path: string): Promise<string[]> {
 		await using tx = this.store.transaction();
-		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')));
 	}
 
 	public readdirSync(path: string): string[] {
 		using tx = this.store.transaction();
-		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')));
 	}
 
 	/**
@@ -252,15 +245,15 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
 		await using tx = this.store.transaction();
 		// 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),
+		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();
@@ -273,15 +266,15 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
 		using tx = this.store.transaction();
 		// 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),
+		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();
@@ -291,17 +284,17 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		await using tx = this.store.transaction();
 
 		const newDir: string = dirname(link),
-			newDirNode = await this.findINode(tx, newDir),
-			listing = await this.getDirListing(tx, newDirNode, newDir);
+			newDirNode = await this.findInode(tx, newDir, 'link'),
+			listing = decodeDirListing(await this.get(tx, newDirNode.data, newDir, 'link'));
 
-		const ino = await this._findINode(tx, dirname(target), basename(target));
-		const node = await this.getINode(tx, ino, target);
+		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();
 	}
 
@@ -309,17 +302,17 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		using tx = this.store.transaction();
 
 		const newDir: string = dirname(link),
-			newDirNode = this.findINodeSync(tx, newDir),
-			listing = this.getDirListingSync(tx, newDirNode, newDir);
+			newDirNode = this.findInodeSync(tx, newDir, 'link'),
+			listing = decodeDirListing(this.getSync(tx, newDirNode.data, newDir, 'link'));
 
-		const ino = this._findINodeSync(tx, dirname(target), basename(target));
-		const node = this.getINodeSync(tx, ino, target);
+		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();
 	}
 
@@ -333,10 +326,11 @@ export class StoreFS<T extends Store = Store> 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();
 	}
 
@@ -350,10 +344,11 @@ export class StoreFS<T extends Store = Store> 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();
 	}
 
@@ -363,23 +358,23 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param filename The filename of the inode we are attempting to find, minus
 	 *   the parent.
 	 */
-	private async _findINode(tx: Transaction, parent: string, filename: string, visited: Set<string> = new Set()): Promise<Ino> {
-		const currentPath = join(parent, filename);
-		if (visited.has(currentPath)) {
-			throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+	private async _findInode(tx: Transaction, path: string, syscall: string, visited: Set<string> = new Set()): Promise<bigint> {
+		if (visited.has(path)) {
+			throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
 		}
 
-		visited.add(currentPath);
+		visited.add(path);
 
-		if (parent == '/' && filename === '') {
+		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];
@@ -392,23 +387,23 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 *   the parent.
 	 * @return string The ID of the file's inode in the file system.
 	 */
-	protected _findINodeSync(tx: Transaction, parent: string, filename: string, visited: Set<string> = new Set()): Ino {
-		const currentPath = join(parent, filename);
-		if (visited.has(currentPath)) {
-			throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+	protected _findInodeSync(tx: Transaction, path: string, syscall: string, visited: Set<string> = new Set()): bigint {
+		if (visited.has(path)) {
+			throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
 		}
 
-		visited.add(currentPath);
+		visited.add(path);
 
-		if (parent == '/' && filename === '') {
+		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];
@@ -419,9 +414,9 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param path The path to look up.
 	 * @todo memoize/cache
 	 */
-	private async findINode(tx: Transaction, path: string, visited: Set<string> = new Set()): Promise<Inode> {
-		const id = await this._findINode(tx, dirname(path), basename(path), visited);
-		return this.getINode(tx, id, path);
+	private async findInode(tx: Transaction, path: string, syscall: string, visited: Set<string> = new Set()): Promise<Inode> {
+		const ino = await this._findInode(tx, path, syscall, visited);
+		return new Inode(await this.get(tx, ino, path, syscall));
 	}
 
 	/**
@@ -430,99 +425,68 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @return The Inode of the path p.
 	 * @todo memoize/cache
 	 */
-	protected findINodeSync(tx: Transaction, path: string, visited: Set<string> = new Set()): Inode {
-		const ino = this._findINodeSync(tx, dirname(path), basename(path), visited);
-		return this.getINodeSync(tx, ino, path);
+	protected findInodeSync(tx: Transaction, path: string, syscall: string, visited: Set<string> = new Set()): Inode {
+		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.
 	 */
-	private async getINode(tx: Transaction, id: Ino, path: string): Promise<Inode> {
+	private async get(tx: Transaction, id: bigint, path: string, syscall: string): Promise<Uint8Array> {
 		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.
 	 */
-	protected getINodeSync(tx: Transaction, id: Ino, path: string): Inode {
+	private getSync(tx: Transaction, id: bigint, path: string, syscall: string): Uint8Array {
 		const data = tx.getSync(id);
 		if (!data) {
-			throw ErrnoError.With('ENOENT', path, 'getINode');
+			throw ErrnoError.With('ENOENT', path, syscall);
 		}
-		const inode = new Inode(data.buffer);
-		return inode;
-	}
-
-	/**
-	 * Given the Inode of a directory, retrieves the corresponding directory
-	 * listing.
-	 */
-	private async getDirListing(tx: Transaction, inode: Inode, path: string): Promise<{ [fileName: string]: Ino }> {
-		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.
-	 */
-	protected getDirListingSync(tx: Transaction, inode: Inode, p?: string): { [fileName: string]: Ino } {
-		const data = tx.getSync(inode.ino);
-		if (!data) {
-			throw ErrnoError.With('ENOENT', p, 'getDirListing');
-		}
-		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.
 	 */
-	private async addNew(tx: Transaction, data: Uint8Array, path: string): Promise<Ino> {
+	private async allocNew(tx: Transaction, path: string, syscall: string): Promise<bigint> {
 		for (let i = 0; i < maxInodeAllocTries; i++) {
-			const ino: Ino = randomIno();
+			const ino: bigint = 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.
 	 */
-	protected addNewSync(tx: Transaction, data: Uint8Array, path: string): Ino {
+	private allocNewSync(tx: Transaction, path: string, syscall: string): bigint {
 		for (let i = 0; i < maxInodeAllocTries; i++) {
-			const ino: Ino = randomIno();
+			const ino: bigint = 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);
 	}
 
 	/**
@@ -533,40 +497,41 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param mode The mode to create the new file with.
 	 * @param data The data to store at the file's data node.
 	 */
-	private async commitNew(path: string, type: FileType, mode: number, data: Uint8Array): Promise<Inode> {
+	private async commitNew(path: string, type: FileType, mode: number, data: Uint8Array, syscall: string): Promise<Inode> {
 		/*
 			The root always exists.
 			If we don't check this prior to taking steps below,
 			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);
 		}
 
 		await using tx = this.store.transaction();
-		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;
 	}
@@ -580,40 +545,43 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param data The data to store at the file's data node.
 	 * @return The Inode for the new file.
 	 */
-	protected commitNewSync(path: string, type: FileType, mode: number, data: Uint8Array = new Uint8Array()): Inode {
+	private commitNewSync(path: string, type: FileType, mode: number, data: Uint8Array, syscall: string): Inode {
 		/*
 			The root always exists.
 			If we don't check this prior to taking steps below,
 			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);
 		}
 
 		using tx = this.store.transaction();
-		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;
 	}
 
 	/**
@@ -622,12 +590,12 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param isDir Does the path belong to a directory, or a file?
 	 * @todo Update mtime.
 	 */
-	private async remove(path: string, isDir: boolean): Promise<void> {
+	private async remove(path: string, isDir: boolean, syscall: string): Promise<void> {
 		await using tx = this.store.transaction();
-		const parent: string = dirname(path),
-			parentNode = await this.findINode(tx, parent),
-			listing = await this.getDirListing(tx, parentNode, parent),
-			fileName: string = 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');
@@ -636,7 +604,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		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];
@@ -645,11 +613,11 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			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);
 		}
 
@@ -663,20 +631,19 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param isDir Does the path belong to a directory, or a file?
 	 * @todo Update mtime.
 	 */
-	protected removeSync(path: string, isDir: boolean): void {
+	private removeSync(path: string, isDir: boolean, syscall: string): void {
 		using tx = this.store.transaction();
-		const parent: string = dirname(path),
-			parentNode = this.findINodeSync(tx, parent),
-			listing = this.getDirListingSync(tx, parentNode, parent),
-			fileName: string = basename(path),
-			fileIno: Ino = 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: bigint = 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];
@@ -686,11 +653,11 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		}
 
 		// 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);
 		}