Function writevAll

lib/internal/fs/promises.js:797–841

(buffers, position, signal)

    // Writev with EAGAIN retry. On partial write, concatenates remaining
    // buffers and falls back to writeAll (same approach as WriteStream).
    async function writevAll(buffers, position, signal) {
      asyncPending = true;
      try {
        let totalSize = 0;
        for (let i = 0; i < buffers.length; i++) {
          totalSize += buffers[i].byteLength;
        }

        let retries = 0;
        while (totalSize > 0) {
          const bytesWritten = (await PromisePrototypeThen(
            binding.writeBuffers(fd, buffers, position, kUsePromises),
            undefined,
            handleErrorFromBinding,
          )) || 0;

          signal?.throwIfAborted();

          if (bytesWritten === 0) {
            if (++retries > 5) {
              throw new ERR_OPERATION_FAILED('writev failed after retries');
            }
          } else {
            retries = 0;
          }

          totalBytesWritten += bytesWritten;
          totalSize -= bytesWritten;
          if (position >= 0) position += bytesWritten;

          if (totalSize > 0) {
            // Partial write - concatenate remaining and use writeAll.
            const remaining = Buffer.concat(buffers);
            const wrote = bytesWritten;
            // writeAll is already inside asyncPending = true, but
            // writeAll sets it again - that's fine (idempotent).
            await writeAll(remaining, wrote, remaining.length - wrote,
                           position, signal);
            return;
          }
        }
      } finally {
        asyncPending = false;
      }
    }

    // Synchronous write with EAGAIN retry. Throws on I/O error.
    // Used by writeSync for the full write, and by writevSync for