@zenfs/core 2.7.7 → 2.8.0

package/tests/backend/single-buffer.test.ts

@@ -5,7 +5,7 @@ import { suite, test } from 'node:test';
 import { Worker } from 'worker_threads';
 import { sizeof } from 'memium';
 import { fs, mount, resolveMountConfig, SingleBuffer, vfs } from '@zenfs/core';
-import { MetadataBlock, SuperBlock } from '@zenfs/core/backends/single_buffer';
+import { MetadataBlock, SuperBlock } from '@zenfs/core/backends/single_buffer/v1';
 import { setupLogs } from '../logs.js';
 
 setupLogs();
@@ -14,13 +14,13 @@ await suite('SingleBuffer', () => {
 	test('filesystem restoration from original buffer (with same metadata)', async () => {
 		const buffer = new ArrayBuffer(0x100000);
 
-		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer });
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, v2: false });
 		mount('/mnt', writable);
 
 		fs.writeFileSync('/mnt/example.ts', 'console.log("hello world")', 'utf-8');
 		const stats = fs.statSync('/mnt/example.ts');
 
-		const snapshot = await resolveMountConfig({ backend: SingleBuffer, buffer });
+		const snapshot = await resolveMountConfig({ backend: SingleBuffer, buffer, v2: false });
 		mount('/snapshot', snapshot);
 
 		const snapshotStats = fs.statSync('/snapshot/example.ts');
@@ -31,7 +31,7 @@ await suite('SingleBuffer', () => {
 	test('cross-thread SharedArrayBuffer', async () => {
 		const sharedBuffer = new SharedArrayBuffer(0x100000);
 
-		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer: sharedBuffer });
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer: sharedBuffer, v2: false });
 		fs.mkdirSync('/shared');
 		mount('/shared', writable);
 
@@ -141,7 +141,7 @@ await suite('SingleBuffer', () => {
 		const mountPoint = '/sbfs-reliability';
 		const verifyMountPoint = '/sbfs-verify';
 		const buffer = new ArrayBuffer(0x400000);
-		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'reliability' });
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'reliability', v2: false });
 		mount(mountPoint, writable);
 
 		const filePath = `${mountPoint}/payload.bin`;
@@ -186,7 +186,7 @@ await suite('SingleBuffer', () => {
 	test('keeps metadata aligned when files have uneven sizes #309', async () => {
 		const mountPoint = '/sbfs-rotation';
 		const buffer = new ArrayBuffer(0x400000);
-		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'rotation' });
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'rotation', v2: false });
 		mount(mountPoint, writable);
 
 		// Uneven writes leave used_bytes between alignment boundaries when the metadata block fills up.

package/tests/backend/single-buffer.worker.js

@@ -16,6 +16,7 @@ try {
 	await configureSingle({
 		backend: SingleBuffer,
 		buffer: workerData,
+		v2: false,
 	});
 
 	fs.writeFileSync('/worker-file.ts', content, 'utf-8');

package/tests/common/async.test.ts

@@ -32,4 +32,15 @@ suite('Async()', () => {
 		assert.deepEqual(calls, ['mkdirSync', 'rmdirSync', 'createFileSync', 'unlinkSync']);
 		assert.deepEqual(await fs.readdir('/'), []);
 	});
+
+	test('async operations see queued sync operations', async () => {
+		const fs = new AsyncMemory(new InMemoryStore());
+		fs.checkRootSync();
+		await fs.ready();
+
+		fs.mkdirSync('/dir', { mode: 0o755, uid: 0, gid: 0 });
+		assert.equal((await fs.stat('/dir')).mode & 0o777, 0o755);
+		fs.rmdirSync('/dir');
+		assert.equal(await fs.exists('/dir'), false);
+	});
 });

package/tests/common/context.test.ts

@@ -134,4 +134,34 @@ suite('Context', () => {
 
 		assert.doesNotThrow(() => ctx.bind({ credentials: { uid: 500, gid: 500 } }));
 	});
