grpc 1.51.0 → 1.52.0.pre2

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

@@ -28,10 +28,10 @@
 #ifdef GRPC_LINUX_ERRQUEUE
 #include <linux/errqueue.h>  // IWYU pragma: keep
 #include <sys/socket.h>
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_LINUX_ERRQUEUE
 
@@ -72,31 +72,31 @@ constexpr uint32_t kTimestampingRecordingOptions =
 // Netlink attribute types used for TCP opt stats.
 enum TCPOptStats {
   TCP_NLA_PAD,
-  TCP_NLA_BUSY,           /* Time (usec) busy sending data. */
-  TCP_NLA_RWND_LIMITED,   /* Time (usec) limited by receive window. */
-  TCP_NLA_SNDBUF_LIMITED, /* Time (usec) limited by send buffer. */
-  TCP_NLA_DATA_SEGS_OUT,  /* Data pkts sent including retransmission. */
-  TCP_NLA_TOTAL_RETRANS,  /* Data pkts retransmitted. */
-  TCP_NLA_PACING_RATE,    /* Pacing rate in Bps. */
-  TCP_NLA_DELIVERY_RATE,  /* Delivery rate in Bps. */
-  TCP_NLA_SND_CWND,       /* Sending congestion window. */
-  TCP_NLA_REORDERING,     /* Reordering metric. */
-  TCP_NLA_MIN_RTT,        /* minimum RTT. */
-  TCP_NLA_RECUR_RETRANS,  /* Recurring retransmits for the current pkt. */
-  TCP_NLA_DELIVERY_RATE_APP_LMT, /* Delivery rate application limited? */
-  TCP_NLA_SNDQ_SIZE,             /* Data (bytes) pending in send queue */
-  TCP_NLA_CA_STATE,              /* ca_state of socket */
-  TCP_NLA_SND_SSTHRESH,          /* Slow start size threshold */
-  TCP_NLA_DELIVERED,             /* Data pkts delivered incl. out-of-order */
-  TCP_NLA_DELIVERED_CE,          /* Like above but only ones w/ CE marks */
-  TCP_NLA_BYTES_SENT,            /* Data bytes sent including retransmission */
-  TCP_NLA_BYTES_RETRANS,         /* Data bytes retransmitted */
-  TCP_NLA_DSACK_DUPS,            /* DSACK blocks received */
-  TCP_NLA_REORD_SEEN,            /* reordering events seen */
-  TCP_NLA_SRTT,                  /* smoothed RTT in usecs */
+  TCP_NLA_BUSY,                   // Time (usec) busy sending data.
+  TCP_NLA_RWND_LIMITED,           // Time (usec) limited by receive window.
+  TCP_NLA_SNDBUF_LIMITED,         // Time (usec) limited by send buffer.
+  TCP_NLA_DATA_SEGS_OUT,          // Data pkts sent including retransmission.
+  TCP_NLA_TOTAL_RETRANS,          // Data pkts retransmitted.
+  TCP_NLA_PACING_RATE,            // Pacing rate in Bps.
+  TCP_NLA_DELIVERY_RATE,          // Delivery rate in Bps.
+  TCP_NLA_SND_CWND,               // Sending congestion window.
+  TCP_NLA_REORDERING,             // Reordering metric.
+  TCP_NLA_MIN_RTT,                // minimum RTT.
+  TCP_NLA_RECUR_RETRANS,          // Recurring retransmits for the current pkt.
+  TCP_NLA_DELIVERY_RATE_APP_LMT,  // Delivery rate application limited?
+  TCP_NLA_SNDQ_SIZE,              // Data (bytes) pending in send queue
+  TCP_NLA_CA_STATE,               // ca_state of socket
+  TCP_NLA_SND_SSTHRESH,           // Slow start size threshold
+  TCP_NLA_DELIVERED,              // Data pkts delivered incl. out-of-order
+  TCP_NLA_DELIVERED_CE,           // Like above but only ones w/ CE marks
+  TCP_NLA_BYTES_SENT,             // Data bytes sent including retransmission
+  TCP_NLA_BYTES_RETRANS,          // Data bytes retransmitted
+  TCP_NLA_DSACK_DUPS,             // DSACK blocks received
+  TCP_NLA_REORD_SEEN,             // reordering events seen
+  TCP_NLA_SRTT,                   // smoothed RTT in usecs
 };
 
