grpc 1.62.0 → 1.63.2

data/src/core/lib/debug/stats_data.h

@@ -76,6 +76,29 @@ class HistogramCollector_65536_26 {
  private:
   std::atomic<uint64_t> buckets_[26]{};
 };
+class HistogramCollector_100_20;
+class Histogram_100_20 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_100_20 operator-(const Histogram_100_20& left,
+                                    const Histogram_100_20& right);
+
+ private:
+  friend class HistogramCollector_100_20;
+  uint64_t buckets_[20]{};
+};
+class HistogramCollector_100_20 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_100_20::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_100_20* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[20]{};
+};
 class HistogramCollector_16777216_20;
 class Histogram_16777216_20 {
  public:
@@ -168,6 +191,17 @@ struct GlobalStats {
     kWrrUpdates,
     kWorkSerializerItemsEnqueued,
     kWorkSerializerItemsDequeued,
+    kEconnabortedCount,
+    kEconnresetCount,
+    kEpipeCount,
+    kEtimedoutCount,
+    kEconnrefusedCount,
+    kEnetunreachCount,
+    kEnomsgCount,
+    kEnotconnCount,
+    kEnobufsCount,
+    kUncommonIoErrorCount,
+    kMsgErrqueueErrorCount,
     COUNT
   };
   enum class Histogram {
@@ -185,6 +219,20 @@ struct GlobalStats {
     kWorkSerializerWorkTimeMs,
     kWorkSerializerWorkTimePerItemMs,
     kWorkSerializerItemsPerRun,
+    kChaoticGoodSendmsgsPerWriteControl,
+    kChaoticGoodRecvmsgsPerReadControl,
+    kChaoticGoodSendmsgsPerWriteData,
+    kChaoticGoodRecvmsgsPerReadData,
+    kChaoticGoodThreadHopsPerWriteControl,
+    kChaoticGoodThreadHopsPerReadControl,
+    kChaoticGoodThreadHopsPerWriteData,
+    kChaoticGoodThreadHopsPerReadData,
+    kChaoticGoodTcpReadSizeData,
+    kChaoticGoodTcpReadSizeControl,
+    kChaoticGoodTcpReadOfferData,
+    kChaoticGoodTcpReadOfferControl,
+    kChaoticGoodTcpWriteSizeData,
+    kChaoticGoodTcpWriteSizeControl,
     COUNT
   };
   GlobalStats();
@@ -217,6 +265,17 @@ struct GlobalStats {
       uint64_t wrr_updates;
       uint64_t work_serializer_items_enqueued;
       uint64_t work_serializer_items_dequeued;
+      uint64_t econnaborted_count;
+      uint64_t econnreset_count;
+      uint64_t epipe_count;
+      uint64_t etimedout_count;
+      uint64_t econnrefused_count;
+      uint64_t enetunreach_count;
+      uint64_t enomsg_count;
+      uint64_t enotconn_count;
+      uint64_t enobufs_count;
+      uint64_t uncommon_io_error_count;
+      uint64_t msg_errqueue_error_count;
     };
     uint64_t counters[static_cast<int>(Counter::COUNT)];
   };
@@ -234,6 +293,20 @@ struct GlobalStats {
   Histogram_100000_20 work_serializer_work_time_ms;
   Histogram_100000_20 work_serializer_work_time_per_item_ms;
   Histogram_10000_20 work_serializer_items_per_run;
+  Histogram_100_20 chaotic_good_sendmsgs_per_write_control;
+  Histogram_100_20 chaotic_good_recvmsgs_per_read_control;
+  Histogram_100_20 chaotic_good_sendmsgs_per_write_data;
+  Histogram_100_20 chaotic_good_recvmsgs_per_read_data;
+  Histogram_100_20 chaotic_good_thread_hops_per_write_control;
+  Histogram_100_20 chaotic_good_thread_hops_per_read_control;
+  Histogram_100_20 chaotic_good_thread_hops_per_write_data;
+  Histogram_100_20 chaotic_good_thread_hops_per_read_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_size_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_size_control;
+  Histogram_16777216_20 chaotic_good_tcp_read_offer_data;
+  Histogram_16777216_20 chaotic_good_tcp_read_offer_control;
+  Histogram_16777216_20 chaotic_good_tcp_write_size_data;
+  Histogram_16777216_20 chaotic_good_tcp_write_size_control;
   HistogramView histogram(Histogram which) const;
   std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const;
 };
@@ -315,6 +388,41 @@ class GlobalStatsCollector {
     data_.this_cpu().work_serializer_items_dequeued.fetch_add(
         1, std::memory_order_relaxed);
   }
+  void IncrementEconnabortedCount() {
+    data_.this_cpu().econnaborted_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEconnresetCount() {
+    data_.this_cpu().econnreset_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEpipeCount() {
+    data_.this_cpu().epipe_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEtimedoutCount() {
+    data_.this_cpu().etimedout_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEconnrefusedCount() {
+    data_.this_cpu().econnrefused_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnetunreachCount() {
+    data_.this_cpu().enetunreach_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnomsgCount() {
+    data_.this_cpu().enomsg_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnotconnCount() {
+    data_.this_cpu().enotconn_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementEnobufsCount() {
+    data_.this_cpu().enobufs_count.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementUncommonIoErrorCount() {
+    data_.this_cpu().uncommon_io_error_count.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementMsgErrqueueErrorCount() {
+    data_.this_cpu().msg_errqueue_error_count.fetch_add(
+        1, std::memory_order_relaxed);
+  }
   void IncrementCallInitialSize(int value) {
     data_.this_cpu().call_initial_size.Increment(value);
   }
@@ -357,6 +465,49 @@ class GlobalStatsCollector {
   void IncrementWorkSerializerItemsPerRun(int value) {
     data_.this_cpu().work_serializer_items_per_run.Increment(value);
   }
+  void IncrementChaoticGoodSendmsgsPerWriteControl(int value) {
+    data_.this_cpu().chaotic_good_sendmsgs_per_write_control.Increment(value);
+  }
+  void IncrementChaoticGoodRecvmsgsPerReadControl(int value) {
+    data_.this_cpu().chaotic_good_recvmsgs_per_read_control.Increment(value);
+  }
+  void IncrementChaoticGoodSendmsgsPerWriteData(int value) {
+    data_.this_cpu().chaotic_good_sendmsgs_per_write_data.Increment(value);
+  }
+  void IncrementChaoticGoodRecvmsgsPerReadData(int value) {
+    data_.this_cpu().chaotic_good_recvmsgs_per_read_data.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerWriteControl(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_write_control.Increment(
+        value);
+  }
+  void IncrementChaoticGoodThreadHopsPerReadControl(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_read_control.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerWriteData(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_write_data.Increment(value);
+  }
+  void IncrementChaoticGoodThreadHopsPerReadData(int value) {
+    data_.this_cpu().chaotic_good_thread_hops_per_read_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadSizeData(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_size_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadSizeControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_size_control.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadOfferData(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_offer_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpReadOfferControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_read_offer_control.Increment(value);
+  }
+  void IncrementChaoticGoodTcpWriteSizeData(int value) {
+    data_.this_cpu().chaotic_good_tcp_write_size_data.Increment(value);
+  }
+  void IncrementChaoticGoodTcpWriteSizeControl(int value) {
+    data_.this_cpu().chaotic_good_tcp_write_size_control.Increment(value);
+  }
 
  private:
   struct Data {
@@ -381,6 +532,17 @@ class GlobalStatsCollector {
     std::atomic<uint64_t> wrr_updates{0};
     std::atomic<uint64_t> work_serializer_items_enqueued{0};
     std::atomic<uint64_t> work_serializer_items_dequeued{0};
+    std::atomic<uint64_t> econnaborted_count{0};
+    std::atomic<uint64_t> econnreset_count{0};
+    std::atomic<uint64_t> epipe_count{0};
+    std::atomic<uint64_t> etimedout_count{0};
+    std::atomic<uint64_t> econnrefused_count{0};
+    std::atomic<uint64_t> enetunreach_count{0};
+    std::atomic<uint64_t> enomsg_count{0};
+    std::atomic<uint64_t> enotconn_count{0};
+    std::atomic<uint64_t> enobufs_count{0};
+    std::atomic<uint64_t> uncommon_io_error_count{0};
+    std::atomic<uint64_t> msg_errqueue_error_count{0};
     HistogramCollector_65536_26 call_initial_size;
     HistogramCollector_16777216_20 tcp_write_size;
     HistogramCollector_80_10 tcp_write_iov_size;
@@ -395,6 +557,20 @@ class GlobalStatsCollector {
     HistogramCollector_100000_20 work_serializer_work_time_ms;
     HistogramCollector_100000_20 work_serializer_work_time_per_item_ms;
     HistogramCollector_10000_20 work_serializer_items_per_run;
+    HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_control;
+    HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_control;
+    HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_data;
+    HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_data;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_write_control;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_read_control;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_write_data;
+    HistogramCollector_100_20 chaotic_good_thread_hops_per_read_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_size_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_size_control;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_control;
+    HistogramCollector_16777216_20 chaotic_good_tcp_write_size_data;
+    HistogramCollector_16777216_20 chaotic_good_tcp_write_size_control;
   };
   PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
 };

data/src/core/lib/event_engine/default_event_engine.h

@@ -23,12 +23,6 @@
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/promise/context.h"
-
-namespace grpc_core {
-template <>
-struct ContextType<grpc_event_engine::experimental::EventEngine> {};
-}  // namespace grpc_core
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/event_engine_context.h

@@ -0,0 +1,31 @@
+// Copyright 2024 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_CONTEXT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_CONTEXT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/promise/context.h"
+
+namespace grpc_core {
+
+template <>
+struct ContextType<grpc_event_engine::experimental::EventEngine> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_CONTEXT_H

data/src/core/lib/event_engine/extensions/chaotic_good_extension.h

@@ -0,0 +1,65 @@
+// Copyright 2024 The 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/resource_quota/memory_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// An Endpoint extension class that will be supported by EventEngine endpoints
+/// which need to work with the ChaoticGood transport.
+class ChaoticGoodExtension {
+ public:
+  virtual ~ChaoticGoodExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.chaotic_good_extension";
+  }
+
+  /// If invoked, the endpoint begins collecting TCP stats. If the boolean
+  /// arg is_control_channel is true, then the collected stats are grouped into
+  /// histograms and counters specific to the chaotic good control channel.
+  /// Otherwise they are grouped into histograms and counters specific to the
+  /// chaotic good data channel.
+  virtual void EnableStatsCollection(bool is_control_channel) = 0;
+
+  /// Forces the endpoint to use the provided memory quota instead of using the
+  /// one provided to it through the channel args. It is safe to call this
+  /// only when there are no outstanding Reads on the Endpoint.
+  virtual void UseMemoryQuota(grpc_core::MemoryQuotaRefPtr mem_quota) = 0;
+
+  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void EnableRpcReceiveCoalescing() = 0;
+
+  /// Disables rpc receive coalescing until it is explicitly enabled again.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void DisableRpcReceiveCoalescing() = 0;
+  /// If invoked, the endpoint tries to preserve proper order and alignment of
+  /// any memory that maybe shared across reads.
+  virtual void EnforceRxMemoryAlignment() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H

data/src/core/lib/event_engine/posix.h

@@ -22,12 +22,20 @@
 #include <grpc/event_engine/slice_buffer.h>
 
 #include "src/core/lib/event_engine/extensions/can_track_errors.h"
+#include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
+/// This defines an interface that posix specific EventEngines endpoints
+/// may implement to support additional chaotic good related functionality.
+class PosixEndpointWithChaoticGoodSupport
+    : public ExtendedType<EventEngine::Endpoint, ChaoticGoodExtension,
+                          EndpointSupportsFdExtension,
+                          EndpointCanTrackErrorsExtension> {};
+
 /// This defines an interface that posix specific EventEngines endpoints
 /// may implement to support additional file descriptor related functionality.
 class PosixEndpointWithFdSupport

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

@@ -100,7 +100,7 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
     }
   }
 
-  auto used_port = ResolvedAddressIsWildcard(res_addr);
+  auto used_port = MaybeGetWildcardPortFromAddress(res_addr);
   // Update the callback. Any subsequent new sockets created and added to
   // acceptors_ in this function will invoke the new callback.
   acceptors_.UpdateOnAppendCallback(std::move(on_bind_new_fd));

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

@@ -169,6 +169,7 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
       !ResolvedAddressIsVSock(socket.addr)) {
     GRPC_RETURN_IF_ERROR(socket.sock.SetSocketLowLatency(1));
     GRPC_RETURN_IF_ERROR(socket.sock.SetSocketReuseAddr(1));
+    GRPC_RETURN_IF_ERROR(socket.sock.SetSocketDscp(options.dscp));
     socket.sock.TrySetSocketTcpUserTimeout(options, false);
   }
   GRPC_RETURN_IF_ERROR(socket.sock.SetSocketNoSigpipeIfPossible());

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

@@ -58,8 +58,15 @@
 #include "src/core/lib/gprpp/strerror.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
+#ifdef GPR_WINDOWS
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#else
 #include <sys/stat.h>  // IWYU pragma: keep
 #include <sys/un.h>
+#endif  // GPR_WINDOWS
 #endif
 
 namespace grpc_event_engine {

data/src/core/lib/event_engine/tcp_socket_utils.cc

@@ -32,8 +32,15 @@
 #endif  //  GRPC_POSIX_SOCKET_UTILS_COMMON
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
+#ifdef GPR_WINDOWS
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#else
 #include <sys/stat.h>  // IWYU pragma: keep
 #include <sys/un.h>
+#endif  // GPR_WINDOWS
 #endif
 
 #ifdef GRPC_HAVE_VSOCK
@@ -304,7 +311,7 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
   }
 }
 
-absl::optional<int> ResolvedAddressIsWildcard(
+absl::optional<int> MaybeGetWildcardPortFromAddress(
     const EventEngine::ResolvedAddress& addr) {
   const EventEngine::ResolvedAddress* resolved_addr = &addr;
   EventEngine::ResolvedAddress addr4_normalized;

data/src/core/lib/event_engine/tcp_socket_utils.h

@@ -57,8 +57,8 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
                             int port);
 
 // Returns the port number associated with the address if the given address is
-// not a wildcard ipv6 or ipv6 address. Otherwise returns absl::nullopt
-absl::optional<int> ResolvedAddressIsWildcard(
+// a wildcard ipv4 or ipv6 address. Otherwise returns absl::nullopt
+absl::optional<int> MaybeGetWildcardPortFromAddress(
     const EventEngine::ResolvedAddress& addr);
 
 // Returns true if resolved_addr is an VSOCK address. Otherwise returns false.

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -208,6 +208,10 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 
 }  // namespace
 
+absl::Status SetSocketNonBlock(SOCKET sock) {
+  return grpc_tcp_set_non_block(sock);
+}
+
 absl::Status PrepareSocket(SOCKET sock) {
   absl::Status err;
   err = grpc_tcp_set_non_block(sock);

data/src/core/lib/event_engine/windows/win_socket.h

@@ -133,6 +133,9 @@ class WinSocket {
 // Attempt to configure default socket settings
 absl::Status PrepareSocket(SOCKET sock);
 
+// Set non block option for socket.
+absl::Status SetSocketNonBlock(SOCKET sock);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -49,6 +49,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+namespace {
+EventEngine::OnConnectCallback CreateCrashingOnConnectCallback() {
+  return [](absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>) {
+    grpc_core::Crash("Internal Error: OnConnect callback called when unset");
+  };
+}
+}  // namespace
 // ---- IOCPWorkClosure ----
 
 WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
@@ -250,6 +257,7 @@ void WindowsEventEngine::OnConnectCompleted(
     // Connection attempt complete!
     grpc_core::MutexLock lock(&state->mu);
     cb = std::move(state->on_connected_user_callback);
+    state->on_connected_user_callback = CreateCrashingOnConnectCallback();
     state->on_connected = nullptr;
     {
       grpc_core::MutexLock handle_lock(&connection_mu_);
@@ -298,7 +306,10 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
   if (ResolvedAddressToV4Mapped(addr, &addr6_v4mapped)) {
     address = addr6_v4mapped;
   }
-  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+  const int addr_family =
+      (address.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET sock = WSASocket(addr_family, SOCK_STREAM, protocol, nullptr, 0,
                           IOCP::GetDefaultSocketFlags());
   if (sock == INVALID_SOCKET) {
     Run([on_connect = std::move(on_connect),
@@ -307,7 +318,11 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  status = PrepareSocket(sock);
+  if (addr_family == AF_UNIX) {
+    status = SetSocketNonBlock(sock);
+  } else {
+    status = PrepareSocket(sock);
+  }
   if (!status.ok()) {
     Run([on_connect = std::move(on_connect), status]() mutable {
       on_connect(status);
@@ -332,7 +347,16 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     return EventEngine::ConnectionHandle::kInvalid;
   }
   // bind the local address
-  auto local_address = ResolvedAddressMakeWild6(0);
+  ResolvedAddress local_address;
+  if (addr_family == AF_UNIX) {
+    // For ConnectEx() to work for AF_UNIX, the sock needs to be bound to
+    // the local address of an unnamed socket.
+    sockaddr addr = {};
+    addr.sa_family = AF_UNIX;
+    local_address = ResolvedAddress(&addr, sizeof(addr));
+  } else {
+    local_address = ResolvedAddressMakeWild6(0);
+  }
   istatus = bind(sock, local_address.address(), local_address.size());
   if (istatus != 0) {
     Run([on_connect = std::move(on_connect),
@@ -356,10 +380,13 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
       });
   connection_state->timer_handle =
       RunAfter(timeout, [this, connection_state]() {
-        grpc_core::MutexLock lock(&connection_state->mu);
+        grpc_core::ReleasableMutexLock lock(&connection_state->mu);
         if (CancelConnectFromDeadlineTimer(connection_state.get())) {
-          connection_state->on_connected_user_callback(
-              absl::DeadlineExceededError("Connection timed out"));
+          auto cb = std::move(connection_state->on_connected_user_callback);
+          connection_state->on_connected_user_callback =
+              CreateCrashingOnConnectCallback();
+          lock.Release();
+          cb(absl::DeadlineExceededError("Connection timed out"));
         }
         // else: The connection attempt could not be canceled. We can assume
         // the connection callback will be called.
@@ -380,8 +407,14 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
       connection_state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
       Run([connection_state = std::move(connection_state),
            status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
-        grpc_core::MutexLock lock(&connection_state->mu);
-        connection_state->on_connected_user_callback(status);
+        EventEngine::OnConnectCallback cb;
+        {
+          grpc_core::MutexLock lock(&connection_state->mu);
+          cb = std::move(connection_state->on_connected_user_callback);
+          connection_state->on_connected_user_callback =
+              CreateCrashingOnConnectCallback();
+        }
+        cb(status);
       });
       return EventEngine::ConnectionHandle::kInvalid;
     }

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -27,6 +27,7 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -67,11 +68,39 @@ void WindowsEventEngineListener::SinglePortSocketListener::
 
 // ---- SinglePortSocketListener ----
 
+// TODO(hork): This may be refactored to share with posix engine.
+void UnlinkIfUnixDomainSocket(
+    const EventEngine::ResolvedAddress& resolved_addr) {
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  if (resolved_addr.address()->sa_family != AF_UNIX) {
+    return;
+  }
+  struct sockaddr_un* un = reinterpret_cast<struct sockaddr_un*>(
+      const_cast<sockaddr*>(resolved_addr.address()));
+  // There is nothing to unlink for an abstract unix socket.
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+  // For windows we need to remove the file instead of unlink.
+  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  if (attr == INVALID_FILE_ATTRIBUTES) {
+    return;
+  }
+  if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
+    return;
+  }
+  ::DeleteFileA(un->sun_path);
+#else
+  (void)resolved_addr;
+#endif
+}
+
 WindowsEventEngineListener::SinglePortSocketListener::
     ~SinglePortSocketListener() {
   grpc_core::MutexLock lock(&io_state_->mu);
   io_state_->listener_socket->Shutdown(DEBUG_LOCATION,
                                        "~SinglePortSocketListener");
+  UnlinkIfUnixDomainSocket(listener_sockname());
   GRPC_EVENT_ENGINE_TRACE("~SinglePortSocketListener::%p", this);
 }
 
@@ -109,7 +138,11 @@ absl::Status WindowsEventEngineListener::SinglePortSocketListener::Start() {
 
 absl::Status
 WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
-  SOCKET accept_socket = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const EventEngine::ResolvedAddress addr = listener_sockname();
+  const int addr_family =
+      (addr.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET accept_socket = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                                    IOCP::GetDefaultSocketFlags());
   if (accept_socket == INVALID_SOCKET) {
     return GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
@@ -118,11 +151,17 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
     if (accept_socket != INVALID_SOCKET) closesocket(accept_socket);
     return error;
   };
-  auto error = PrepareSocket(accept_socket);
+  absl::Status error;
+  if (addr_family == AF_UNIX) {
+    error = SetSocketNonBlock(accept_socket);
+  } else {
+    error = PrepareSocket(accept_socket);
+  }
   if (!error.ok()) return fail(error);
   // Start the "accept" asynchronously.
   io_state_->listener_socket->NotifyOnRead(&io_state_->on_accept_cb);
-  DWORD addrlen = sizeof(sockaddr_in6) + 16;
+  DWORD addrlen =
+      sizeof(addresses_) / 2;  // half of the buffer is for remote addr.
   DWORD bytes_received = 0;
   int success =
       AcceptEx(io_state_->listener_socket->raw_socket(), accept_socket,
@@ -238,8 +277,14 @@ WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     if (sock != INVALID_SOCKET) closesocket(sock);
     return error;
   };
-  auto error = PrepareSocket(sock);
+  absl::Status error;
+  if (addr.address()->sa_family == AF_UNIX) {
+    error = SetSocketNonBlock(sock);
+  } else {
+    error = PrepareSocket(sock);
+  }
   if (!error.ok()) return fail(error);
+  UnlinkIfUnixDomainSocket(addr);
   if (bind(sock, addr.address(), addr.size()) == SOCKET_ERROR) {
     return fail(GRPC_WSA_ERROR(WSAGetLastError(), "bind"));
   }
@@ -309,11 +354,14 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
     out_addr = tmp_addr;
   }
   // Treat :: or 0.0.0.0 as a family-agnostic wildcard.
-  if (ResolvedAddressIsWildcard(out_addr)) {
+  if (MaybeGetWildcardPortFromAddress(out_addr).has_value()) {
     out_addr = ResolvedAddressMakeWild6(out_port);
   }
   // open the socket
-  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+  const int addr_family =
+      (out_addr.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET sock = WSASocket(addr_family, SOCK_STREAM, protocol, nullptr, 0,
                           IOCP::GetDefaultSocketFlags());
   if (sock == INVALID_SOCKET) {
     auto error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");