+
+	test('umask is inherited by children', () => {
+		const parent = bindContext({ umask: 0o027 });
+		assert.equal(parent.bind({}).umask, 0o027);
+		assert.equal(parent.bind({ umask: 0o077 }).umask, 0o077);
+	});
+
+	test('umask applies to created files and directories', async () => {
+		fs.mkdirSync('/masked');
+		const masked = bindContext({ root: '/masked', umask: 0o027 });
+
+		masked.fs.writeFileSync('/sync.txt', '', { mode: 0o666 });
+		assert.equal(masked.fs.statSync('/sync.txt').mode & 0o7777, 0o640);
+
+		await masked.fs.promises.writeFile('/async.txt', '', { mode: 0o666 });
+		assert.equal(masked.fs.statSync('/async.txt').mode & 0o7777, 0o640);
+
+		masked.fs.mkdirSync('/a/b', { recursive: true, mode: 0o777 });
+		assert.equal(masked.fs.statSync('/a').mode & 0o7777, 0o750);
+		assert.equal(masked.fs.statSync('/a/b').mode & 0o7777, 0o750);
+
+		await masked.fs.promises.mkdir('/c', 0o1777);
+		assert.equal(masked.fs.statSync('/c').mode & 0o7777, 0o1750);
+
+		masked.fs.symlinkSync('/sync.txt', '/link');
+		assert.equal(masked.fs.lstatSync('/link').mode & 0o7777, 0o777);
+
+		masked.fs.chmodSync('/sync.txt', 0o666);
+		assert.equal(masked.fs.statSync('/sync.txt').mode & 0o7777, 0o666);
+	});
 });

package/tests/fs/permissions.test.ts