-/* tcp_info from from linux/tcp.h */
+// tcp_info from from linux/tcp.h
 struct tcp_info {
   uint8_t tcpi_state;
   uint8_t tcpi_ca_state;
@@ -115,12 +115,12 @@ struct tcp_info {
   uint32_t tcpi_lost;
   uint32_t tcpi_retrans;
   uint32_t tcpi_fackets;
-  /* Times. */
+  // Times.
   uint32_t tcpi_last_data_sent;
-  uint32_t tcpi_last_ack_sent; /* Not remembered, sorry. */
+  uint32_t tcpi_last_ack_sent;  // Not remembered, sorry.
   uint32_t tcpi_last_data_recv;
   uint32_t tcpi_last_ack_recv;
-  /* Metrics. */
+  // Metrics.
   uint32_t tcpi_pmtu;
   uint32_t tcpi_rcv_ssthresh;
   uint32_t tcpi_rtt;
@@ -134,29 +134,29 @@ struct tcp_info {
   uint32_t tcpi_total_retrans;
   uint64_t tcpi_pacing_rate;
   uint64_t tcpi_max_pacing_rate;
-  uint64_t tcpi_bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
-  uint64_t tcpi_bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived */
+  uint64_t tcpi_bytes_acked;     // RFC4898 tcpEStatsAppHCThruOctetsAcked
+  uint64_t tcpi_bytes_received;  // RFC4898 tcpEStatsAppHCThruOctetsReceived
 
-  uint32_t tcpi_segs_out; /* RFC4898 tcpEStatsPerfSegsOut */
-  uint32_t tcpi_segs_in;  /* RFC4898 tcpEStatsPerfSegsIn */
+  uint32_t tcpi_segs_out;  // RFC4898 tcpEStatsPerfSegsOut
+  uint32_t tcpi_segs_in;   // RFC4898 tcpEStatsPerfSegsIn
   uint32_t tcpi_notsent_bytes;
   uint32_t tcpi_min_rtt;
 
-  uint32_t tcpi_data_segs_in;  /* RFC4898 tcpEStatsDataSegsIn */
-  uint32_t tcpi_data_segs_out; /* RFC4898 tcpEStatsDataSegsOut */
+  uint32_t tcpi_data_segs_in;   // RFC4898 tcpEStatsDataSegsIn
+  uint32_t tcpi_data_segs_out;  // RFC4898 tcpEStatsDataSegsOut
 
   uint64_t tcpi_delivery_rate;
-  uint64_t tcpi_busy_time;      /* Time (usec) busy sending data */
-  uint64_t tcpi_rwnd_limited;   /* Time (usec) limited by receive window */
-  uint64_t tcpi_sndbuf_limited; /* Time (usec) limited by send buffer */
+  uint64_t tcpi_busy_time;       // Time (usec) busy sending data
+  uint64_t tcpi_rwnd_limited;    // Time (usec) limited by receive window
+  uint64_t tcpi_sndbuf_limited;  // Time (usec) limited by send buffer
 
   uint32_t tcpi_delivered;
   uint32_t tcpi_delivered_ce;
-  uint64_t tcpi_bytes_sent;    /* RFC4898 tcpEStatsPerfHCDataOctetsOut */
-  uint64_t tcpi_bytes_retrans; /* RFC4898 tcpEStatsPerfOctetsRetrans */
-  uint32_t tcpi_dsack_dups;    /* RFC4898 tcpEStatsStackDSACKDups */
-  uint32_t tcpi_reord_seen;    /* reordering events seen */
-  socklen_t length;            /* Length of struct returned by kernel */
+  uint64_t tcpi_bytes_sent;     // RFC4898 tcpEStatsPerfHCDataOctetsOut
+  uint64_t tcpi_bytes_retrans;  // RFC4898 tcpEStatsPerfOctetsRetrans
+  uint32_t tcpi_dsack_dups;     // RFC4898 tcpEStatsStackDSACKDups
+  uint32_t tcpi_reord_seen;     // reordering events seen
+  socklen_t length;             // Length of struct returned by kernel
 };
 
 #ifndef TCP_INFO
@@ -165,15 +165,15 @@ struct tcp_info {
 
 int GetSocketTcpInfo(tcp_info* info, int fd);
 
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
 
 // Returns true if kernel is capable of supporting errqueue and timestamping.
 // Currently allowing only linux kernels above 4.0.0
 bool KernelSupportsErrqueue();
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H */
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H

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

@@ -15,8 +15,6 @@
 
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 
-#include <stdlib.h>
-
 #include <atomic>
 #include <cstdint>
 
@@ -27,6 +25,7 @@
 
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/status_helper.h"
 
 //  'state' holds the to call when the fd is readable or writable respectively.
@@ -61,7 +60,7 @@
 //     For 5,6,7: See SetShutdown() function
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 void LockfreeEvent::InitEvent() {
   // Perform an atomic store to start the state machine.
@@ -86,7 +85,7 @@ void LockfreeEvent::DestroyEvent() {
     // with post-deletion (see the note in the constructor) we want the bit
     // pattern to prevent error retention in a deleted object
   } while (!state_.compare_exchange_strong(curr, kShutdownBit,
-                                           std::memory_order_relaxed,
+                                           std::memory_order_acq_rel,
                                            std::memory_order_relaxed));
 }
 
@@ -111,7 +110,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         // barrier.
         if (state_.compare_exchange_strong(
                 curr, reinterpret_cast<intptr_t>(closure),
-                std::memory_order_release, std::memory_order_relaxed)) {
+                std::memory_order_acq_rel, std::memory_order_relaxed)) {
           return;  // Successful. Return
         }
 
@@ -128,7 +127,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         // closure when transitioning out of CLOSURE_NO_READY state (i.e there
         // is no other code that needs to 'happen-after' this)
         if (state_.compare_exchange_strong(curr, kClosureNotReady,
-                                           std::memory_order_relaxed,
+                                           std::memory_order_acq_rel,
                                            std::memory_order_relaxed)) {
           scheduler_->Run(closure);
           return;  // Successful. Return.
@@ -149,10 +148,9 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         }
 
         // There is already a closure!. This indicates a bug in the code.
-        gpr_log(GPR_ERROR,
-                "LockfreeEvent::NotifyOn: notify_on called with a previous "
-                "callback still pending");
-        abort();
+        grpc_core::Crash(
+            "LockfreeEvent::NotifyOn: notify_on called with a previous "
+            "callback still pending");
       }
     }
   }
