fs: read small files in one thread pool round trip

fs.readFile(path) took four libuv thread pool round trips for a typical
small file -- open, fstat, read and close, each its own uv_fs request
with its own queue wait, completion callback and JS/C++ crossing -- and
fs.promises.readFile(path) did the same through a FileHandle. For the
small files applications read most, the round trips are the cost, and
each occupies a slot in the pool that concurrent dns.lookup(), fs and
crypto work is also queueing for.
Add ReadFileJob (an AsyncWrap + ThreadPoolWork) that performs
open + fstat + read-to-EOF + close as one pool task and reports the
whole content, or, when the file turns out to be larger than one chunk
(kReadFileBufferLength, 512 KiB), stops after fstat() and hands the fd
and size back so that the existing chunked reader continues unchanged
(large reads stay interleaved and abortable between chunks, and still
save the fstat round trip). fs.readFile() and fs.promises.readFile()
use it for path arguments without a user buffer; file descriptors,
FileHandles, options.buffer and an active VFS keep their paths.
Behavior is otherwise kept: same bytes for every size and encoding;
open failures report syscall 'open' with the path, read failures
'read'; permission errors are delivered through the callback/promise
as before; an abort that arrives while the read is in flight still
wins; the job is an FSREQCALLBACK resource for async_hooks; a handed
back fd is tracked exactly like one from a plain open().
Tests that asserted the internal open/fstat/read/close request chain,
used readFile() as a proxy for an fstat trace event, or injected
faults through FileHandle.prototype for path-based reads are adjusted
to keep testing what they test (a file just over one chunk where the
chain shape matters, fs.fstat() for the fstat trace, a larger file so
the FileHandle path is taken).
fs.readFile() of 4 KiB files at concurrency 64 goes from ~51k to ~306k
files per second, and a mixed stat/readFile/dns.lookup burst from ~66k
to ~312k operations per second.
Signed-off-by: Shelley Vohr <shelley.vohr@gmail.com>
PR-URL: #65327
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: codebytere

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const{
  FSReqCallback,
+ ReadFileJob,
 }=binding;
 const{ toPathIfFileURL }=require('internal/url');
 const{
@@ -98,6 +99,7 @@ const {
 const{
 constants: {
  kIoMaxLength,
+ kReadFileBufferLength,
  kMaxUserId,
 },
  copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
 return;
 
 constflagsNumber=stringToFlags(options.flag,'options.flag');
+path=getValidatedPath(path);
+if(options.buffer===undefined){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and take
+// the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+// fd will be closed through fs.close(), so track it as unmanaged.
+constjob=newReadFileJob(path,flagsNumber,kReadFileBufferLength,true);
+job.context=context;
+job.ondone=readFileAfterOneShot;
+constaccessError=job.run(path);
+if(accessError!==undefined){
+// Not scheduled: report it the way the request-based open() did.
+callback(accessError);
+}
+return;
+}
 constreq=newFSReqCallback();
 req.context=context;
 req.oncomplete=readFileAfterOpen;
-binding.open(getValidatedPath(path),flagsNumber,0o666,req);
+binding.open(path,flagsNumber,0o666,req);
+}
+
+functionreadFileAfterOneShot(err,buffer,fd,size,closeErr){
+constcontext=this.context;
+if(err){
+context.callback(err);
+return;
+}
+if(fd!==-1){
+// (context.read() below performs the abort check for this case.)
+// Larger than one chunk: continue exactly like after open + fstat.
+context.fd=fd;
+context.size=size;
+if(size>kIoMaxLength){
+returncontext.close(newERR_FS_FILE_TOO_LARGE(size));
+}
+try{
+context.prepare();
+}catch(err){
+returncontext.close(err);
+}
+context.read();
+return;
+}
+if(closeErr){
+context.callback(closeErr);
+return;
+}
+if(context.signal?.aborted){
+// An abort that arrived while the read was in flight wins, as it did when
+// it was noticed between the open/fstat/read steps.
+context.callback(newAbortError(undefined,{cause: context.signal.reason}));
+return;
+}
+letresult=buffer;
+if(context.encoding){
+try{
+result=buffer.toString(context.encoding);
+}catch(err){
+context.callback(err);
+return;
+}
+}
+context.callback(null,result);
 }
 
 functiontryStatSync(fd,isUserFd){

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
 returnencoding ? buffer.toString(encoding) : buffer.subarray(0,totalRead);
 }
 
-asyncfunctionreadFileHandle(filehandle,options){
+asyncfunctionreadFileHandle(filehandle,options,knownRegularFileSize){
 constsignal=options?.signal;
 constencoding=options?.encoding;
 constdecoder=encoding&&newStringDecoder(encoding);
 
 checkAborted(signal);
 
-conststatFields=awaitPromisePrototypeThen(
-binding.fstat(filehandle.fd,false,kUsePromises),
-undefined,
-handleErrorFromBinding,
-);
-
-checkAborted(signal);
-
 letsize=0;
 letlength=0;
-if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
-size=statFields[8/* size */];
+if(knownRegularFileSize!==undefined){
+// Handed over by readFile() together with an already open fd.
+size=knownRegularFileSize;
 length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}else{
+conststatFields=awaitPromisePrototypeThen(
+binding.fstat(filehandle.fd,false,kUsePromises),
+undefined,
+handleErrorFromBinding,
+);
+
+checkAborted(signal);
+
+if((statFields[1/* mode */]&S_IFMT)===S_IFREG){
+size=statFields[8/* size */];
+length=encoding ? MathMin(size,kReadFileBufferLength) : size;
+}
 }
 if(length===0){
 length=kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
 checkAborted(options.signal);
 
+if(options.buffer===undefined&&vfsState.handlers===null){
+// Open + fstat + read + close in one thread pool round trip for files of
+// up to one chunk; larger files come back as an open fd + size and are
+// read by readFileHandle() as before.
+path=getValidatedPath(path);
+const{0: buffer,1: fd,2: size}=awaitreadFileInOneRoundTrip(path,stringToFlags(flag));
+if(fd===-1){
+checkAborted(options.signal);// An abort during the read still wins.
+returnoptions.encoding ? buffer.toString(options.encoding) : buffer;
+}
+constfilehandle=newFileHandle(newbinding.FileHandle(fd));
+returnhandleFdClose(readFileHandle(filehandle,options,size),filehandle.close);
+}
+
 constfd=awaitopen(path,flag,0o666);
 returnhandleFdClose(readFileHandle(fd,options),fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+functionreadFileInOneRoundTrip(path,flagsNumber){
+returnnewPromise((resolve,reject)=>{
+constjob=newbinding.ReadFileJob(path,flagsNumber,kReadFileBufferLength);
+job.ondone=(err,buffer,fd,size,closeErr)=>{
+consterror=err??closeErr;
+if(error!=null){
+ErrorCaptureStackTrace(error,readFileInOneRoundTrip);
+reject(error);
+}else{
+resolve([buffer,fd,size]);
+}
+};
+constaccessError=job.run(path);
+if(accessError!==undefined){
+ErrorCaptureStackTrace(accessError,readFileInOneRoundTrip);
+reject(accessError);
+}
+});
+}
+
 asyncfunction*_watch(filename,options=kEmptyObject){
 consth=vfsState.handlers;
 if(h!==null){