grpc 1.56.2 → 1.58.0

data/src/core/lib/iomgr/error.h

@@ -46,8 +46,7 @@ typedef absl::Status grpc_error_handle;
 
 absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
                                 const grpc_core::DebugLocation& location,
-                                size_t children_count,
-                                absl::Status* children) GRPC_MUST_USE_RESULT;
+                                size_t children_count, absl::Status* children);
 
 // Create an error that references some other errors.
 #define GRPC_ERROR_CREATE_REFERENCING(desc, errs, count)                      \
@@ -73,7 +72,7 @@ static absl::Status grpc_status_create_from_vector(
   grpc_status_create_from_vector(DEBUG_LOCATION, desc, error_list)
 
 absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
-                           const char* call_name) GRPC_MUST_USE_RESULT;
+                           const char* call_name);
 
 inline absl::Status grpc_assert_never_ok(absl::Status error) {
   GPR_ASSERT(!error.ok());
@@ -85,7 +84,7 @@ inline absl::Status grpc_assert_never_ok(absl::Status error) {
   grpc_assert_never_ok(grpc_os_error(DEBUG_LOCATION, err, call_name))
 
 absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
-                            absl::string_view call_name) GRPC_MUST_USE_RESULT;
+                            absl::string_view call_name);
 
 /// windows only: create an error associated with WSAGetLastError()!=0
 #define GRPC_WSA_ERROR(err, call_name) \
@@ -93,14 +92,14 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_core::StatusIntProperty which,
-                                     intptr_t value) GRPC_MUST_USE_RESULT;
+                                     intptr_t value);
 /// It is an error to pass nullptr as `p`. Caller should allocate a phony
 /// intptr_t for `p`, even if the value of `p` is not used.
 bool grpc_error_get_int(grpc_error_handle error,
                         grpc_core::StatusIntProperty which, intptr_t* p);
-grpc_error_handle grpc_error_set_str(
-    grpc_error_handle src, grpc_core::StatusStrProperty which,
-    absl::string_view str) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_error_set_str(grpc_error_handle src,
+                                     grpc_core::StatusStrProperty which,
+                                     absl::string_view str);
 /// Returns false if the specified string is not set.
 bool grpc_error_get_str(grpc_error_handle error,
                         grpc_core::StatusStrProperty which, std::string* str);
@@ -116,8 +115,8 @@ bool grpc_error_get_str(grpc_error_handle error,
 /// returns absl::OkStatus(). 3) If \a src and \a child point to the same error,
 /// returns a single reference. (Note that, 2 references should have been
 /// received to the error in this case.)
-grpc_error_handle grpc_error_add_child(
-    grpc_error_handle src, grpc_error_handle child) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_error_add_child(grpc_error_handle src,
+                                       grpc_error_handle child);
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line);

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -1236,10 +1236,6 @@ static void shutdown_engine(void) {
   fd_global_shutdown();
   pollset_global_shutdown();
   epoll_set_shutdown();
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_destroy(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
-  }
   g_is_shutdown = true;
 }
 
@@ -1296,6 +1292,7 @@ const grpc_event_engine_vtable grpc_ev_epoll1_posix = {
 // the global epoll fd. This allows gRPC to shutdown in the child process
 // without interfering with connections or RPCs ongoing in the parent.
 static void reset_event_manager_on_fork() {
+  if (g_is_shutdown) return;
   gpr_mu_lock(&fork_fd_list_mu);
   while (fork_fd_list_head != nullptr) {
     close(fork_fd_list_head->fd);
@@ -1330,9 +1327,10 @@ static bool init_epoll1_linux() {
   }
 
   if (grpc_core::Fork::Enabled()) {
-    gpr_mu_init(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(
-        reset_event_manager_on_fork);
+    if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+            reset_event_manager_on_fork)) {
+      gpr_mu_init(&fork_fd_list_mu);
+    }
   }
   g_is_shutdown = false;
   return true;

data/src/core/lib/iomgr/ev_poll_posix.cc

@@ -235,7 +235,7 @@ static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline);
 // -- mostly for fd_posix's use.
 static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
                                           grpc_pollset_worker* specific_worker,
-                                          uint32_t flags) GRPC_MUST_USE_RESULT;
+                                          uint32_t flags);
 
 // Return 1 if the pollset has active threads in pollset_work (pollset must
 // be locked)