@@ -230,7 +228,7 @@ void LockfreeEvent::SetReady() {
         // No barrier required as we're transitioning to a state that does not
         // involve a closure
         if (state_.compare_exchange_strong(curr, kClosureReady,
-                                           std::memory_order_relaxed,
+                                           std::memory_order_acq_rel,
                                            std::memory_order_relaxed)) {
           return;  // early out
         }
@@ -263,5 +261,5 @@ void LockfreeEvent::SetReady() {
   }
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -24,7 +24,7 @@
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class Scheduler;
 
@@ -67,7 +67,7 @@ class LockfreeEvent {
   Scheduler* scheduler_;
 };
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H

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

@@ -23,9 +23,9 @@
 #include <cctype>
 #include <cstdint>
 #include <cstdlib>
-#include <cstring>
 #include <memory>
 #include <string>
+#include <type_traits>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
@@ -33,18 +33,22 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/internal/slice_cast.h>
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/event_engine/slice.h>
 #include <grpc/event_engine/slice_buffer.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -88,15 +92,10 @@
 #define MAX_READ_IOVEC 64
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 namespace {
 
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::MemoryAllocator;
-using ::grpc_event_engine::experimental::Slice;
-using ::grpc_event_engine::experimental::SliceBuffer;
-
 // A wrapper around sendmsg. It sends \a msg over \a fd and returns the number
 // of bytes sent.
 ssize_t TcpSend(int fd, const struct msghdr* msg, int* saved_errno,
@@ -210,6 +209,16 @@ bool CmsgIsZeroCopy(const cmsghdr& cmsg) {
 }
 #endif  // GRPC_LINUX_ERRQUEUE
 
+absl::Status PosixOSError(int error_no, const char* call_name) {
+  absl::Status s = absl::UnknownError(grpc_core::StrError(error_no));
+  grpc_core::StatusSetInt(&s, grpc_core::StatusIntProperty::kErrorNo, error_no);
+  grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError,
+                          grpc_core::StrError(error_no));
+  grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall,
+                          call_name);
+  return s;
+}
+
 }  // namespace
 
 #if defined(IOV_MAX) && IOV_MAX < 260
