grpc 1.81.1 → 1.85.0

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -35,6 +35,7 @@
 #include "src/core/util/grpc_check.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -86,7 +87,7 @@ class PollEventHandle : public EventHandle {
         read_closure_(reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)),
         write_closure_(
             reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
-    grpc_core::MutexLock lock(&poller_->mu_);
+    grpc_core::MutexLock lock(poller_->mu_);
     poller_->PollerHandlesListAddHandle(this);
   }
   PollPoller* Poller() override { return poller_.get(); }
@@ -104,7 +105,7 @@ class PollEventHandle : public EventHandle {
     return false;
   }
   void ForceRemoveHandleFromPoller() {
-    grpc_core::MutexLock lock(&poller_->mu_);
+    grpc_core::MutexLock lock(poller_->mu_);
     poller_->PollerHandlesListRemoveHandle(this);
   }
   FileDescriptor WrappedFd() override { return fd_; }
@@ -141,13 +142,13 @@ class PollEventHandle : public EventHandle {
   void SetWritable() override;
   void SetHasError() override;
   bool IsHandleShutdown() override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return is_shutdown_;
   };
   inline void ExecutePendingActions() {
     int kick = 0;
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       if ((pending_actions_ & 1UL)) {
         if (SetReadyLocked(&read_closure_)) {
           kick = 1;
@@ -263,11 +264,7 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done,
     // Perform shutdown operations if not already done so.
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      shutdown_error_ =
-          absl::Status(absl::StatusCode::kInternal, "FD Orphaned");
-      grpc_core::StatusSetInt(&shutdown_error_,
-                              grpc_core::StatusIntProperty::kRpcStatus,
-                              GRPC_STATUS_UNAVAILABLE);
+      shutdown_error_ = absl::UnavailableError("FD Orphaned");
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
@@ -337,15 +334,13 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
   // of a closure which calls OrphanHandle or poller->Shutdown() prematurely.
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     // only shutdown once
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      shutdown_error_ = std::move(why);
-      grpc_core::StatusSetInt(
-          &shutdown_error_, grpc_core::StatusIntProperty::kRpcStatus,
-          absl::IsCancelled(shutdown_error_) ? GRPC_STATUS_CANCELLED
-                                             : GRPC_STATUS_UNAVAILABLE);
+      shutdown_error_ = absl::IsCancelled(why)
+                            ? std::move(why)
+                            : absl::UnavailableError(why.message());
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
@@ -408,7 +403,7 @@ void PollEventHandle::NotifyOnError(PosixEngineClosure* on_error) {
 void PollEventHandle::SetReadable() {
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     SetReadyLocked(&read_closure_);
   }
   Unref();
@@ -417,7 +412,7 @@ void PollEventHandle::SetReadable() {
 void PollEventHandle::SetWritable() {
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     SetReadyLocked(&write_closure_);
   }
   Unref();
@@ -461,7 +456,7 @@ bool PollEventHandle::EndPollLocked(bool got_read, bool got_write) {
 }
 
 void PollPoller::KickExternal(bool ext) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (closed_) {
     return;
   }
@@ -571,7 +566,7 @@ Poller::WorkResult PollPoller::Work(
     PollEventHandle* head = poll_handles_list_head_;
     while (head != nullptr) {
       {
-        grpc_core::MutexLock lock(head->mu());
+        grpc_core::MutexLock lock(*head->mu());
         // There shouldn't be any orphaned fds at this point. This is because
         // prior to marking a handle as orphaned it is first removed from
         // poll handle list for the poller under the poller lock.
@@ -590,8 +585,9 @@ Poller::WorkResult PollPoller::Work(
             pfds[pfd_count].events = head->BeginPollLocked(POLLIN, POLLOUT);
             pfd_count++;
           } else {
-            LOG(INFO) << "FD from fork parent still in poll list: "
-                      << head->WrappedFd();
+            LOG_EVERY_N_SEC(INFO, 10)
+                << "FD from fork parent still in poll list: "
+                << head->WrappedFd();
           }
         }
       }
@@ -721,7 +717,7 @@ Poller::WorkResult PollPoller::Work(
 }
 
 void PollPoller::Close() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   closed_ = true;
 }
 
@@ -732,7 +728,7 @@ void PollPoller::HandleForkInChild() {
   }
   PollEventHandle* handle;
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     handle = poll_handles_list_head_;
   }
   while (handle != nullptr) {
@@ -748,7 +744,7 @@ void PollPoller::ResetKickState() {
   // new fd
   // TODO (eostroukhov): Need to consider merging kicked/kicked_ext
   // with the wakeup_fd so there's no duplicate state.
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   was_kicked_ = false;
   was_kicked_ext_ = false;
 }

data/src/core/lib/event_engine/posix_engine/file_descriptor_collection.cc

@@ -35,7 +35,7 @@ FileDescriptorCollection::FileDescriptorCollection(int generation) noexcept
 FileDescriptorCollection::FileDescriptorCollection(
     FileDescriptorCollection&& other) noexcept
     : generation_(other.generation_) {
-  grpc_core::MutexLock lock(&other.mu_);
+  grpc_core::MutexLock lock(other.mu_);
   file_descriptors_ = std::move(other.file_descriptors_);
   other.generation_ = -1;
   other.file_descriptors_.clear();
@@ -44,8 +44,8 @@ FileDescriptorCollection::FileDescriptorCollection(
 FileDescriptorCollection& FileDescriptorCollection::operator=(
     FileDescriptorCollection&& other) noexcept {
   generation_ = other.generation_;
-  grpc_core::MutexLock self_lock(&mu_);
-  grpc_core::MutexLock other_lock(&other.mu_);
+  grpc_core::MutexLock self_lock(mu_);
+  grpc_core::MutexLock other_lock(other.mu_);
   file_descriptors_ = std::move(other.file_descriptors_);
   other.generation_ = -1;
   other.file_descriptors_.clear();
@@ -54,7 +54,7 @@ FileDescriptorCollection& FileDescriptorCollection::operator=(
 
 FileDescriptor FileDescriptorCollection::Add(int fd) {
   if (IsForkEnabled()) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     file_descriptors_.emplace(fd);
   }
   return FileDescriptor(fd, generation_);
@@ -65,7 +65,7 @@ bool FileDescriptorCollection::Remove(const FileDescriptor& fd) {
     return true;
   }
   if (fd.generation() == generation_) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return file_descriptors_.erase(fd.fd()) == 1;
   }
   return false;
@@ -76,7 +76,7 @@ FileDescriptorCollection::ClearAndReturnRawDescriptors() {
   if (!IsForkEnabled()) {
     return {};
   }
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   absl::flat_hash_set<int> file_descriptors = std::move(file_descriptors_);
   // Should not be necessary, but standard is not clear if move would empty
   // the collection

data/src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h

@@ -106,7 +106,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
       : poller_(poller) {}
 
   ~GrpcPolledFdFactoryPosix() override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     for (auto& fd : owned_fds_) {
       close(fd);
     }
@@ -116,7 +116,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 
   std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
       ares_socket_t as) override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     owned_fds_.insert(as);
     CHECK_NE(poller_, nullptr);
     FileDescriptor fd(as, poller_->posix_interface().generation());
@@ -165,7 +165,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
   static int Close(ares_socket_t as, void* user_data) {
     GrpcPolledFdFactoryPosix* self =
         static_cast<GrpcPolledFdFactoryPosix*>(user_data);
-    grpc_core::MutexLock lock(&self->mu_);
+    grpc_core::MutexLock lock(self->mu_);
     if (self->owned_fds_.find(as) == self->owned_fds_.end()) {
       // c-ares owns this fd, grpc has never seen it
       return close(as);

data/src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.cc

@@ -95,7 +95,8 @@ NativePosixDNSResolver::NativePosixDNSResolver(
 void NativePosixDNSResolver::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
     absl::string_view name, absl::string_view default_port) {
-  event_engine_->Run([name = std::string(name), default_port,
+  event_engine_->Run([name = std::string(name),
+                      default_port = std::string(default_port),
                       on_resolved = std::move(on_resolved)]() mutable {
     on_resolved(LookupHostnameBlocking(name, default_port));
   });

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -29,6 +29,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
@@ -44,7 +45,6 @@
 #include "src/core/util/load_file.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
-#include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
@@ -124,7 +124,7 @@ void rtrim(std::string& s) {
 
 uint64_t ParseUlimitMemLockFromFile(std::string file_name) {
   static std::string kHardMemlockPrefix = "* hard memlock";
-  auto result = grpc_core::LoadFile(file_name, false);
+  auto result = grpc_core::LoadFile(file_name);
   if (!result.ok()) {
     return 0;
   }
@@ -136,10 +136,11 @@ uint64_t ParseUlimitMemLockFromFile(std::string file_name) {
     return 0;
   }
   // Find position of next newline after prefix.
-  size_t end = file_contents.find(start, '\n');
+  size_t end = file_contents.find('\n', start);
   // Extract substring between prefix and next newline.
+  size_t value_start = start + kHardMemlockPrefix.length() + 1;
   auto memlock_value_string = file_contents.substr(
-      start + kHardMemlockPrefix.length() + 1, end - start);
+      value_start, end == std::string::npos ? end : end - value_start);
   rtrim(memlock_value_string);
   if (memlock_value_string == "unlimited" ||
       memlock_value_string == "infinity") {
@@ -215,10 +216,10 @@ bool CmsgIsZeroCopy(const cmsghdr& cmsg) {
 absl::Status PosixOSError(const PosixErrorOr<int64_t>& error_no,
                           absl::string_view call_name) {
   if (error_no.IsPosixError()) {
-    return absl::UnknownError(
+    return absl::UnavailableError(
         absl::StrCat(call_name, ": ", error_no.StrError()));
   }
-  return absl::UnknownError(
+  return absl::UnavailableError(
       absl::StrCat(call_name, ": Wrong file descriptor generation"));
 }
 
@@ -279,15 +280,17 @@ void PosixEndpointImpl::FinishEstimate() {
   } else {
     target_length_ = 0.99 * target_length_ + 0.01 * bytes_read_this_round_;
   }
+  // Opt-in: if a maximum read buffer size has been configured, clamp the
+  // adaptive target so that occasional large reads do not leave a permanently
+  // high read-buffer high-watermark. When unset (max_read_buffer_size_ < 0)
+  // the behavior is unchanged.
+  if (max_read_buffer_size_ >= 0 &&
+      target_length_ > static_cast<double>(max_read_buffer_size_)) {
+    target_length_ = static_cast<double>(max_read_buffer_size_);
+  }
   bytes_read_this_round_ = 0;
 }
 
-absl::Status PosixEndpointImpl::TcpAnnotateError(absl::Status src_error) const {
-  grpc_core::StatusSetInt(&src_error, grpc_core::StatusIntProperty::kRpcStatus,
-                          GRPC_STATUS_UNAVAILABLE);
-  return src_error;
-}
-
 // Returns true if data available to read or error other than EAGAIN.
 bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
   GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("TcpDoRead");
@@ -296,6 +299,7 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
   struct iovec iov[MAX_READ_IOVEC];
   size_t total_read_bytes = 0;
   size_t iov_len = std::min<size_t>(MAX_READ_IOVEC, incoming_buffer_->Count());
+  size_t slice_idx = iov_len;
 #ifdef GRPC_LINUX_ERRQUEUE
   constexpr size_t cmsg_alloc_space =
       CMSG_SPACE(sizeof(scm_timestamping)) + CMSG_SPACE(sizeof(int));
@@ -364,14 +368,11 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       incoming_buffer_->Clear();
       if (res.IsWrongGenerationError()) {
         status = absl::CancelledError("Closed on fork");
-        grpc_core::StatusSetInt(&status,
-                                grpc_core::StatusIntProperty::kRpcStatus,
-                                GRPC_STATUS_CANCELLED);
       } else if (read_bytes == 0) {
-        status = TcpAnnotateError(absl::InternalError("Socket closed"));
+        status = absl::UnavailableError("Socket closed");
       } else {
-        status = TcpAnnotateError(absl::InternalError(
-            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
+        status =
+            absl::UnavailableError(absl::StrCat("recvmsg:", res.StrError()));
       }
       return true;
     }
@@ -419,6 +420,19 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       ++j;
     }
     iov_len = j;
+    // For cases where incoming_buffer_->Count() > MAX_READ_IOVEC, if the
+    // previous read resulted in a partial read, the previous loop remaining -=
+    // iov[i].iov_len; may execute for all of the IOVs. In that case iov_len
+    // would be 0. For this case, we need to add ptrs to the remaining
+    // slices in incoming_buffer_ to the IOV entries.
+    while (iov_len < MAX_READ_IOVEC && slice_idx < incoming_buffer_->Count()) {
+      MutableSlice& slice = internal::SliceCast<MutableSlice>(
+          incoming_buffer_->MutableSliceAt(slice_idx));
+      iov[iov_len].iov_base = slice.begin();
+      iov[iov_len].iov_len = slice.length();
+      iov_len++;
+      slice_idx++;
+    }
   } while (true);
 
   if (inq_ == 0) {
@@ -495,21 +509,18 @@ void PosixEndpointImpl::UpdateRcvLowat() {
   // TODO(ctiller): Check if supported by OS.
   // TODO(ctiller): Allow some adjustments instead of hardcoding things.
 
-  static constexpr int kRcvLowatMax = 16 * 1024 * 1024;
   static constexpr int kRcvLowatThreshold = 16 * 1024;
 
   int remaining = std::min({static_cast<int>(incoming_buffer_->Length()),
-                            kRcvLowatMax, min_progress_size_});
+                            rcv_lowat_max_, min_progress_size_});
 
   // Setting SO_RCVLOWAT for small quantities does not save on CPU.
-  if (remaining < kRcvLowatThreshold) {
-    remaining = 0;
-  }
-
-  // If zerocopy is off, wake shortly before the full RPC is here. More can
-  // show up partway through recvmsg() since it takes a while to copy data.
-  // So an early wakeup aids latency.
-  if (!tcp_zerocopy_send_ctx_->Enabled() && remaining > 0) {
+  if (remaining < 2 * kRcvLowatThreshold) {
+    remaining = 1;
+  } else {
+    // Decrement remaining by kRcvLowatThreshold. This would have the effect of
+    // waking up a little early. It would help with latency because some bytes
+    // may arrive while we execute the recvmsg syscall after waking up.
     remaining -= kRcvLowatThreshold;
   }
 
@@ -578,11 +589,17 @@ bool PosixEndpointImpl::HandleReadLocked(absl::Status& status) {
     }
   } else {
     if (!memory_owner_.is_valid() && status.ok()) {
-      status = TcpAnnotateError(absl::UnknownError("Shutting down endpoint"));
+      status = absl::UnavailableError("Shutting down endpoint");
     }
     incoming_buffer_->Clear();
     last_read_buffer_.Clear();
   }
+  // Update rcv lowat needs to be called at the end of the current read
+  // operation to ensure the right SO_RCVLOWAT value is set for the next read.
+  // Otherwise the next endpoint read operation may get stuck indefinitely
+  // because the previously set rcv lowat value will persist and the socket may
+  // erroneously considered to not be ready for read.
+  UpdateRcvLowat();
   return true;
 }
 
@@ -590,7 +607,7 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
   bool ret = false;
   absl::AnyInvocable<void(absl::Status)> cb = nullptr;
   grpc_core::EnsureRunInExecCtx([&, this]() mutable {
-    grpc_core::MutexLock lock(&read_mu_);
+    grpc_core::MutexLock lock(read_mu_);
     ret = HandleReadLocked(status);
     if (ret) {
       GRPC_TRACE_LOG(event_engine_endpoint, INFO)
@@ -626,7 +643,6 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
   Ref().release();
   if (is_first_read_) {
     read_cb_ = std::move(on_read);
-    UpdateRcvLowat();
     // Endpoint read called for the very first time. Register read callback
     // with the polling engine.
     is_first_read_ = false;
@@ -634,7 +650,6 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     handle_->NotifyOnRead(on_read_);
   } else if (inq_ == 0) {
     read_cb_ = std::move(on_read);
-    UpdateRcvLowat();
     lock.Release();
     // Upper layer asked to read more but we know there is no pending data to
     // read from previous reads. So, wait for POLLIN.
@@ -662,6 +677,12 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
       Unref();
       return false;
     }
+    // Update rcv lowat needs to be called at the end of the current read
+    // operation to ensure the right SO_RCVLOWAT value is set for the next read.
+    // Otherwise the next endpoint read operation may get stuck indefinitely
+    // because the previously set rcv lowat value will persist and the socket
+    // may erroneously considered to not be ready for read.
+    UpdateRcvLowat();
     // Read succeeded immediately. Return true and don't run the on_read
     // callback.
     incoming_buffer_ = nullptr;
@@ -892,7 +913,7 @@ bool PosixEndpointImpl::WriteWithTimestamps(struct msghdr* msg,
   traced_buffers_.AddNewEntry(
       static_cast<uint32_t>(bytes_counter_ + sending_length),
       &poller_->posix_interface(), handle_->WrappedFd(),
-      std::move(outgoing_buffer_write_event_sink_).value());
+      std::move(*outgoing_buffer_write_event_sink_));
   outgoing_buffer_write_event_sink_.reset();
 
   // If there was an error on sendmsg the logic in tcp_flush will handle it.
@@ -940,6 +961,7 @@ void PosixEndpointImpl::UnrefMaybePutZerocopySendRecord(
 void PosixEndpointImpl::TcpShutdownTracedBufferList() {
   if (outgoing_buffer_write_event_sink_.has_value()) {
     traced_buffers_.Shutdown(std::move(outgoing_buffer_write_event_sink_));
+    outgoing_buffer_write_event_sink_.reset();
   }
 }
 
@@ -1031,7 +1053,7 @@ bool PosixEndpointImpl::DoFlushZerocopy(TcpZerocopySendRecord* record,
         record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
         return false;
       } else {
-        status = TcpAnnotateError(PosixOSError(send_status, "sendmsg"));
+        status = PosixOSError(send_status, "sendmsg");
         return true;
       }
     }
@@ -1127,13 +1149,14 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
         }
         return false;
       } else {
-        status = TcpAnnotateError(PosixOSError(send_result, "sendmsg"));
+        status = PosixOSError(send_result, "sendmsg");
         outgoing_buffer_->Clear();
         return true;
       }
     }
 
     GRPC_CHECK_EQ(outgoing_byte_idx_, 0u);
+    GRPC_CHECK_LE((static_cast<size_t>(*send_result)), sending_length);
     bytes_counter_ += *send_result;
     trailing = sending_length - static_cast<size_t>(*send_result);
     while (trailing > 0) {
@@ -1202,7 +1225,7 @@ bool PosixEndpointImpl::Write(
     GRPC_TRACE_LOG(event_engine_endpoint, INFO)
         << "Endpoint[" << this << "]: Write skipped";
     if (handle_->IsHandleShutdown()) {
-      status = TcpAnnotateError(absl::InternalError("EOF"));
+      status = absl::UnavailableError("EOF");
       engine_->Run(
           [on_writable = std::move(on_writable), status, this]() mutable {
             GRPC_TRACE_LOG(event_engine_endpoint, INFO)
@@ -1261,8 +1284,6 @@ void PosixEndpointImpl::MaybeShutdown(
     handle_->SetHasError();
   }
   on_release_fd_ = std::move(on_release_fd);
-  grpc_core::StatusSetInt(&why, grpc_core::StatusIntProperty::kRpcStatus,
-                          GRPC_STATUS_UNAVAILABLE);
   handle_->ShutdownHandle(why);
   read_mu_.Lock();
   memory_owner_.Reset();
@@ -1270,7 +1291,7 @@ void PosixEndpointImpl::MaybeShutdown(
   Unref();
 }
 
-PosixEndpointImpl ::~PosixEndpointImpl() {
+PosixEndpointImpl::~PosixEndpointImpl() {
   FileDescriptor release_fd;
   handle_->OrphanHandle(on_done_,
                         on_release_fd_ == nullptr ? nullptr : &release_fd, "");
@@ -1296,6 +1317,28 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
   FileDescriptor fd = handle_->WrappedFd();
   GRPC_CHECK(options.resource_quota != nullptr);
   auto& posix_interface = poller_->posix_interface();
+  int rcvbuf_size = 0;
+  socklen_t len = sizeof(rcvbuf_size);
+  auto err =
+      posix_interface.GetSockOpt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, &len);
+  if (err.ok()) {
+    rcv_lowat_max_ = rcvbuf_size / 2;
+  } else {
+    rcv_lowat_max_ = 512 * 1024;
+    LOG(ERROR) << "getsockopt(SO_RCVBUF) failed: " << err.StrError()
+               << ", defaulting rcv_lowat_max_ to " << rcv_lowat_max_;
+  }
+  int rcvlowat_default = 0;
+  socklen_t rcvlowat_len = sizeof(rcvlowat_default);
+  auto rcvlowat_err = posix_interface.GetSockOpt(
+      fd, SOL_SOCKET, SO_RCVLOWAT, &rcvlowat_default, &rcvlowat_len);
+  if (rcvlowat_err.ok()) {
+    set_rcvlowat_ = rcvlowat_default;
+  } else {
+    set_rcvlowat_ = 1;
+    LOG(ERROR) << "getsockopt(SO_RCVLOWAT) failed: " << rcvlowat_err.StrError()
+               << ", defaulting set_rcvlowat_ to " << set_rcvlowat_;
+  }
   auto peer_addr_string = posix_interface.PeerAddressString(fd);
   mem_quota_ = options.resource_quota->memory_quota();
   memory_owner_ = mem_quota_->CreateMemoryOwner();
@@ -1312,6 +1355,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
   bytes_read_this_round_ = 0;
   min_read_chunk_size_ = options.tcp_min_read_chunk_size;
   max_read_chunk_size_ = options.tcp_max_read_chunk_size;
+  max_read_buffer_size_ = options.tcp_max_read_buffer_size;
   bool zerocopy_enabled =
       options.tcp_tx_zero_copy_enabled && poller_->CanTrackErrors();
 #ifdef GRPC_LINUX_ERRQUEUE
@@ -1327,7 +1371,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
                  << "ulimit value is not set. Use ulimit -l <value> to set its "
                  << "value.";
     } else {
-      if (posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
+      if (!posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
         zerocopy_enabled = false;
         LOG(ERROR) << "Failed to set zerocopy options on the socket.";
       }

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -214,7 +214,7 @@ class TcpZerocopySendCtx {
   void NoteSend(TcpZerocopySendRecord* record) {
     record->Ref();
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       is_in_write_ = true;
       AssociateSeqWithSendRecordLocked(last_send_, record);
     }
@@ -246,7 +246,7 @@ class TcpZerocopySendCtx {
 
   // Get a send record for a send that we wish to do with zerocopy.
   TcpZerocopySendRecord* GetSendRecord() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return TryGetSendRecordLocked();
   }
 
@@ -260,7 +260,7 @@ class TcpZerocopySendCtx {
   // buffers for this sendmsg()) is received from the kernel - or, in case
   // sendmsg() was unsuccessful to begin with.
   TcpZerocopySendRecord* ReleaseSendRecord(uint32_t seq) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return ReleaseSendRecordLocked(seq);
   }
 
@@ -269,7 +269,7 @@ class TcpZerocopySendCtx {
   // max_sends_ tcp_write() instances with zerocopy enabled in flight at the
   // same time.
   void PutSendRecord(TcpZerocopySendRecord* record) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     GRPC_DCHECK(record >= send_records_ && record < send_records_ + max_sends_);
     PutSendRecordLocked(record);
   }
@@ -281,7 +281,7 @@ class TcpZerocopySendCtx {
   // Indicates that there are no inflight tcp_write() instances with zerocopy
   // enabled.
   bool AllSendRecordsEmpty() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return free_send_records_size_ == max_sends_;
   }
 
@@ -322,7 +322,7 @@ class TcpZerocopySendCtx {
   // Please refer to the STATE TRANSITION DIAGRAM below for more details.
   //
   bool UpdateZeroCopyOptMemStateAfterFree() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (is_in_write_) {
       zcopy_enobuf_state_ = OptMemState::kCheck;
       return false;
@@ -362,7 +362,7 @@ class TcpZerocopySendCtx {
   // Please refer to the STATE TRANSITION DIAGRAM below for more details.
   //
   bool UpdateZeroCopyOptMemStateAfterSend(bool seen_enobuf, bool& constrained) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     is_in_write_ = false;
     constrained = false;
     if (seen_enobuf) {
@@ -517,7 +517,6 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
   bool WriteWithTimestamps(struct msghdr* msg, size_t sending_length,
                            PosixErrorOr<int64_t>* sent_length, int* saved_errno,
                            int additional_flags);
-  absl::Status TcpAnnotateError(absl::Status src_error) const;
 #ifdef GRPC_LINUX_ERRQUEUE
   bool ProcessErrors();
   // Reads a cmsg to process zerocopy control messages.
@@ -531,6 +530,8 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
   double target_length_;
   int min_read_chunk_size_;
   int max_read_chunk_size_;
+  int rcv_lowat_max_;
+  int max_read_buffer_size_;
   int64_t set_rcvlowat_ = 0;
   double bytes_read_this_round_ = 0;
 
@@ -637,15 +638,14 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
   void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
                     on_release_fd) override {
     if (!shutdown_.exchange(true, std::memory_order_acq_rel)) {
-      impl_->MaybeShutdown(absl::FailedPreconditionError("Endpoint closing"),
+      impl_->MaybeShutdown(absl::UnavailableError("Endpoint closing"),
                            std::move(on_release_fd));
     }
   }
 
   ~PosixEndpoint() override {
     if (!shutdown_.exchange(true, std::memory_order_acq_rel)) {
-      impl_->MaybeShutdown(absl::FailedPreconditionError("Endpoint closing"),
-                           nullptr);
+      impl_->MaybeShutdown(absl::UnavailableError("Endpoint closing"), nullptr);
     }
   }