@@ -133,11 +133,11 @@ suite('Permissions', config('permissions'), () => {
 		await rootFS.promises.writeFile('/removal-root/file', 'x', { mode: 0o666 });
 		await rootFS.promises.mkdir('/removal-root/dir', { mode: 0o777 });
 		await rootFS.promises.mkdir('/removal-own', { mode: 0o755 });
-		await rootFS.promises.lchown('/removal-own', 1000, 1000);
+		await rootFS.promises.chown('/removal-own', 1000, 1000);
 		await rootFS.promises.writeFile('/removal-own/readonly', 'x', { mode: 0o444 });
 		await rootFS.promises.mkdir('/removal-own/readonly-dir', { mode: 0o555 });
 		await rootFS.promises.mkdir('/removal-unreadable', { mode: 0o300 });
-		await rootFS.promises.lchown('/removal-unreadable', 1000, 1000);
+		await rootFS.promises.chown('/removal-unreadable', 1000, 1000);
 		await rootFS.promises.writeFile('/removal-unreadable/file', 'x');
 
 		await assert.rejects(alice.fs.promises.unlink('/removal-root/file'), { code: 'EACCES' });
@@ -177,7 +177,7 @@ suite('Permissions', config('permissions'), () => {
 		assert.deepEqual(rootFS.readdirSync('/sticky'), []);
 
 		await rootFS.promises.mkdir('/sticky-alice', { mode: 0o1777 });
-		await rootFS.promises.lchown('/sticky-alice', 1000, 1000);
+		await rootFS.promises.chown('/sticky-alice', 1000, 1000);
 		await bob.fs.promises.writeFile('/sticky-alice/bob', 'b');
 		await alice.fs.promises.unlink('/sticky-alice/bob');
 	});
@@ -211,6 +211,27 @@ suite('Permissions', config('permissions'), () => {
 		assert.equal(stats.uid, 2000);
 	});
 
+	test('changing metadata needs no read or write access, even on directories #327', async () => {
+		const alice = bindContext({ credentials: { uid: 1000, gid: 1000 } });
+
+		await rootFS.promises.writeFile('/metadata-file', 'x', { mode: 0o000 });
+		await rootFS.promises.mkdir('/metadata-dir', { mode: 0o000 });
+
+		for (const path of ['/metadata-file', '/metadata-dir']) {
+			rootFS.chownSync(path, 1000, 1000);
+			alice.fs.chmodSync(path, 0o500);
+			await alice.fs.promises.chmod(path, 0o400);
+			alice.fs.utimesSync(path, 1, 2);
+			await alice.fs.promises.utimes(path, 3, 4);
+			alice.fs.chownSync(path, -1, -1);
+			await alice.fs.promises.chown(path, -1, -1);
+
+			const stats = rootFS.statSync(path);
+			assert.equal(stats.mode & 0o777, 0o400);
+			assert.equal(stats.mtimeMs, 4000);
+		}
+	});
+
 	test('moving a directory to another parent needs write permission on it', async () => {
 		const alice = bindContext({ credentials: { uid: 1000, gid: 1000 } });
 
@@ -249,8 +270,8 @@ suite('Permissions', config('permissions'), () => {
 		alice.fs.chmodSync('/sid/file', 0o2755);
 		assert.equal(modeOf('/sid/file'), 0o755);
 
-		await alice.fs.promises.lchmod('/sid/dir', 0o6755);
-		await alice.fs.promises.lchown('/sid/dir', -1, -1);
+		await alice.fs.promises.chmod('/sid/dir', 0o6755);
+		await alice.fs.promises.chown('/sid/dir', -1, -1);
 		assert.equal(modeOf('/sid/dir'), 0o6755);
 	});
 
@@ -271,7 +292,7 @@ suite('Permissions', config('permissions'), () => {
 		const bob = bindContext({ credentials: { uid: 2000, gid: 2000 } });
 
 		await rootFS.promises.mkdir('/private', { mode: 0o700 });
-		await rootFS.promises.lchown('/private', 1000, 1000);
+		await rootFS.promises.chown('/private', 1000, 1000);
 		await rootFS.promises.mkdir('/private/inner', { mode: 0o755 });
 		await rootFS.promises.writeFile('/private/inner/readable.txt', 'secret', { mode: 0o644 });
 		await rootFS.promises.symlink('/private', '/private-link');

package/tests/fs/watch.test.ts

@@ -41,6 +41,20 @@ suite('Watch', config('watch'), () => {
 		assert.equal(filename, 'test.txt');
 	});
 
+	test('Events emitted on metadata change', async () => {
+		const { promise, resolve } = Promise.withResolvers<[string, string]>();
+
+		using watcher = fs.watch(testFile, (eventType, filename) => {
+			resolve([eventType, filename]);
+		});
+
+		fs.chmodSync(testFile, 0o600);
+
+		const [eventType, filename] = await withTimeout(promise);
+		assert.equal(eventType, 'change');
+		assert.equal(filename, 'test.txt');
+	});
+
 	test('Events are emitted on delete', async () => {
 		const { promise, resolve } = Promise.withResolvers<string>();
 

package/tests/perf/config.json

@@ -1,6 +1,7 @@
 {
 	"flags": {
-		"prep": ["writeFile", "stream"]
+		"prep": ["writeFile", "stream"],
+		"sbfs_v2": [true, false]
 	},
 	"tests": [
 		{
@@ -79,6 +80,35 @@
 				{ "name": "2000 appends", "value": { "writes": 2000 } },
 				{ "name": "8000 appends", "cpu": 1, "value": { "writes": 8000 } }
 			]
+		},
+		{
+			"path": "single-buffer-read.ts",
+			"name": "Random 4 KB reads from one file in a SingleBuffer",
+			"flags": ["sbfs_v2"],
+			"measure": {
+				"bytes": { "throughput": "s", "unit": "MB" },
+				"reads": { "cost": true, "unit": "read" }
+			},
+			"configurations": [
+				{ "name": "1 MiB", "value": { "size": 1048576, "count": 256 } },
+				{ "name": "8 MiB", "value": { "size": 8388608, "count": 1024 } },
+				{ "name": "32 MiB", "cpu": 1, "value": { "size": 33554432, "count": 1024 } }
+			]
+		},
+		{
+			"path": "single-buffer-write.ts",
+			"name": "Random 4 KB writes to one file in a SingleBuffer",
+			"flags": ["sbfs_v2"],
+			"measure": {
+				"bytes": { "throughput": "s", "unit": "MB" },
+				"writes": { "cost": true, "unit": "write" }
+			},
+			"configurations": [
+				{ "name": "1 MiB, flushed", "value": { "size": 1048576, "count": 256, "flush": 1, "sync": 0 } },
+				{ "name": "1 MiB, O_SYNC", "value": { "size": 1048576, "count": 256, "flush": 0, "sync": 1 } },
+				{ "name": "8 MiB, flushed", "cpu": 1, "value": { "size": 8388608, "count": 1024, "flush": 1, "sync": 0 } },
+				{ "name": "8 MiB, O_SYNC", "cpu": 1, "value": { "size": 8388608, "count": 1024, "flush": 0, "sync": 1 } }
+			]
 		}
 	]
 }

package/tests/perf/single-buffer-random.ts

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Helpers for random access to one file in a SingleBuffer.
+import { configureSingle, SingleBuffer } from '@zenfs/core';
+import { fs, KB, MB } from './common.ts';
+
+export { fs };
+
+export const block = 4 * KB;
+
+export interface Config {
+	/** Size of the file */
+	size: number;
+
+	/** Number of blocks accessed, each once */
+	count: number;
+
+	sbfs_v2: boolean;
+}
+
+/** Mounts a SingleBuffer with room for the file twice over, then creates the file */
+export async function mountWithFile(config: Config): Promise<void> {
+	await configureSingle({ backend: SingleBuffer, buffer: new ArrayBuffer(config.size * 2 + 4 * MB), v2: config.sbfs_v2 });
+	fs.writeFileSync('/f', new Uint8Array(config.size).fill(0x5a));
+}
+
+/** Offsets of `count` distinct blocks of the file, in a shuffled order that is the same on every run */
+export function offsets(config: Config): number[] {
+	const blocks = Array.from({ length: config.size / block }, (_, i) => i);
+
+	let seed = 0x2545f491;
+	for (let i = blocks.length - 1; i > 0; i--) {
+		seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+		const j = seed % (i + 1);
+		[blocks[i], blocks[j]] = [blocks[j], blocks[i]];
+	}
+
+	return blocks.slice(0, config.count).map(i => i * block);
+}

package/tests/perf/single-buffer-read.ts

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// 4 KB reads at random offsets in one file in a SingleBuffer.
+// The file is opened fresh for each iteration, so every read misses the vnode cache and reaches the store.
+import { block, fs, mountWithFile, offsets, type Config } from './single-buffer-random.ts';
+
+interface State {
+	offsets: number[];
+	target: Uint8Array;
+	fd?: number;
+}
+
+export async function setup(config: Config): Promise<State> {
+	await mountWithFile(config);
+	return { offsets: offsets(config), target: new Uint8Array(block) };
+}
+
+export function before(config: Config, state: State): void {
+	state.fd = fs.openSync('/f', 'r');
+}
+
+export function test(config: Config, state: State) {
+	for (const offset of state.offsets) fs.readSync(state.fd!, state.target, 0, block, offset);
+	return { reads: state.offsets.length, bytes: state.offsets.length * block };
+}
+
+export function after(config: Config, state: State): void {
+	fs.closeSync(state.fd!);
+}

package/tests/perf/single-buffer-write.ts

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// 4 KB writes at random offsets in one file in a SingleBuffer.
+// By default, only the writes are timed, and they stay in the vnode cache until the untimed close.
+// With `flush`, the close is timed too, which writes the cached data to the store.
+// With `osync`, the file is opened with O_SYNC, so every write reaches the store.
+import { block, fs, mountWithFile, offsets, type Config as BaseConfig } from './single-buffer-random.ts';
+
+interface Config extends BaseConfig {
+	flush: number;
+	sync: number;
+}
+
+interface State {
+	offsets: number[];
+	data: Uint8Array;
+	fd?: number;
+}
+
+export async function setup(config: Config): Promise<State> {
+	await mountWithFile(config);
+	return { offsets: offsets(config), data: new Uint8Array(block).fill(0xa5) };
+}
+
+export function before(config: Config, state: State): void {
+	state.fd = fs.openSync('/f', config.sync ? 'rs+' : 'r+');
+}
+
+export function test(config: Config, state: State) {
+	for (const offset of state.offsets) fs.writeSync(state.fd!, state.data, 0, block, offset);
+
+	if (config.flush) {
+		fs.closeSync(state.fd!);
+		state.fd = undefined;
+	}
+
+	return { writes: state.offsets.length, bytes: state.offsets.length * block };
+}
+
+export function after(config: Config, state: State): void {
+	if (state.fd !== undefined) fs.closeSync(state.fd);
+}

package/tests/setup/single-buffer-v2.ts

@@ -0,0 +1,10 @@
+import { SingleBuffer, configureSingle } from '@zenfs/core';
+import { copySync, data } from '../setup.ts';
+
+await configureSingle({
+	backend: SingleBuffer,
+	buffer: new ArrayBuffer(0x1100000),
+	v2: true,
+});
+
+copySync(data);

package/tests/setup/single-buffer.ts

@@ -4,6 +4,7 @@ import { copySync, data } from '../setup.ts';
 await configureSingle({
 	backend: SingleBuffer,
 	buffer: new ArrayBuffer(0x1100000),
+	v2: false,
 });
 
 copySync(data);