Rewrite microsoft#205 to harden the implementation

Author: andy0130tw

wasm-wasi-core/src/common/buffer.ts

@@ -14,6 +14,28 @@ export function read(content: Uint8Array, offset: number, buffers: Uint8Array[])
 	return totalBytesRead;
 }
 
+// copied from TS's es2024.arraybuffer.d.ts
+interface MaybeResizableArrayBuffer extends ArrayBuffer {
+	get maxByteLength(): number;
+	get resizable(): boolean;
+	resize: (newByteLength?: number) => void;
+}
+
+interface ResizableArrayBufferConstructor extends ArrayBufferConstructor {
+	new (byteLength: number, options?: { maxByteLength?: number; }): MaybeResizableArrayBuffer;
+}
+
+declare const ArrayBuffer: ResizableArrayBufferConstructor;
+
+let isArrayBufferResizingSupported: boolean | undefined = undefined;
+function canResizeArrayBuffers() {
+  if (isArrayBufferResizingSupported !== undefined) {
+  	return isArrayBufferResizingSupported;
+  }
+  const ab = new ArrayBuffer(1, { maxByteLength: 4 });
+  return (isArrayBufferResizingSupported = !!ab.resizable);
+}
+
 export function write(content: Uint8Array, offset: number, buffers: Uint8Array[]): [Uint8Array, size] {
 	let bytesToWrite: size = 0;
 	for (const bytes of buffers) {
@@ -24,22 +46,27 @@ export function write(content: Uint8Array, offset: number, buffers: Uint8Array[]
 
 	// Do we need to increase the buffer
 	if (newSize > content.byteLength) {
-		interface ResizeableArrayBuffer extends ArrayBuffer {
-			resize: (newByteLength: number) => void;
-			maxByteLength: number;
-		}
-		//Utilize ECMAScript 2024 In-Place Resizable ArrayBuffers
-
-		const buffer = content.buffer as ResizeableArrayBuffer;
-		const oldSize = buffer.maxByteLength;
-
-		if(newSize < oldSize){
-			buffer.resize(newSize);
-		} else {
-			const newBuffer = new (ArrayBuffer as any)(newSize, { maxByteLength: Math.max(newSize, oldSize << 1) });
-			const newContent = new Uint8Array(newBuffer);
+		if (!canResizeArrayBuffers()) {
+			// resizing is unsupported; fallback to always copying over
+			const newContent = new Uint8Array(offset + bytesToWrite);
 			newContent.set(content);
 			content = newContent;
+		} else {
+			// Utilize ECMAScript 2024 In-Place Resizable ArrayBuffers
+			const buffer = content.buffer as MaybeResizableArrayBuffer;
+
+			const oldSize = buffer.maxByteLength;
+
+			if (newSize < oldSize) {
+				// content.byteLength < newSize < oldSize = content.buffer.maxByteLength;
+				// hence the buffer must be resizable
+				buffer.resize(newSize);
+			} else if (newSize > oldSize) {
+				const newBuffer = new ArrayBuffer(newSize, { maxByteLength: Math.max(newSize, oldSize << 1) });
+				const newContent = new Uint8Array(newBuffer);
+				newContent.set(content);
+				content = newContent;
+			}
 		}
 	}
 

wasm-wasi-core/src/common/test/wasi.worker.test.ts

@@ -761,23 +761,38 @@ suite(`Filesystem - ${memoryQualifier}`, () => {
 	test('fd_write - multiple ciovec', () => {
 		const memory = createMemory();
 		const filename = `/tmp/${uuid.v4()}`;
-		const hw = ['Hello ', 'World ', '!!!'];
+		const hw1 = ['Hello ', 'World ', '!!!'];
+		const hw2 = ['Hello ', 'World ', ', again', '!!!'];
 		const fd = FileSystem.createFile(memory, rootFd, filename);
-		const ciovecs = memory.allocStructArray(3, Ciovec);
-		let contentLength: number = 0;
-		for (let i = 0; i < hw.length; i++) {
-			const content = memory.allocBytes(encoder.encode(hw[i]));
-			ciovecs.get(i).buf = content.$ptr;
-			ciovecs.get(i).buf_len = content.byteLength;
-			contentLength += content.byteLength;
+		const ciovecs1 = memory.allocStructArray(3, Ciovec);
+		let contentLength1: number = 0;
+		for (let i = 0; i < hw1.length; i++) {
+			const content = memory.allocBytes(encoder.encode(hw1[i]));
+			ciovecs1.get(i).buf = content.$ptr;
+			ciovecs1.get(i).buf_len = content.byteLength;
+			contentLength1 += content.byteLength;
 		}
+		const ciovecs2 = memory.allocStructArray(4, Ciovec);
+		let contentLength2: number = 0;
+		for (let i = 0; i < hw2.length; i++) {
+			const content = memory.allocBytes(encoder.encode(hw2[i]));
+			ciovecs2.get(i).buf = content.$ptr;
+			ciovecs2.get(i).buf_len = content.byteLength;
+			contentLength2 += content.byteLength;
+		}
+
 		const bytesWritten = memory.allocUint32();
-		let errno = wasi.fd_write(fd, ciovecs.$ptr, ciovecs.size, bytesWritten.$ptr);
+		let errno1 = wasi.fd_write(fd, ciovecs1.$ptr, ciovecs1.size, bytesWritten.$ptr);
+		assert.strictEqual(errno1, Errno.success);
+		assert.strictEqual(bytesWritten.value, contentLength1);
+
+		let errno2 = wasi.fd_write(fd, ciovecs2.$ptr, ciovecs2.size, bytesWritten.$ptr);
+		assert.strictEqual(errno2, Errno.success);
+		assert.strictEqual(bytesWritten.value, contentLength2);
 		FileSystem.close(fd);
+
 		const check = FileSystem.openFile(memory, rootFd, filename);
-		assert.strictEqual(errno, Errno.success);
-		assert.strictEqual(bytesWritten.value, contentLength);
-		assert.strictEqual(decoder.decode(FileSystem.read(memory, check)), hw.join(''));
+		assert.strictEqual(decoder.decode(FileSystem.read(memory, check)), hw1.join('') + hw2.join(''));
 		FileSystem.close(check);
 	});