@@ -1404,10 +1404,11 @@ const grpc_event_engine_vtable grpc_ev_poll_posix = {
         return false;
       }
       if (grpc_core::Fork::Enabled()) {
-        track_fds_for_fork = true;
-        gpr_mu_init(&fork_fd_list_mu);
-        grpc_core::Fork::SetResetChildPollingEngineFunc(
-            reset_event_manager_on_fork);
+        if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+                reset_event_manager_on_fork)) {
+          track_fds_for_fork = true;
+          gpr_mu_init(&fork_fd_list_mu);
+        }
       }
       return true;
     },

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -74,15 +74,9 @@ class EventEngineEndpointWrapper {
     return fd_;
   }
 
-  absl::string_view PeerAddress() {
-    grpc_core::MutexLock lock(&mu_);
-    return peer_address_;
-  }
+  absl::string_view PeerAddress() { return peer_address_; }
 
-  absl::string_view LocalAddress() {
-    grpc_core::MutexLock lock(&mu_);
-    return local_address_;
-  }
+  absl::string_view LocalAddress() { return local_address_; }
 
   void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
   void Unref() {
@@ -119,8 +113,7 @@ class EventEngineEndpointWrapper {
     read_buffer->~SliceBuffer();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       size_t i;
-      gpr_log(GPR_INFO, "TCP: %p READ (peer=%s) error=%s", eeep_->wrapper,
-              std::string(eeep_->wrapper->PeerAddress()).c_str(),
+      gpr_log(GPR_INFO, "TCP: %p READ error=%s", eeep_->wrapper,
               status.ToString().c_str());
       if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
         for (i = 0; i < pending_read_buffer_->count; i++) {
@@ -270,8 +263,6 @@ class EventEngineEndpointWrapper {
     {
       grpc_core::MutexLock lock(&mu_);
       fd_ = -1;
-      local_address_ = "";
-      peer_address_ = "";
     }
     endpoint_.reset();
     // For the Ref taken in TriggerShutdown
@@ -286,8 +277,10 @@ class EventEngineEndpointWrapper {
   grpc_closure* pending_read_cb_;
   grpc_closure* pending_write_cb_;
   grpc_slice_buffer* pending_read_buffer_;
-  std::string peer_address_;
-  std::string local_address_;
+  const std::string peer_address_{
+      ResolvedAddressToURI(endpoint_->GetPeerAddress()).value_or("")};
+  const std::string local_address_{
+      ResolvedAddressToURI(endpoint_->GetLocalAddress()).value_or("")};
   int fd_{-1};
 };
 
@@ -413,14 +406,6 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
       eeep_(std::make_unique<grpc_event_engine_endpoint>()) {
   eeep_->base.vtable = &grpc_event_engine_endpoint_vtable;
   eeep_->wrapper = this;
-  auto local_addr = ResolvedAddressToURI(endpoint_->GetLocalAddress());
-  if (local_addr.ok()) {
-    local_address_ = *local_addr;
-  }
-  auto peer_addr = ResolvedAddressToURI(endpoint_->GetPeerAddress());
-  if (peer_addr.ok()) {
-    peer_address_ = *peer_addr;
-  }
   if (EventEngineSupportsFd()) {
     fd_ = reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
               ->GetWrappedFd();

data/src/core/lib/iomgr/exec_ctx.h

@@ -329,6 +329,17 @@ class ApplicationCallbackExecCtx {
   static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
 };
 
+template <typename F>
+void EnsureRunInExecCtx(F f) {
+  if (ExecCtx::Get() == nullptr) {
+    ApplicationCallbackExecCtx app_ctx;
+    ExecCtx exec_ctx;
+    f();
+  } else {
+    f();
+  }
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H

data/src/core/lib/iomgr/pollset.h

@@ -86,14 +86,13 @@ void grpc_pollset_destroy(grpc_pollset* pollset);
 // May call grpc_closure_list_run on grpc_closure_list, without holding the
 // pollset
 // lock
-grpc_error_handle grpc_pollset_work(
-    grpc_pollset* pollset, grpc_pollset_worker** worker,
-    grpc_core::Timestamp deadline) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
+                                    grpc_pollset_worker** worker,
+                                    grpc_core::Timestamp deadline);
 
 // Break one polling thread out of polling work for this pollset.
 // If specific_worker is non-NULL, then kick that worker.
 grpc_error_handle grpc_pollset_kick(grpc_pollset* pollset,
-                                    grpc_pollset_worker* specific_worker)
-    GRPC_MUST_USE_RESULT;
+                                    grpc_pollset_worker* specific_worker);
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_POLLSET_H

data/src/core/lib/iomgr/port.h

@@ -37,6 +37,11 @@
 #define GRPC_HAVE_IP_PKTINFO 1
 #define GRPC_HAVE_MSG_NOSIGNAL 1
 #define GRPC_HAVE_UNIX_SOCKET 1
+#if defined(LINUX_VERSION_CODE) && defined(__GLIBC_PREREQ)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0) && __GLIBC_PREREQ(2, 18)
+#define GRPC_HAVE_VSOCK 1
+#endif
+#endif
 #define GRPC_LINUX_EVENTFD 1
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
@@ -56,6 +61,11 @@
 #define GRPC_LINUX_ERRQUEUE 1
 #endif  // LINUX_VERSION_CODE >= KERNEL_VERSION(4, 0, 0)
 #endif  // LINUX_VERSION_CODE
+#if defined(LINUX_VERSION_CODE) && defined(__GLIBC_PREREQ)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0) && __GLIBC_PREREQ(2, 18)
+#define GRPC_HAVE_VSOCK 1
+#endif
+#endif
 #define GRPC_LINUX_MULTIPOLL_WITH_EPOLL 1
 #define GRPC_POSIX_FORK 1
 #define GRPC_POSIX_HOST_NAME_MAX 1

data/src/core/lib/iomgr/resolve_address.cc

@@ -35,7 +35,9 @@ namespace {
 NoDestruct<std::shared_ptr<DNSResolver>> g_dns_resolver;
 }
 
-constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
+const DNSResolver::LookupTaskHandle DNSResolver::LookupTaskHandle::kInvalid = {
+    -1, -1};
+const DNSResolver::TaskHandle DNSResolver::kNullHandle = {0, 0};
 
 void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
   *g_dns_resolver = std::move(resolver);
@@ -43,6 +45,16 @@ void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
 
 std::shared_ptr<DNSResolver> GetDNSResolver() { return *g_dns_resolver; }
 
+bool operator==(const DNSResolver::LookupTaskHandle& lhs,
+                const DNSResolver::LookupTaskHandle& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+
+bool operator!=(const DNSResolver::LookupTaskHandle& lhs,
+                const DNSResolver::LookupTaskHandle& rhs) {
+  return !(lhs == rhs);
+}
+
 std::string DNSResolver::HandleToString(TaskHandle handle) {
   return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
 }

data/src/core/lib/iomgr/resolve_address.h

@@ -23,10 +23,12 @@
 
 #include <stddef.h>
 
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/statusor.h"
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -43,9 +45,21 @@ constexpr Duration kDefaultDNSRequestTimeout = Duration::Minutes(2);
 // A singleton class used for async and blocking DNS resolution
 class DNSResolver {
  public:
-  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::
-      DNSResolver::LookupTaskHandle;
-  static constexpr TaskHandle kNullHandle{0, 0};
+  /// Task handle for DNS Resolution requests.
+  struct LookupTaskHandle {
+    intptr_t keys[2];
+    static const LookupTaskHandle kInvalid;
+    friend bool operator==(const LookupTaskHandle& lhs,
+                           const LookupTaskHandle& rhs);
+    friend bool operator!=(const LookupTaskHandle& lhs,
+                           const LookupTaskHandle& rhs);
+  };
+  using TaskHandle = LookupTaskHandle;
+  using TaskHandleSet = absl::flat_hash_set<
+      TaskHandle,
+      grpc_event_engine::experimental::TaskHandleComparator<TaskHandle>::Hash>;
+
+  static const TaskHandle kNullHandle;
 
   virtual ~DNSResolver() {}
 

data/src/core/lib/iomgr/sockaddr_posix.h

@@ -33,6 +33,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#ifdef GRPC_HAVE_VSOCK
+#include <linux/vm_sockets.h>
+#endif
+
 typedef struct sockaddr grpc_sockaddr;
 typedef struct sockaddr_in grpc_sockaddr_in;
 typedef struct in_addr grpc_in_addr;
@@ -47,6 +51,9 @@ typedef struct in6_addr grpc_in6_addr;
 
 #define GRPC_AF_UNSPEC AF_UNSPEC
 #define GRPC_AF_UNIX AF_UNIX
+#ifdef GRPC_HAVE_VSOCK
+#define GRPC_AF_VSOCK AF_VSOCK
+#endif
 #define GRPC_AF_INET AF_INET
 #define GRPC_AF_INET6 AF_INET6
 

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -249,6 +249,35 @@ grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency) {
   return absl::OkStatus();
 }
 
+/* Set Differentiated Services Code Point (DSCP) */
+grpc_error_handle grpc_set_socket_dscp(int fd, int dscp) {
+  if (dscp == grpc_core::PosixTcpOptions::kDscpNotSet) {
+    return absl::OkStatus();
+  }
+  // The TOS/TrafficClass byte consists of following bits:
+  // | 7 6 5 4 3 2 | 1 0 |
+  // |    DSCP     | ECN |
+  int value = dscp << 2;
+
+  int optval;
+  socklen_t optlen = sizeof(optval);
+  // Get ECN bits from current IP_TOS value unless IPv6 only
+  if (0 == getsockopt(fd, IPPROTO_IP, IP_TOS, &optval, &optlen)) {
+    value |= (optval & 0x3);
+    if (0 != setsockopt(fd, IPPROTO_IP, IP_TOS, &value, sizeof(value))) {
+      return GRPC_OS_ERROR(errno, "setsockopt(IP_TOS)");
+    }
+  }
+  // Get ECN from current Traffic Class value if IPv6 is available
+  if (0 == getsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &optval, &optlen)) {
+    value |= (optval & 0x3);
+    if (0 != setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &value, sizeof(value))) {
+      return GRPC_OS_ERROR(errno, "setsockopt(IPV6_TCLASS)");
+    }
+  }
+  return absl::OkStatus();
+}
+
 // The default values for TCP_USER_TIMEOUT are currently configured to be in
 // line with the default values of KEEPALIVE_TIMEOUT as proposed in
 // https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md

data/src/core/lib/iomgr/socket_utils_posix.cc

@@ -93,6 +93,8 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.allow_reuse_port =
       (AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_ALLOW_REUSEPORT)) !=
        0);
+  options.dscp = AdjustValue(PosixTcpOptions::kDscpNotSet, 0, 63,
+                             config.GetInt(GRPC_ARG_DSCP));
 
   if (options.tcp_min_read_chunk_size > options.tcp_max_read_chunk_size) {
     options.tcp_min_read_chunk_size = options.tcp_max_read_chunk_size;

data/src/core/lib/iomgr/socket_utils_posix.h

@@ -51,6 +51,7 @@ struct PosixTcpOptions {
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
   // Let the system decide the proper buffer size.
   static constexpr int kReadBufferSizeUnset = -1;
+  static constexpr int kDscpNotSet = -1;
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
@@ -60,6 +61,7 @@ struct PosixTcpOptions {
   bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
   int keep_alive_time_ms = 0;
   int keep_alive_timeout_ms = 0;
+  int dscp = kDscpNotSet;
   bool expand_wildcard_addrs = false;
   bool allow_reuse_port = false;
   RefCountedPtr<ResourceQuota> resource_quota;
@@ -126,6 +128,7 @@ struct PosixTcpOptions {
     keep_alive_timeout_ms = other.keep_alive_timeout_ms;
     expand_wildcard_addrs = other.expand_wildcard_addrs;
     allow_reuse_port = other.allow_reuse_port;
+    dscp = other.dscp;
   }
 };
 
@@ -159,6 +162,9 @@ grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency);
 // set SO_REUSEPORT
 grpc_error_handle grpc_set_socket_reuse_port(int fd, int reuse);
 
+/* Set Differentiated Services Code Point (DSCP) */
+grpc_error_handle grpc_set_socket_dscp(int fd, int dscp);
+
 // Configure the default values for TCP_USER_TIMEOUT
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -51,6 +51,7 @@
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
@@ -111,11 +112,13 @@ static grpc_error_handle prepare_socket(
     err = grpc_set_socket_rcvbuf(fd, options.tcp_receive_buffer_size);
     if (!err.ok()) goto error;
   }
-  if (!grpc_is_unix_socket(addr)) {
+  if (!grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (!err.ok()) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
     if (!err.ok()) goto error;
+    err = grpc_set_socket_dscp(fd, options.dscp);
+    if (!err.ok()) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, options, true /* is_client */);
     if (!err.ok()) goto error;
   }

data/src/core/lib/iomgr/tcp_posix.cc

@@ -729,6 +729,9 @@ static void tcp_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   ZerocopyDisableAndWaitForRemaining(tcp);
   grpc_fd_shutdown(tcp->em_fd, why);
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
 }
 
 static void tcp_free(grpc_tcp* tcp) {
@@ -775,6 +778,9 @@ static void tcp_destroy(grpc_endpoint* ep) {
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
   TCP_UNREF(tcp, "destroy");
 }
 
@@ -795,11 +801,14 @@ static void maybe_post_reclaimer(grpc_tcp* tcp)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
   if (!tcp->has_posted_reclaimer) {
     tcp->has_posted_reclaimer = true;
+    TCP_REF(tcp, "posted_reclaimer");
     tcp->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
         [tcp](absl::optional<grpc_core::ReclamationSweep> sweep) {
-          if (!sweep.has_value()) return;
-          perform_reclamation(tcp);
+          if (sweep.has_value()) {
+            perform_reclamation(tcp);
+          }
+          TCP_UNREF(tcp, "posted_reclaimer");
         });
   }
 }
@@ -1048,7 +1057,7 @@ static void maybe_make_read_slices(grpc_tcp* tcp)
   static const int kBigAlloc = 64 * 1024;
   static const int kSmallAlloc = 8 * 1024;
   if (tcp->incoming_buffer->length <
-      static_cast<size_t>(tcp->min_progress_size)) {
+      std::max<size_t>(tcp->min_progress_size, 1)) {
     size_t allocate_length = tcp->min_progress_size;
     const size_t target_length = static_cast<size_t>(tcp->target_length);
     // If memory pressure is low and we think there will be more than
@@ -1058,8 +1067,8 @@ static void maybe_make_read_slices(grpc_tcp* tcp)
     if (low_memory_pressure && target_length > allocate_length) {
       allocate_length = target_length;
     }
-    int extra_wanted =
-        allocate_length - static_cast<int>(tcp->incoming_buffer->length);
+    int extra_wanted = std::max<int>(
+        1, allocate_length - static_cast<int>(tcp->incoming_buffer->length));
     if (extra_wanted >=
         (low_memory_pressure ? kSmallAlloc * 3 / 2 : kBigAlloc)) {
       while (extra_wanted > 0) {
@@ -1088,7 +1097,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   }
   tcp->read_mu.Lock();
   grpc_error_handle tcp_read_error;
-  if (GPR_LIKELY(error.ok())) {
+  if (GPR_LIKELY(error.ok()) && tcp->memory_owner.is_valid()) {
     maybe_make_read_slices(tcp);
     if (!tcp_do_read(tcp, &tcp_read_error)) {
       // Maybe update rcv lowat value based on the number of bytes read in this
@@ -1101,7 +1110,12 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
     }
     tcp_trace_read(tcp, tcp_read_error);
   } else {
-    tcp_read_error = error;
+    if (!tcp->memory_owner.is_valid() && error.ok()) {
+      tcp_read_error =
+          tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+    } else {
+      tcp_read_error = error;
+    }
     grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
     grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   }
@@ -2031,6 +2045,9 @@ void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
   TCP_UNREF(tcp, "destroy");
 }
 

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -25,7 +25,6 @@
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
-#include <grpc/event_engine/event_engine.h>
 #endif
 
 #include "src/core/lib/iomgr/port.h"
@@ -50,6 +49,7 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -76,6 +76,7 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -776,7 +777,7 @@ static void tcp_server_start(grpc_tcp_server* s,
   sp = s->head;
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
-        pollsets->size() > 1) {
+        !grpc_is_vsock(&sp->addr) && pollsets->size() > 1) {
       GPR_ASSERT(GRPC_LOG_IF_ERROR(
           "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1))));
       for (i = 0; i < pollsets->size(); i++) {

data/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -44,6 +44,7 @@
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -211,7 +212,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 
   GPR_ASSERT(fd >= 0);
 
-  if (so_reuseport && !grpc_is_unix_socket(addr)) {
+  if (so_reuseport && !grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
     if (!err.ok()) goto error;
   }
@@ -227,11 +228,13 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   if (!err.ok()) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
   if (!err.ok()) goto error;
-  if (!grpc_is_unix_socket(addr)) {
+  if (!grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (!err.ok()) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
     if (!err.ok()) goto error;
+    err = grpc_set_socket_dscp(fd, s->options.dscp);
+    if (!err.ok()) goto error;
     err =
         grpc_set_socket_tcp_user_timeout(fd, s->options, false /* is_client */);
     if (!err.ok()) goto error;

data/src/core/lib/iomgr/tcp_windows.cc

@@ -186,9 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   if (error.ok()) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
-      char* utf8_message = gpr_format_message(info->wsa_error);
-      error = GRPC_ERROR_CREATE(utf8_message);
-      gpr_free(utf8_message);
+      error = GRPC_WSA_ERROR(info->wsa_error, "IOCP/Socket");
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {

data/src/core/lib/iomgr/vsock.cc

@@ -0,0 +1,59 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/vsock.h"
+
+#ifdef GRPC_HAVE_VSOCK
+
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "absl/strings/str_cat.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/transport/error_utils.h"
+
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view name) {
+  grpc_resolved_address addr;
+  grpc_error_handle error = grpc_core::VSockaddrPopulate(name, &addr);
+  GRPC_RETURN_IF_ERROR(error);
+  return std::vector<grpc_resolved_address>({addr});
+}
+
+int grpc_is_vsock(const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  return addr->sa_family == AF_VSOCK;
+}
+#else
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view /*name*/) {
+  return absl::InvalidArgumentError("VSOCK is not supported.");
+}
+
+int grpc_is_vsock(const grpc_resolved_address* /*resolved_addr*/) { return 0; }
+#endif