diff --git a/doc/api/fs.md b/doc/api/fs.md
index 350555f2f8ad99..80d5548cc57d3a 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -696,11 +696,18 @@ close the `FileHandle` automatically. User code must still call the
 
 <!-- YAML
 added: v10.0.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63634
+    description: Added support for the `buffer` and `getBuffer` options.
 -->
 
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
   * `signal` {AbortSignal} allows aborting an in-progress readFile
+  * `buffer` {Buffer|TypedArray|DataView} A buffer to read into.
+  * `getBuffer` {Function} A synchronous function called with the file size and
+    returning the buffer to read into.
 * Returns: {Promise} Fulfills upon a successful read with the contents of the
   file. If no encoding is specified (using `options.encoding`), the data is
   returned as a {Buffer} object. Otherwise, the data will be a string.
@@ -709,6 +716,11 @@ Asynchronously reads the entire contents of a file.
 
 If `options` is a string, then it specifies the `encoding`.
 
+The `buffer` and `getBuffer` options cannot be used together. If one of them is
+provided and no encoding is specified, the returned {Buffer} is a view over the
+supplied buffer containing only the bytes read. If the supplied buffer is too
+small to contain the entire file, the operation will fail.
+
 The {FileHandle} has to support reading.
 
 If one or more `filehandle.read()` calls are made on a file handle and then a
