Use writeChain instead of writev in Transport::write to have zerocopy support

Summary:
Switch both Transport::write() overloads (ByteRange and IOBufQueue) to
use writeChain instead of writev/write. This enables the zero-copy
(MSG_ZEROCOPY) code path in AsyncSocket::writeChainImpl, which checks
zeroCopyEnabled_, isManaged(), and the enable threshold before adding
MSG_ZEROCOPY to individual writes.

The old writev/write path bypassed writeChainImpl entirely, so zero-copy
decisions were never evaluated even when zero copy was enabled on the
socket.

For the IOBufQueue overload, this also avoids an intermediate
std::vector<iovec> allocation from getIov().

For the ByteRange overload, wrapBuffer creates an unmanaged IOBuf so
isManaged() returns false, meaning MSG_ZEROCOPY won't be added (which is
correct since ByteRange data may point at stack memory).

Reviewed By: dmm-fb

Differential Revision: D96616945

fbshipit-source-id: 5a53269db20b8f3a0ae53d71530a2ee879a0de4e

Author: Rahul Dutta

third-party/folly/src/folly/io/coro/Transport.cpp

@@ -119,7 +119,8 @@ Task<folly::Unit> Transport::write(
     WriteInfo* writeInfo) {
   transport_->setSendTimeout(timeout.count());
   WriteCallback cb{*transport_};
-  transport_->write(&cb, buf.begin(), buf.size(), writeFlags);
+  transport_->writeChain(
+      &cb, folly::IOBuf::wrapBuffer(buf.begin(), buf.size()), writeFlags);
   auto waitRet = co_await co_awaitTry(cb.wait());
   if (waitRet.hasException()) {
     if (writeInfo) {
@@ -144,8 +145,7 @@ Task<folly::Unit> Transport::write(
     WriteInfo* writeInfo) {
   transport_->setSendTimeout(timeout.count());
   WriteCallback cb{*transport_};
-  auto iovec = ioBufQueue.front()->getIov();
-  transport_->writev(&cb, iovec.data(), iovec.size(), writeFlags);
+  transport_->writeChain(&cb, ioBufQueue.move(), writeFlags);
   auto waitRet = co_await co_awaitTry(cb.wait());
   if (waitRet.hasException()) {
     if (writeInfo) {

third-party/folly/src/folly/io/coro/test/TransportTest.cpp

@@ -268,6 +268,57 @@ TEST_F(ServerTransportTest, SimpleWritev) {
   });
 }
 
+// Verify that write(IOBufQueue&) moves the data out of the queue and
+// delivers it correctly. This exercises the writeChain path.
+TEST_F(ServerTransportTest, WriteIOBufQueueMovesData) {
+  run([&]() -> Task<> {
+    auto cs = co_await connect();
+    auto ss = srv.accept(-1);
+
+    IOBufQueue sndBuf(IOBufQueue::cacheChainLength());
+    constexpr auto kBufSize = 4096;
+    std::array<uint8_t, kBufSize> data;
+    std::memset(data.data(), 'x', data.size());
+    sndBuf.append(data.data(), data.size());
+
+    EXPECT_EQ(sndBuf.chainLength(), kBufSize);
+    co_await cs.write(sndBuf);
+    // After write, the IOBufQueue should be empty (data was moved)
+    EXPECT_EQ(sndBuf.chainLength(), 0);
+
+    std::array<uint8_t, kBufSize> rcvBuf{};
+    ss->readAll(rcvBuf.data(), rcvBuf.size());
+    EXPECT_EQ(0, memcmp(data.data(), rcvBuf.data(), rcvBuf.size()));
+  });
+}
+
+// Verify that write(IOBufQueue&) works with a multi-element IOBuf chain.
+TEST_F(ServerTransportTest, WriteIOBufQueueChain) {
+  run([&]() -> Task<> {
+    auto cs = co_await connect();
+    auto ss = srv.accept(-1);
+
+    IOBufQueue sndBuf(IOBufQueue::cacheChainLength());
+    constexpr auto kChunkSize = 1024;
+    constexpr auto kNumChunks = 8;
+    std::array<uint8_t, kChunkSize * kNumChunks> expected;
+    for (size_t i = 0; i < kNumChunks; ++i) {
+      std::memset(
+          expected.data() + i * kChunkSize,
+          static_cast<int>('a' + i),
+          kChunkSize);
+      sndBuf.append(expected.data() + i * kChunkSize, kChunkSize);
+    }
+
+    co_await cs.write(sndBuf);
+    EXPECT_EQ(sndBuf.chainLength(), 0);
+
+    std::array<uint8_t, kChunkSize * kNumChunks> rcvBuf{};
+    ss->readAll(rcvBuf.data(), rcvBuf.size());
+    EXPECT_EQ(0, memcmp(expected.data(), rcvBuf.data(), rcvBuf.size()));
+  });
+}
+
 TEST_F(ServerTransportTest, WriteCancelled) {
   run([&]() -> Task<> {
     auto cs = co_await connect();