vfs: read RealFSProvider files from open fd

Read RealFileHandle contents through the open file descriptor instead
of reopening the original real path. This keeps already-open VFS file
descriptors usable after the backing file is renamed.
Use positioned reads so readFileSync() and readFile() preserve the
handle's current offset.
Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: #64104Fixes: #64103
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: trivikr

lib/internal/vfs/providers/real.js

@@ -1,10 +1,12 @@
 'use strict';
 
 const{
+ ArrayPrototypePush,
  Promise,
  StringPrototypeStartsWith,
 }=primordials;
 
+const{ Buffer }=require('buffer');
 constfs=require('fs');
 constpath=require('path');
 const{ VirtualProvider }=require('internal/vfs/provider');
@@ -17,6 +19,8 @@ const {
  createENOENT,
 }=require('internal/vfs/errors');
 
+constkReadFileUnknownBufferLength=8192;
+
 /**
  * A file handle that wraps a real file descriptor.
  */
@@ -34,6 +38,20 @@ class RealFileHandle extends VirtualFileHandle {
 }
 }
 
+ #readFileResult(buffer,bytesRead,options){
+buffer=buffer.subarray(0,bytesRead);
+constencoding=typeofoptions==='string' ? options : options?.encoding;
+if(encoding&&encoding!=='buffer'){
+buffer=buffer.toString(encoding);
+}
+returnbuffer;
+}
+
+ #readFileUnknownSizeResult(buffers,totalRead,options){
+returnthis.#readFileResult(
+Buffer.concat(buffers,totalRead),totalRead,options);
+}
+
 /**
  * @param {string} path The VFS path
  * @param {string} flags The open flags
@@ -79,12 +97,77 @@ class RealFileHandle extends VirtualFileHandle {
 
 readFileSync(options){
 this.#checkClosed('read');
-returnfs.readFileSync(this.#realPath,options);
+constsize=fs.fstatSync(this.#fd).size;
+if(size===0){
+constbuffers=[];
+lettotalRead=0;
+
+while(true){
+constbuffer=Buffer.allocUnsafe(kReadFileUnknownBufferLength);
+constread=fs.readSync(
+this.#fd,buffer,0,buffer.byteLength,totalRead);
+if(read===0)break;
+ArrayPrototypePush(buffers,buffer.subarray(0,read));
+totalRead+=read;
+}
+
+returnthis.#readFileUnknownSizeResult(buffers,totalRead,options);
+}
+
+constbuffer=Buffer.allocUnsafe(size);
+letbytesRead=0;
+while(bytesRead<buffer.byteLength){
+constread=fs.readSync(
+this.#fd,
+buffer,
+bytesRead,
+buffer.byteLength-bytesRead,
+bytesRead,
+);
+if(read===0)break;
+bytesRead+=read;
+}
+
+returnthis.#readFileResult(buffer,bytesRead,options);
 }
 
 asyncreadFile(options){
 this.#checkClosed('read');
-returnfs.promises.readFile(this.#realPath,options);
+constsize=(awaitthis.stat()).size;
+if(size===0){
+constbuffers=[];
+lettotalRead=0;
+
+while(true){
+constbuffer=Buffer.allocUnsafe(kReadFileUnknownBufferLength);
+const{bytesRead: read}=awaitthis.read(
+buffer,
+0,
+buffer.byteLength,
+totalRead,
+);
+if(read===0)break;
+ArrayPrototypePush(buffers,buffer.subarray(0,read));
+totalRead+=read;
+}
+
+returnthis.#readFileUnknownSizeResult(buffers,totalRead,options);
+}
+
+constbuffer=Buffer.allocUnsafe(size);
+letbytesRead=0;
+while(bytesRead<buffer.byteLength){
+const{bytesRead: read}=awaitthis.read(
+buffer,
+bytesRead,
+buffer.byteLength-bytesRead,
+bytesRead,
+);
+if(read===0)break;
+bytesRead+=read;
+}
+
+returnthis.#readFileResult(buffer,bytesRead,options);
 }
 
 writeFileSync(data,options){

test/parallel/test-vfs-fs-readFileSync.js

@@ -43,3 +43,32 @@ assert.strictEqual(
 }
 
 myVfs.unmount();
+
+// readFileSync via a RealFSProvider fd remains usable after the backing path
+// is renamed.
+{
+constroot=path.join('/tmp','vfs-real-readFileSync-'+process.pid);
+constrealMountPoint=path.join('/tmp','vfs-real-readFileSync-mount-'+process.pid);
+fs.rmSync(root,{recursive: true,force: true});
+fs.rmSync(realMountPoint,{recursive: true,force: true});
+fs.mkdirSync(root,{recursive: true});
+fs.mkdirSync(realMountPoint,{recursive: true});
+
+constrealVfs=vfs
+.create(newvfs.RealFSProvider(root),{emitExperimentalWarning: false})
+.mount(realMountPoint);
+try{
+fs.writeFileSync(path.join(root,'a.txt'),'still readable');
+constfd=fs.openSync(path.join(realMountPoint,'a.txt'),'r');
+try{
+fs.renameSync(path.join(root,'a.txt'),path.join(root,'b.txt'));
+assert.strictEqual(fs.readFileSync(fd,'utf8'),'still readable');
+}finally{
+fs.closeSync(fd);
+}
+}finally{
+realVfs.unmount();
+fs.rmSync(root,{recursive: true,force: true});
+fs.rmSync(realMountPoint,{recursive: true,force: true});
+}
+}

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

@@ -75,6 +75,55 @@ const myVfs = vfs.create(new vfs.RealFSProvider(root));
 awaithandle.close();
 }
 
+// ===== readFile through an open real fd survives backing path rename =====
+{
+fs.writeFileSync(path.join(root,'rename-read.txt'),'still readable');
+constsyncHandle=awaitmyVfs.provider.open('/rename-read.txt','r');
+constasyncHandle=awaitmyVfs.provider.open('/rename-read.txt','r');
+fs.renameSync(path.join(root,'rename-read.txt'),
+path.join(root,'rename-read-renamed.txt'));
+try{
+assert.strictEqual(syncHandle.readFileSync('utf8'),'still readable');
+assert.strictEqual(awaitasyncHandle.readFile('utf8'),'still readable');
+}finally{
+awaitsyncHandle.close();
+awaitasyncHandle.close();
+fs.unlinkSync(path.join(root,'rename-read-renamed.txt'));
+}
+}
+
+// ===== readFile reads past the fallback chunk when fstat reports size 0 =====
+{
+constcontent='a'.repeat(8192)+'trailing data';
+fs.writeFileSync(path.join(root,'zero-stat.txt'),content);
+constsyncHandle=awaitmyVfs.provider.open('/zero-stat.txt','r');
+constasyncHandle=awaitmyVfs.provider.open('/zero-stat.txt','r');
+constoriginalFstatSync=fs.fstatSync;
+constoriginalFstat=fs.fstat;
+
+fs.fstatSync=common.mustCall(functionfstatSync(...args){
+conststats=originalFstatSync.apply(this,args);
+stats.size=0;
+returnstats;
+});
+fs.fstat=common.mustCall(functionfstat(fd,options,callback){
+returnoriginalFstat.call(this,fd,options,(err,stats)=>{
+if(stats)stats.size=0;
+callback(err,stats);
+});
+});
+
+try{
+assert.strictEqual(syncHandle.readFileSync('utf8'),content);
+assert.strictEqual(awaitasyncHandle.readFile('utf8'),content);
+}finally{
+fs.fstatSync=originalFstatSync;
+fs.fstat=originalFstat;
+awaitsyncHandle.close();
+awaitasyncHandle.close();
+}
+}
+
 // ===== EBADF after close =====
 {
 awaitmyVfs.promises.writeFile('/h.txt','hello');