fixup! vfs: read full zero-size real file handles

Author: trivikr

lib/internal/vfs/providers/real.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
   Promise,
   StringPrototypeStartsWith,
 } = primordials;
@@ -18,6 +19,8 @@ const {
   createENOENT,
 } = require('internal/vfs/errors');
 
+const kReadFileUnknownBufferLength = 8192;
+
 /**
  * A file handle that wraps a real file descriptor.
  */
@@ -35,10 +38,6 @@ class RealFileHandle extends VirtualFileHandle {
     }
   }
 
-  #readFileBuffer(size) {
-    return Buffer.allocUnsafe(size || 8192);
-  }
-
   #readFileResult(buffer, bytesRead, options) {
     buffer = buffer.subarray(0, bytesRead);
     const encoding = typeof options === 'string' ? options : options?.encoding;
@@ -48,6 +47,11 @@ class RealFileHandle extends VirtualFileHandle {
     return buffer;
   }
 
+  #readFileUnknownSizeResult(buffers, totalRead, options) {
+    return this.#readFileResult(
+      Buffer.concat(buffers, totalRead), totalRead, options);
+  }
+
   /**
    * @param {string} path The VFS path
    * @param {string} flags The open flags
@@ -94,7 +98,23 @@ class RealFileHandle extends VirtualFileHandle {
   readFileSync(options) {
     this.#checkClosed('read');
     const size = fs.fstatSync(this.#fd).size;
-    const buffer = this.#readFileBuffer(size);
+    if (size === 0) {
+      const buffers = [];
+      let totalRead = 0;
+
+      while (true) {
+        const buffer = Buffer.allocUnsafe(kReadFileUnknownBufferLength);
+        const read = fs.readSync(
+          this.#fd, buffer, 0, buffer.byteLength, totalRead);
+        if (read === 0) break;
+        ArrayPrototypePush(buffers, buffer.subarray(0, read));
+        totalRead += read;
+      }
+
+      return this.#readFileUnknownSizeResult(buffers, totalRead, options);
+    }
+
+    const buffer = Buffer.allocUnsafe(size);
     let bytesRead = 0;
     while (bytesRead < buffer.byteLength) {
       const read = fs.readSync(
@@ -114,7 +134,27 @@ class RealFileHandle extends VirtualFileHandle {
   async readFile(options) {
     this.#checkClosed('read');
     const size = (await this.stat()).size;
-    const buffer = this.#readFileBuffer(size);
+    if (size === 0) {
+      const buffers = [];
+      let totalRead = 0;
+
+      while (true) {
+        const buffer = Buffer.allocUnsafe(kReadFileUnknownBufferLength);
+        const { bytesRead: read } = await this.read(
+          buffer,
+          0,
+          buffer.byteLength,
+          totalRead,
+        );
+        if (read === 0) break;
+        ArrayPrototypePush(buffers, buffer.subarray(0, read));
+        totalRead += read;
+      }
+
+      return this.#readFileUnknownSizeResult(buffers, totalRead, options);
+    }
+
+    const buffer = Buffer.allocUnsafe(size);
     let bytesRead = 0;
     while (bytesRead < buffer.byteLength) {
       const { bytesRead: read } = await this.read(

test/parallel/test-vfs-real-provider-handle.js

@@ -92,6 +92,38 @@ const myVfs = vfs.create(new vfs.RealFSProvider(root));
     }
   }
 
+  // ===== readFile reads past the fallback chunk when fstat reports size 0 =====
+  {
+    const content = 'a'.repeat(8192) + 'trailing data';
+    fs.writeFileSync(path.join(root, 'zero-stat.txt'), content);
+    const syncHandle = await myVfs.provider.open('/zero-stat.txt', 'r');
+    const asyncHandle = await myVfs.provider.open('/zero-stat.txt', 'r');
+    const originalFstatSync = fs.fstatSync;
+    const originalFstat = fs.fstat;
+
+    fs.fstatSync = common.mustCall(function fstatSync(...args) {
+      const stats = originalFstatSync.apply(this, args);
+      stats.size = 0;
+      return stats;
+    });
+    fs.fstat = common.mustCall(function fstat(fd, options, callback) {
+      return originalFstat.call(this, fd, options, (err, stats) => {
+        if (stats) stats.size = 0;
+        callback(err, stats);
+      });
+    });
+
+    try {
+      assert.strictEqual(syncHandle.readFileSync('utf8'), content);
+      assert.strictEqual(await asyncHandle.readFile('utf8'), content);
+    } finally {
+      fs.fstatSync = originalFstatSync;
+      fs.fstat = originalFstat;
+      await syncHandle.close();
+      await asyncHandle.close();
+    }
+  }
+
   // ===== EBADF after close =====
   {
     await myVfs.promises.writeFile('/h.txt', 'hello');