@@ -227,9 +236,9 @@ msg_iovlen_type TcpZerocopySendRecord::PopulateIovs(size_t* unwind_slice_idx,
   for (iov_size = 0;
        out_offset_.slice_idx != buf_.Count() && iov_size != MAX_WRITE_IOVEC;
        iov_size++) {
-    auto slice = buf_.RefSlice(out_offset_.slice_idx);
-    iov[iov_size].iov_base =
-        const_cast<uint8_t*>(slice.begin()) + out_offset_.byte_idx;
+    MutableSlice& slice = internal::SliceCast<MutableSlice>(
+        buf_.MutableSliceAt(out_offset_.slice_idx));
+    iov[iov_size].iov_base = slice.begin();
     iov[iov_size].iov_len = slice.length() - out_offset_.byte_idx;
     *sending_length += iov[iov_size].iov_len;
     ++(out_offset_.slice_idx);
@@ -270,6 +279,19 @@ void PosixEndpointImpl::FinishEstimate() {
   bytes_read_this_round_ = 0;
 }
 
+absl::Status PosixEndpointImpl::TcpAnnotateError(absl::Status src_error) {
+  auto peer_string = ResolvedAddressToNormalizedString(peer_address_);
+
+  grpc_core::StatusSetStr(&src_error,
+                          grpc_core::StatusStrProperty::kTargetAddress,
+                          peer_string.ok() ? *peer_string : "");
+  grpc_core::StatusSetInt(&src_error, grpc_core::StatusIntProperty::kFd,
+                          handle_->WrappedFd());
+  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) {
   struct msghdr msg;
@@ -285,8 +307,9 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
 #endif  // GRPC_LINUX_ERRQUEUE
   char cmsgbuf[cmsg_alloc_space];
   for (size_t i = 0; i < iov_len; i++) {
-    Slice slice = incoming_buffer_->RefSlice(i);
-    iov[i].iov_base = const_cast<uint8_t*>(slice.begin());
+    MutableSlice& slice =
+        internal::SliceCast<MutableSlice>(incoming_buffer_->MutableSliceAt(i));
+    iov[i].iov_base = slice.begin();
     iov[i].iov_len = slice.length();
   }
 
@@ -338,10 +361,10 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       // 0 read size ==> end of stream
       incoming_buffer_->Clear();
       if (read_bytes == 0) {
-        status = absl::InternalError("Socket closed");
+        status = TcpAnnotateError(absl::InternalError("Socket closed"));
       } else {
-        status = absl::InternalError(
-            absl::StrCat("recvmsg:", grpc_core::StrError(errno)));
+        status = TcpAnnotateError(absl::InternalError(
+            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
       }
       return true;
     }
@@ -426,7 +449,6 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
   if (total_read_bytes < incoming_buffer_->Length()) {
     incoming_buffer_->MoveLastNBytesIntoSliceBuffer(
         incoming_buffer_->Length() - total_read_bytes, last_read_buffer_);
-    // last_read_buffer_.Clear();
   }
   return true;
 }
@@ -551,6 +573,7 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
   if (status.ok()) {
     MaybeMakeReadSlices();
     if (!TcpDoRead(status)) {
+      UpdateRcvLowat();
       // We've consumed the edge, request a new one.
       read_mu_.Unlock();
       handle_->NotifyOnRead(on_read_);
@@ -571,29 +594,33 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
 void PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                              SliceBuffer* buffer,
                              const EventEngine::Endpoint::ReadArgs* args) {
-  read_mu_.Lock();
+  grpc_core::ReleasableMutexLock lock(&read_mu_);
   GPR_ASSERT(read_cb_ == nullptr);
   read_cb_ = std::move(on_read);
   incoming_buffer_ = buffer;
   incoming_buffer_->Clear();
   incoming_buffer_->Swap(last_read_buffer_);
-  read_mu_.Unlock();
   if (args != nullptr && grpc_core::IsTcpFrameSizeTuningEnabled()) {
-    min_progress_size_ = args->read_hint_bytes;
+    min_progress_size_ = std::max(static_cast<int>(args->read_hint_bytes), 1);
   } else {
     min_progress_size_ = 1;
   }
   Ref().release();
   if (is_first_read_) {
+    UpdateRcvLowat();
     // Endpoint read called for the very first time. Register read callback
     // with the polling engine.
     is_first_read_ = false;
+    lock.Release();
     handle_->NotifyOnRead(on_read_);
   } else if (inq_ == 0) {
+    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.
     handle_->NotifyOnRead(on_read_);
   } else {
+    lock.Release();
     on_read_->SetStatus(absl::OkStatus());
     engine_->Run(on_read_);
   }
@@ -829,7 +856,7 @@ TcpZerocopySendRecord* PosixEndpointImpl::TcpGetSendZerocopyRecord(
 }
 
 void PosixEndpointImpl::HandleError(absl::Status /*status*/) {
-  GPR_ASSERT(false && "Error handling not supported on this platform");
+  grpc_core::Crash("Error handling not supported on this platform");
 }
 
 void PosixEndpointImpl::ZerocopyDisableAndWaitForRemaining() {}
@@ -839,7 +866,7 @@ bool PosixEndpointImpl::WriteWithTimestamps(struct msghdr* /*msg*/,
                                             ssize_t* /*sent_length*/,
                                             int* /*saved_errno*/,
                                             int /*additional_flags*/) {
-  GPR_ASSERT(false && "Write with timestamps not supported for this platform");
+  grpc_core::Crash("Write with timestamps not supported for this platform");
 }
 #endif  // GRPC_LINUX_ERRQUEUE
 
@@ -944,8 +971,7 @@ bool PosixEndpointImpl::DoFlushZerocopy(TcpZerocopySendRecord* record,
         record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
         return false;
       } else {
-        status = absl::InternalError(
-            absl::StrCat("sendmsg", std::strerror(saved_errno)));
+        status = TcpAnnotateError(PosixOSError(saved_errno, "sendmsg"));
         TcpShutdownTracedBufferList();
         return true;
       }
@@ -993,10 +1019,11 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
     for (iov_size = 0; outgoing_slice_idx != outgoing_buffer_->Count() &&
                        iov_size != MAX_WRITE_IOVEC;
          iov_size++) {
-      auto slice = outgoing_buffer_->RefSlice(outgoing_slice_idx);
-      iov[iov_size].iov_base =
-          const_cast<uint8_t*>(slice.begin()) + outgoing_byte_idx_;
+      MutableSlice& slice = internal::SliceCast<MutableSlice>(
+          outgoing_buffer_->MutableSliceAt(outgoing_slice_idx));
+      iov[iov_size].iov_base = slice.begin() + outgoing_byte_idx_;
       iov[iov_size].iov_len = slice.length() - outgoing_byte_idx_;
+
       sending_length += iov[iov_size].iov_len;
       outgoing_slice_idx++;
       outgoing_byte_idx_ = 0;
@@ -1037,8 +1064,7 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
         }
         return false;
       } else {
-        status = absl::InternalError(
-            absl::StrCat("sendmsg", std::strerror(saved_errno)));
+        status = TcpAnnotateError(PosixOSError(saved_errno, "sendmsg"));
         outgoing_buffer_->Clear();
         TcpShutdownTracedBufferList();
         return true;
@@ -1104,8 +1130,9 @@ void PosixEndpointImpl::Write(
   GPR_DEBUG_ASSERT(data != nullptr);
 
   if (data->Length() == 0) {
-    on_writable(handle_->IsHandleShutdown() ? absl::InternalError("EOF")
-                                            : status);
+    on_writable(handle_->IsHandleShutdown()
+                    ? TcpAnnotateError(absl::InternalError("EOF"))
+                    : status);
     TcpShutdownTracedBufferList();
     return;
   }
@@ -1132,7 +1159,12 @@ void PosixEndpointImpl::Write(
     current_zerocopy_send_ = zerocopy_send_record;
     handle_->NotifyOnWrite(on_write_);
   } else {
-    on_writable(status);
+    // TODO(vigneshbabu): Consider eventually running this callback inline to
+    // avoid a thread hop. At the time of submission, it causes deadlocks which
+    // should be reolved after ExecCtx removal.
+    engine_->Run([on_writable = std::move(on_writable), status]() mutable {
+      on_writable(status);
+    });
   }
 }
 
@@ -1142,6 +1174,8 @@ void PosixEndpointImpl::MaybeShutdown(absl::Status why) {
     stop_error_notification_.store(true, std::memory_order_release);
     handle_->SetHasError();
   }
+  grpc_core::StatusSetInt(&why, grpc_core::StatusIntProperty::kRpcStatus,
+                          GRPC_STATUS_UNAVAILABLE);
   handle_->ShutdownHandle(why);
   Unref();
 }
@@ -1167,11 +1201,18 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
   PosixSocketWrapper sock(handle->WrappedFd());
   fd_ = handle_->WrappedFd();
   GPR_ASSERT(options.resource_quota != nullptr);
+  auto peer_addr_string = sock.PeerAddressString();
   memory_owner_ = options.resource_quota->memory_quota()->CreateMemoryOwner(
-      *sock.PeerAddressString());
+      peer_addr_string.ok() ? *peer_addr_string : "");
   self_reservation_ = memory_owner_.MakeReservation(sizeof(PosixEndpointImpl));
-  local_address_ = *sock.LocalAddress();
-  peer_address_ = *sock.PeerAddress();
+  auto local_address = sock.LocalAddress();
+  if (local_address.ok()) {
+    local_address_ = *local_address;
+  }
+  auto peer_address = sock.PeerAddress();
+  if (peer_address.ok()) {
+    peer_address_ = *peer_address;
+  }
   target_length_ = static_cast<double>(options.tcp_read_chunk_size);
   bytes_read_this_round_ = 0;
   min_read_chunk_size_ = options.tcp_min_read_chunk_size;
@@ -1246,25 +1287,22 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
                                          std::move(allocator), options);
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
 namespace grpc_event_engine {
-namespace posix_engine {
-
-using ::grpc_event_engine::experimental::EndpointConfig;
-using ::grpc_event_engine::experimental::EventEngine;
+namespace experimental {
 
 std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     EventHandle* /*handle*/, PosixEngineClosure* /*on_shutdown*/,
     std::shared_ptr<EventEngine> /*engine*/,
     const PosixTcpOptions& /*options*/) {
-  GPR_ASSERT(false && "Cannot create PosixEndpoint on this platform");
+  grpc_core::Crash("Cannot create PosixEndpoint on this platform");
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_POSIX_SOCKET_TCP

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

@@ -42,6 +42,7 @@
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/posix_engine/traced_buffer_list.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
@@ -61,7 +62,7 @@ typedef size_t msg_iovlen_type;
 #endif  //  GRPC_POSIX_SOCKET_TCP
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
@@ -344,7 +345,7 @@ class TcpZerocopySendCtx {
       // state was CHECK and is_in_write is false. This means that after the
       // previous sendmsg returned and set is_in_write to false, it did
       // not update the z-copy change from CHECK to OPEN.
-      GPR_ASSERT(false && "OMem state error!");
+      grpc_core::Crash("OMem state error!");
     }
   }
 
@@ -513,6 +514,7 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
   bool WriteWithTimestamps(struct msghdr* msg, size_t sending_length,
                            ssize_t* sent_length, int* saved_errno,
                            int additional_flags);
+  absl::Status TcpAnnotateError(absl::Status src_error);
 #ifdef GRPC_LINUX_ERRQUEUE
   bool ProcessErrors();
   // Reads a cmsg to process zerocopy control messages.
@@ -640,25 +642,25 @@ class PosixEndpoint
             grpc_event_engine::experimental::SliceBuffer* /*buffer*/,
             const grpc_event_engine::experimental::EventEngine::Endpoint::
                 ReadArgs* /*args*/) override {
-    GPR_ASSERT(false && "PosixEndpoint::Read not supported on this platform");
+    grpc_core::Crash("PosixEndpoint::Read not supported on this platform");
   }
 
   void Write(absl::AnyInvocable<void(absl::Status)> /*on_writable*/,
              grpc_event_engine::experimental::SliceBuffer* /*data*/,
              const grpc_event_engine::experimental::EventEngine::Endpoint::
                  WriteArgs* /*args*/) override {
-    GPR_ASSERT(false && "PosixEndpoint::Write not supported on this platform");
+    grpc_core::Crash("PosixEndpoint::Write not supported on this platform");
   }
 
   const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
   GetPeerAddress() const override {
-    GPR_ASSERT(false &&
-               "PosixEndpoint::GetPeerAddress not supported on this platform");
+    grpc_core::Crash(
+        "PosixEndpoint::GetPeerAddress not supported on this platform");
   }
   const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
   GetLocalAddress() const override {
-    GPR_ASSERT(false &&
-               "PosixEndpoint::GetLocalAddress not supported on this platform");
+    grpc_core::Crash(
+        "PosixEndpoint::GetLocalAddress not supported on this platform");
   }
 
   ~PosixEndpoint() override = default;
@@ -676,7 +678,7 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     grpc_event_engine::experimental::MemoryAllocator&& allocator,
     const PosixTcpOptions& options);
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENDPOINT_H