@@ -1765,6 +1777,9 @@ try {
 <!-- YAML
 added: v10.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63634
+    description: Added support for the `buffer` and `getBuffer` options.
   - version:
     - v15.2.0
     - v14.17.0
@@ -1778,6 +1793,9 @@ changes:
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
   * `signal` {AbortSignal} allows aborting an in-progress readFile
+  * `buffer` {Buffer|TypedArray|DataView} A buffer to read into.
+  * `getBuffer` {Function} A synchronous function called with the file size and
+    returning the buffer to read into.
 * Returns: {Promise}  Fulfills with the contents of the file.
 
 Asynchronously reads the entire contents of a file.
@@ -1787,6 +1805,11 @@ as a {Buffer} object. Otherwise, the data will be a string.
 
 If `options` is a string, then it specifies the encoding.
 
+The `buffer` and `getBuffer` options cannot be used together. If one of them is
+provided and no encoding is specified, the returned {Buffer} is a view over the
+supplied buffer containing only the bytes read. If the supplied buffer is too
+small to contain the entire file, the promise will be rejected.
+
 When the `path` is a directory, the behavior of `fsPromises.readFile()` is
 platform-specific. On macOS, Linux, and Windows, the promise will be rejected
 with an error. On FreeBSD, a representation of the directory's contents will be
@@ -4225,6 +4248,9 @@ If `options.withFileTypes` is set to `true`, the `files` array will contain
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63634
+    description: Added support for the `buffer` and `getBuffer` options.
   - version: v18.0.0
     pr-url: https://github.com/nodejs/node/pull/41678
     description: Passing an invalid callback to the `callback` argument
@@ -4266,6 +4292,9 @@ changes:
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
   * `signal` {AbortSignal} allows aborting an in-progress readFile
+  * `buffer` {Buffer|TypedArray|DataView} A buffer to read into.
+  * `getBuffer` {Function} A synchronous function called with the file size and
+    returning the buffer to read into.
 * `callback` {Function}
   * `err` {Error|AggregateError}
   * `data` {string|Buffer}
@@ -4286,6 +4315,11 @@ contents of the file.
 
 If no encoding is specified, then the raw buffer is returned.
 
+The `buffer` and `getBuffer` options cannot be used together. If one of them is
+provided and no encoding is specified, the returned {Buffer} is a view over the
+supplied buffer containing only the bytes read. If the supplied buffer is too
+small to contain the entire file, the callback is called with an error.
+
 If `options` is a string, then it specifies the encoding:
 
 ```mjs
@@ -6428,6 +6462,9 @@ If `options.withFileTypes` is set to `true`, the result will contain
 <!-- YAML
 added: v0.1.8
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63634
+    description: Added support for the `buffer` and `getBuffer` options.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
@@ -6441,6 +6478,9 @@ changes:
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+  * `buffer` {Buffer|TypedArray|DataView} A buffer to read into.
+  * `getBuffer` {Function} A synchronous function called with the file size and
+    returning the buffer to read into.
 * Returns: {string|Buffer}
 
 Returns the contents of the `path`.
@@ -6451,6 +6491,11 @@ this API: [`fs.readFile()`][].
 If the `encoding` option is specified then this function returns a
 string. Otherwise it returns a buffer.
 
+The `buffer` and `getBuffer` options cannot be used together. If one of them is
+provided and no encoding is specified, the returned {Buffer} is a view over the
+supplied buffer containing only the bytes read. If the supplied buffer is too
+small to contain the entire file, an error will be thrown.
+
 Similar to [`fs.readFile()`][], when the path is a directory, the behavior of
 `fs.readFileSync()` is platform-specific.
 
diff --git a/lib/fs.js b/lib/fs.js
index d63fad8b2a258b..619d3b50a23eb9 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -111,6 +111,8 @@ const {
   handleErrorFromBinding,
   preprocessSymlinkDestination,
   Stats,
+  getReadFileBuffer,
+  getReadFileBufferByteLengthName,
   getStatFsFromBinding,
   getStatsFromBinding,
   realpathCacheKey,
@@ -123,6 +125,7 @@ const {
   validateOffsetLengthWrite,
   validatePath,
   validatePosition,
+  validateReadFileBufferOptions,
   validateRmOptions,
   validateRmOptionsSync,
   validateRmdirOptions,
@@ -319,13 +322,7 @@ function readFileAfterStat(err, stats) {
   }
 
   try {
-    if (size === 0) {
-      // TODO(BridgeAR): If an encoding is set, use the StringDecoder to concat
-      // the result and reuse the buffer instead of allocating a new one.
-      context.buffers = [];
-    } else {
-      context.buffer = Buffer.allocUnsafeSlow(size);
-    }
+    context.prepare();
   } catch (err) {
     return context.close(err);
   }
@@ -358,8 +355,9 @@ function readFile(path, options, callback) {
   callback ||= options;
   validateFunction(callback, 'cb');
   options = getOptions(options, { flag: 'r' });
+  validateReadFileBufferOptions(options);
   ReadFileContext ??= require('internal/fs/read/context');
-  const context = new ReadFileContext(callback, options.encoding);
+  const context = new ReadFileContext(callback, options);
   context.isUserFd = isFd(path); // File descriptor ownership
 
   if (options.signal) {
@@ -405,6 +403,18 @@ function tryCreateBuffer(size, fd, isUserFd) {
   return buffer;
 }
 
+function tryGetReadFileBuffer(options, size, fd, isUserFd) {
+  let threw = true;
+  let buffer;
+  try {
+    buffer = getReadFileBuffer(options, size);
+    threw = false;
+  } finally {
+    if (threw && !isUserFd) fs.closeSync(fd);
+  }
+  return buffer;
+}
+
 function tryReadSync(fd, isUserFd, buffer, pos, len) {
   let threw = true;
   let bytesRead;
@@ -417,6 +427,36 @@ function tryReadSync(fd, isUserFd, buffer, pos, len) {
   return bytesRead;
 }
 
+function tryReadSyncWithUserBuffer(fd, isUserFd, buffer, byteLengthName) {
+  let pos = 0;
+  let bytesRead = 0;
+
+  while (pos < buffer.byteLength) {
+    bytesRead = tryReadSync(fd, isUserFd, buffer, pos, buffer.byteLength - pos);
+    pos += bytesRead;
+
+    if (bytesRead === 0) {
+      return pos;
+    }
+  }
+
+  const extraBuffer = tryCreateBuffer(1, fd, isUserFd);
+  bytesRead = tryReadSync(fd, isUserFd, extraBuffer, 0, 1);
+
+  if (bytesRead !== 0) {
+    if (!isUserFd) {
+      fs.closeSync(fd);
+    }
+    throw new ERR_INVALID_ARG_VALUE(
+      byteLengthName,
+      buffer.byteLength,
+      'is too small to contain the entire file',
+    );
+  }
+
+  return pos;
+}
+
 /**
  * Synchronously reads the entire contents of a file.
  * @param {string | Buffer | URL | number} path
@@ -428,8 +468,12 @@ function tryReadSync(fd, isUserFd, buffer, pos, len) {
  */
 function readFileSync(path, options) {
   options = getOptions(options, { flag: 'r' });
+  validateReadFileBufferOptions(options);
+  const hasUserBuffer =
+    options.buffer !== undefined || options.getBuffer !== undefined;
 
-  if (options.encoding === 'utf8' || options.encoding === 'utf-8') {
+  if ((options.encoding === 'utf8' || options.encoding === 'utf-8') &&
+      !hasUserBuffer) {
     if (!isInt32(path)) {
       path = getValidatedPath(path);
     }
@@ -445,7 +489,9 @@ function readFileSync(path, options) {
   let buffer; // Single buffer with file data
   let buffers; // List for when size is unknown
 
-  if (size === 0) {
+  if (hasUserBuffer) {
+    buffer = tryGetReadFileBuffer(options, size, fd, isUserFd);
+  } else if (size === 0) {
     buffers = [];
   } else {
     buffer = tryCreateBuffer(size, fd, isUserFd);
@@ -453,7 +499,21 @@ function readFileSync(path, options) {
 
   let bytesRead;
 
-  if (size !== 0) {
+  if (hasUserBuffer) {
+    if (size !== 0) {
+      do {
+        bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);
+        pos += bytesRead;
+      } while (bytesRead !== 0 && pos < size);
+    } else {
+      pos = tryReadSyncWithUserBuffer(
+        fd,
+        isUserFd,
+        buffer,
+        getReadFileBufferByteLengthName(options),
+      );
+    }
+  } else if (size !== 0) {
     do {
       bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);
       pos += bytesRead;
@@ -474,7 +534,9 @@ function readFileSync(path, options) {
   if (!isUserFd)
     fs.closeSync(fd);
 
-  if (size === 0) {
+  if (hasUserBuffer) {
+    buffer = buffer.subarray(0, pos);
+  } else if (size === 0) {
     // Data was collected into the buffers list.
     buffer = Buffer.concat(buffers, pos);
   } else if (pos < size) {
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index e8694843987c2b..8842e0afab71fd 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -66,6 +66,8 @@ const {
   getStatFsFromBinding,
   getStatsFromBinding,
   getValidatedPath,
+  getReadFileBuffer,
+  getReadFileBufferByteLengthName,
   preprocessSymlinkDestination,
   stringToFlags,
   stringToSymlinkType,
@@ -76,6 +78,7 @@ const {
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePosition,
+  validateReadFileBufferOptions,
   validateRmOptions,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
@@ -1157,6 +1160,56 @@ async function writeFileHandle(filehandle, data, signal, encoding) {
   } while (remaining > 0);
 }
 
+async function readFileHandleWithUserBuffer(filehandle, options, size) {
+  const signal = options?.signal;
+  const encoding = options?.encoding;
+  const buffer = getReadFileBuffer(options, size);
+  const byteLengthName = getReadFileBufferByteLengthName(options);
+  let totalRead = 0;
+
+  while (totalRead < buffer.byteLength) {
+    checkAborted(signal);
+
+    const length = size === 0 ?
+      buffer.byteLength - totalRead :
+      MathMin(size - totalRead, kReadFileBufferLength);
+
+    const bytesRead = (await PromisePrototypeThen(
+      binding.read(filehandle.fd, buffer, totalRead, length, -1, kUsePromises),
+      undefined,
+      handleErrorFromBinding,
+    )) ?? 0;
+
+    totalRead += bytesRead;
+
+    if (bytesRead === 0 || totalRead === size) {
+      const result = buffer.subarray(0, totalRead);
+      return encoding ? result.toString(encoding) : result;
+    }
+  }
+
+  if (size === 0) {
+    checkAborted(signal);
+
+    const extraBuffer = Buffer.allocUnsafeSlow(1);
+    const bytesRead = (await PromisePrototypeThen(
+      binding.read(filehandle.fd, extraBuffer, 0, 1, -1, kUsePromises),
+      undefined,
+      handleErrorFromBinding,
+    )) ?? 0;
+
+    if (bytesRead !== 0) {
+      throw new ERR_INVALID_ARG_VALUE(
+        byteLengthName,
+        buffer.byteLength,
+        'is too small to contain the entire file',
+      );
+    }
+  }
+
+  return encoding ? buffer.toString(encoding) : buffer.subarray(0, totalRead);
+}
+
 async function readFileHandle(filehandle, options) {
   const signal = options?.signal;
   const encoding = options?.encoding;
@@ -1185,6 +1238,10 @@ async function readFileHandle(filehandle, options) {
   if (size > kIoMaxLength)
     throw new ERR_FS_FILE_TOO_LARGE(size);
 
+  if (options.buffer !== undefined || options.getBuffer !== undefined) {
+    return readFileHandleWithUserBuffer(filehandle, options, size);
+  }
+
   let totalRead = 0;
   const noSize = size === 0;
   let buffer = Buffer.allocUnsafeSlow(length);
@@ -1925,6 +1982,7 @@ async function appendFile(path, data, options) {
 
 async function readFile(path, options) {
   options = getOptions(options, { flag: 'r' });
+  validateReadFileBufferOptions(options);
   const flag = options.flag || 'r';
 
   if (path instanceof FileHandle)
diff --git a/lib/internal/fs/read/context.js b/lib/internal/fs/read/context.js
index 193251a0516d76..270f83323d5d52 100644
--- a/lib/internal/fs/read/context.js
+++ b/lib/internal/fs/read/context.js
@@ -11,6 +11,9 @@ const {
     kReadFileBufferLength,
     kReadFileUnknownBufferLength,
   },
+  createReadFileBufferTooSmallError,
+  getReadFileBuffer,
+  getReadFileBufferByteLengthName,
 } = require('internal/fs/utils');
 
 const { Buffer } = require('buffer');
@@ -28,8 +31,30 @@ function readFileAfterRead(err, bytesRead) {
   if (err)
     return context.close(err);
 
+  if (context.checkOverflow) {
+    context.checkOverflow = false;
+
+    if (bytesRead !== 0) {
+      return context.close(createReadFileBufferTooSmallError(
+        context.bufferByteLengthName,
+        context.buffer.byteLength,
+      ));
+    }
+
+    return context.close();
+  }
+
   context.pos += bytesRead;
 
+  if (context.userBuffer) {
+    if (context.pos === context.size || bytesRead === 0) {
+      context.close();
+    } else {
+      context.read();
+    }
+    return;
+  }
+
   if (context.pos === context.size || bytesRead === 0) {
     context.close();
   } else {
@@ -52,12 +77,15 @@ function readFileAfterClose(err) {
     return callback(aggregateTwoErrors(err, context.err));
 
   try {
-    if (context.size === 0)
+    if (context.userBuffer) {
+      buffer = context.buffer.subarray(0, context.pos);
+    } else if (context.size === 0) {
       buffer = Buffer.concat(context.buffers, context.pos);
-    else if (context.pos < context.size)
+    } else if (context.pos < context.size) {
       buffer = context.buffer.slice(0, context.pos);
-    else
+    } else {
       buffer = context.buffer;
+    }
 
     if (context.encoding)
       buffer = buffer.toString(context.encoding);
@@ -69,7 +97,7 @@ function readFileAfterClose(err) {
 }
 
 class ReadFileContext {
-  constructor(callback, encoding) {
+  constructor(callback, options) {
     this.fd = undefined;
     this.isUserFd = undefined;
     this.size = 0;
@@ -77,9 +105,31 @@ class ReadFileContext {
     this.buffers = null;
     this.buffer = null;
     this.pos = 0;
-    this.encoding = encoding;
+    this.encoding = options.encoding;
+    this.options = options;
     this.err = null;
     this.signal = undefined;
+    this.userBuffer = false;
+    this.bufferByteLengthName = null;
+    this.overflowBuffer = null;
+    this.checkOverflow = false;
+  }
+
+  prepare() {
+    const buffer = getReadFileBuffer(this.options, this.size);
+
+    if (buffer !== undefined) {
+      this.buffer = buffer;
+      this.userBuffer = true;
+      this.bufferByteLengthName = getReadFileBufferByteLengthName(this.options);
+      return;
+    }
+
+    if (this.size === 0) {
+      this.buffers = [];
+    } else {
+      this.buffer = Buffer.allocUnsafeSlow(this.size);
+    }
   }
 
   read() {
@@ -91,7 +141,25 @@ class ReadFileContext {
       return this.close(
         new AbortError(undefined, { cause: this.signal.reason }));
     }
-    if (this.size === 0) {
+
+    if (this.userBuffer) {
+      if (this.size === 0) {
+        buffer = this.buffer;
+        offset = this.pos;
+        length = this.buffer.byteLength - this.pos;
+
+        if (length === 0) {
+          buffer = this.overflowBuffer ??= Buffer.allocUnsafeSlow(1);
+          offset = 0;
+          length = 1;
+          this.checkOverflow = true;
+        }
+      } else {
+        buffer = this.buffer;
+        offset = this.pos;
+        length = MathMin(kReadFileBufferLength, this.size - this.pos);
+      }
+    } else if (this.size === 0) {
       buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
       offset = 0;
       length = kReadFileUnknownBufferLength;
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 811c52aeffb8b9..1790ff5713e0a4 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -27,6 +27,7 @@ const {
 } = primordials;
 
 const { Buffer } = require('buffer');
+const { isBuffer: BufferIsBuffer } = Buffer;
 const {
   UVException,
   codes: {
@@ -56,6 +57,7 @@ const { toPathIfFileURL } = require('internal/url');
 const {
   validateAbortSignal,
   validateBoolean,
+  validateBuffer,
   validateFunction,
   validateInt32,
   validateInteger,
@@ -1033,6 +1035,66 @@ const validateStringAfterArrayBufferView = hideStackFrames((buffer, name) => {
   }
 });
 
+const validateReadFileBufferOptions = hideStackFrames((options) => {
+  const { buffer, getBuffer } = options;
+
+  if (buffer !== undefined && getBuffer !== undefined) {
+    throw new ERR_INCOMPATIBLE_OPTION_PAIR.HideStackFramesError(
+      'buffer',
+      'getBuffer',
+    );
+  }
+
+  if (buffer !== undefined) {
+    validateBuffer.withoutStackTrace(buffer, 'options.buffer');
+  }
+
+  if (getBuffer !== undefined) {
+    validateFunction.withoutStackTrace(getBuffer, 'options.getBuffer');
+  }
+});
+
+function getReadFileBufferByteLengthName(options) {
+  return options.buffer !== undefined ?
+    'options.buffer.byteLength' :
+    'options.getBuffer().byteLength';
+}
+
+const getReadFileBuffer = hideStackFrames((options, size) => {
+  let { buffer } = options;
+
+  if (buffer === undefined && options.getBuffer !== undefined) {
+    buffer = options.getBuffer(size);
+    validateBuffer.withoutStackTrace(buffer, 'options.getBuffer()');
+  }
+
+  if (buffer === undefined) {
+    return undefined;
+  }
+
+  if (!BufferIsBuffer(buffer)) {
+    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+
+  if (size > buffer.byteLength) {
+    throw new ERR_INVALID_ARG_VALUE.HideStackFramesError(
+      getReadFileBufferByteLengthName(options),
+      buffer.byteLength,
+      `is smaller than the file size of ${size} bytes`,
+    );
+  }
+
+  return buffer;
+});
+
+const createReadFileBufferTooSmallError = hideStackFrames((name, byteLength) => {
+  return new ERR_INVALID_ARG_VALUE.HideStackFramesError(
+    name,
+    byteLength,
+    'is too small to contain the entire file',
+  );
+});
+
 const validatePosition = hideStackFrames((position, name, length) => {
   if (typeof position === 'number') {
     validateInteger.withoutStackTrace(position, name, -1);
@@ -1081,6 +1143,10 @@ module.exports = {
   validateOffsetLengthWrite,
   validatePath,
   validatePosition,
+  validateReadFileBufferOptions,
+  getReadFileBuffer,
+  getReadFileBufferByteLengthName,
+  createReadFileBufferTooSmallError,
   validateRmOptions,
   validateRmOptionsSync,
   validateRmdirOptions,
diff --git a/test/parallel/test-fs-promises-readfile-buffer-option.js b/test/parallel/test-fs-promises-readfile-buffer-option.js
new file mode 100644
index 00000000000000..9d374c1f8b9fa5
--- /dev/null
+++ b/test/parallel/test-fs-promises-readfile-buffer-option.js
@@ -0,0 +1,150 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const {
+  open,
+  readFile,
+} = fs.promises;
+const tmpdir = require('../common/tmpdir');
+const { internalBinding } = require('internal/test/binding');
+
+const fsBinding = internalBinding('fs');
+
+tmpdir.refresh();
+
+const file = tmpdir.resolve('fs-promises-readfile-buffer-option.txt');
+const content = Buffer.from('Hello promises buffer option\n'.repeat(128));
+fs.writeFileSync(file, content);
+
+async function withFstatSizeZero(fn) {
+  const originalFstat = fsBinding.fstat;
+  fsBinding.fstat = function(...args) {
+    const result = Reflect.apply(originalFstat, this, args);
+    return Promise.resolve(result).then((stats) => {
+      if (stats !== undefined) {
+        stats[8] = 0;
+      }
+      return stats;
+    });
+  };
+
+  try {
+    await fn();
+  } finally {
+    fsBinding.fstat = originalFstat;
+  }
+}
+
+(async () => {
+  {
+    const buffer = Buffer.alloc(content.length + 16, 0x78);
+    const data = await readFile(file, { buffer });
+    assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+    assert.deepStrictEqual(data, content);
+    assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+  }
+
+  {
+    const buffer = Buffer.alloc(content.length + 16);
+    assert.strictEqual(
+      await readFile(file, { buffer, encoding: 'utf8' }),
+      content.toString('utf8'),
+    );
+    assert.deepStrictEqual(buffer.subarray(0, content.length), content);
+  }
+
+  {
+    let size;
+    const data = await readFile(file, {
+      getBuffer(fileSize) {
+        size = fileSize;
+        return Buffer.alloc(fileSize + 8);
+      },
+    });
+    assert.strictEqual(size, content.length);
+    assert.deepStrictEqual(data, content);
+  }
+
+  {
+    await using handle = await open(file, 'r');
+    const buffer = Buffer.alloc(content.length + 16, 0x78);
+    const data = await handle.readFile({ buffer });
+    assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+    assert.deepStrictEqual(data, content);
+    assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+  }
+
+  {
+    await using handle = await open(file, 'r');
+    let size;
+    const data = await handle.readFile({
+      getBuffer(fileSize) {
+        size = fileSize;
+        return Buffer.alloc(fileSize + 8);
+      },
+    });
+    assert.strictEqual(size, content.length);
+    assert.deepStrictEqual(data, content);
+  }
+
+  await assert.rejects(readFile(file, {
+    buffer: Buffer.alloc(1),
+    getBuffer: common.mustNotCall(),
+  }), {
+    code: 'ERR_INCOMPATIBLE_OPTION_PAIR',
+  });
+
+  await assert.rejects(readFile(file, {
+    getBuffer() {
+      return Buffer.alloc(content.length - 1);
+    },
+  }), {
+    code: 'ERR_INVALID_ARG_VALUE',
+  });
+
+  {
+    await using handle = await open(file, 'r');
+    await assert.rejects(handle.readFile({
+      buffer: Buffer.alloc(content.length - 1),
+    }), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  }
+
+  await withFstatSizeZero(common.mustCall(async () => {
+    {
+      const buffer = Buffer.alloc(content.length + 16, 0x78);
+      const data = await readFile(file, { buffer });
+      assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+      assert.deepStrictEqual(data, content);
+      assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+    }
+
+    {
+      await using handle = await open(file, 'r');
+      const buffer = Buffer.alloc(content.length + 16, 0x78);
+      const data = await handle.readFile({ buffer });
+      assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+      assert.deepStrictEqual(data, content);
+      assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+    }
+
+    await assert.rejects(readFile(file, {
+      buffer: Buffer.alloc(content.length - 1),
+    }), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+
+    {
+      await using handle = await open(file, 'r');
+      await assert.rejects(handle.readFile({
+        buffer: Buffer.alloc(content.length - 1),
+      }), {
+        code: 'ERR_INVALID_ARG_VALUE',
+      });
+    }
+  }));
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-readfile-buffer-option.js b/test/parallel/test-fs-readfile-buffer-option.js
new file mode 100644
index 00000000000000..93727cf40a35c4
--- /dev/null
+++ b/test/parallel/test-fs-readfile-buffer-option.js
@@ -0,0 +1,173 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const { internalBinding } = require('internal/test/binding');
+
+const fsBinding = internalBinding('fs');
+
+tmpdir.refresh();
+
+const file = tmpdir.resolve('readfile-buffer-option.txt');
+const content = Buffer.from('Hello buffer option\n'.repeat(128));
+fs.writeFileSync(file, content);
+
+function readFile(path, options) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, options, (err, data) => {
+      if (err) reject(err);
+      else resolve(data);
+    });
+  });
+}
+
+async function withFstatSizeZero(fn) {
+  const originalFstat = fsBinding.fstat;
+  fsBinding.fstat = function(...args) {
+    const req = args[2];
+
+    if (req?.oncomplete) {
+      const originalOncomplete = req.oncomplete;
+      req.oncomplete = function(err, stats) {
+        if (!err) {
+          stats[8] = 0;
+        }
+        return originalOncomplete.call(this, err, stats);
+      };
+      return Reflect.apply(originalFstat, this, args);
+    }
+
+    const stats = Reflect.apply(originalFstat, this, args);
+    if (stats !== undefined) {
+      stats[8] = 0;
+    }
+    return stats;
+  };
+
+  try {
+    await fn();
+  } finally {
+    fsBinding.fstat = originalFstat;
+  }
+}
+
+(async () => {
+  {
+    const buffer = Buffer.alloc(content.length + 16, 0x78);
+    const data = fs.readFileSync(file, { buffer });
+    assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+    assert.deepStrictEqual(data, content);
+    assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+  }
+
+  {
+    const buffer = Buffer.alloc(content.length + 16);
+    assert.strictEqual(
+      fs.readFileSync(file, { buffer, encoding: 'utf8' }),
+      content.toString('utf8'),
+    );
+    assert.deepStrictEqual(buffer.subarray(0, content.length), content);
+  }
+
+  {
+    let size;
+    const data = fs.readFileSync(file, {
+      getBuffer(fileSize) {
+        size = fileSize;
+        return Buffer.alloc(fileSize + 8);
+      },
+    });
+    assert.strictEqual(size, content.length);
+    assert.deepStrictEqual(data, content);
+  }
+
+  {
+    const buffer = Buffer.alloc(content.length + 16, 0x78);
+    const data = await readFile(file, { buffer });
+    assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+    assert.deepStrictEqual(data, content);
+    assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+  }
+
+  {
+    const buffer = Buffer.alloc(content.length + 16);
+    assert.strictEqual(
+      await readFile(file, { buffer, encoding: 'utf8' }),
+      content.toString('utf8'),
+    );
+    assert.deepStrictEqual(buffer.subarray(0, content.length), content);
+  }
+
+  {
+    let size;
+    const data = await readFile(file, {
+      getBuffer(fileSize) {
+        size = fileSize;
+        return Buffer.alloc(fileSize + 8);
+      },
+    });
+    assert.strictEqual(size, content.length);
+    assert.deepStrictEqual(data, content);
+  }
+
+  {
+    const buffer = Buffer.alloc(content.length - 1);
+    assert.throws(() => fs.readFileSync(file, { buffer }), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  }
+
+  await assert.rejects(readFile(file, {
+    getBuffer() {
+      return Buffer.alloc(content.length - 1);
+    },
+  }), {
+    code: 'ERR_INVALID_ARG_VALUE',
+  });
+
+  {
+    const buffer = Buffer.alloc(1);
+    assert.throws(() => {
+      fs.readFile(file, {
+        buffer,
+        getBuffer: common.mustNotCall(),
+      }, common.mustNotCall());
+    }, {
+      code: 'ERR_INCOMPATIBLE_OPTION_PAIR',
+    });
+  }
+
+  await withFstatSizeZero(common.mustCall(async () => {
+    {
+      const buffer = Buffer.alloc(content.length + 16, 0x78);
+      const data = fs.readFileSync(file, { buffer });
+      assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+      assert.deepStrictEqual(data, content);
+      assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+    }
+
+    {
+      const buffer = Buffer.alloc(content.length + 16, 0x78);
+      const data = await readFile(file, { buffer });
+      assert.deepStrictEqual(data, buffer.subarray(0, content.length));
+      assert.deepStrictEqual(data, content);
+      assert(buffer.subarray(content.length).every((byte) => byte === 0x78));
+    }
+
+    {
+      const buffer = Buffer.alloc(content.length - 1);
+      assert.throws(() => fs.readFileSync(file, { buffer }), {
+        code: 'ERR_INVALID_ARG_VALUE',
+      });
+    }
+
+    await assert.rejects(readFile(file, {
+      buffer: Buffer.alloc(content.length - 1),
+    }), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  }));
+})().then(common.mustCall());