grpc 1.58.0 → 1.60.0

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

@@ -0,0 +1,75 @@
+// Copyright 2023 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_WINDOWS_GRPC_POLLED_FD_WINDOWS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_GRPC_POLLED_FD_WINDOWS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
+
+#if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+
+#include <memory>
+
+#include <ares.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/grpc_polled_fd.h"
+#include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/win_socket.h"
+#include "src/core/lib/gprpp/sync.h"
+
+struct iovec;
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class GrpcPolledFdWindows;
+
+class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
+ public:
+  explicit GrpcPolledFdFactoryWindows(IOCP* iocp);
+  ~GrpcPolledFdFactoryWindows() override;
+
+  void Initialize(grpc_core::Mutex* mutex, EventEngine* event_engine) override;
+  std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
+      ares_socket_t as) override;
+  void ConfigureAresChannelLocked(ares_channel channel) override;
+
+ private:
+  friend class CustomSockFuncs;
+
+  // The mutex is owned by the AresResolver which owns this object.
+  grpc_core::Mutex* mu_;
+  // The IOCP object is owned by the WindowsEngine whose ownership is shared by
+  // the AresResolver.
+  IOCP* iocp_;
+  // This pointer is initialized from the stored pointer inside the shared
+  // pointer owned by the AresResolver which owns this object.
+  EventEngine* event_engine_;
+  std::map<SOCKET, std::unique_ptr<GrpcPolledFdWindows>> sockets_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_GRPC_POLLED_FD_WINDOWS_H

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

@@ -93,12 +93,8 @@ void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
     thread_pool_->Run(closure);
     return;
   };
-  if (std::exchange(info.has_pending_iocp_, false)) {
-    thread_pool_->Run(closure);
-  } else {
-    EventEngine::Closure* prev = nullptr;
-    GPR_ASSERT(info.closure_.compare_exchange_strong(prev, closure));
-  }
+  // It is an error if any notification is already registered for this socket.
+  GPR_ASSERT(std::exchange(info.closure_, closure) == nullptr);
 }
 
 void WinSocket::NotifyOnRead(EventEngine::Closure* on_read) {
@@ -109,6 +105,14 @@ void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
   NotifyOnReady(write_info_, on_write);
 }
 
+void WinSocket::UnregisterReadCallback() {
+  GPR_ASSERT(std::exchange(read_info_.closure_, nullptr) != nullptr);
+}
+
+void WinSocket::UnregisterWriteCallback() {
+  GPR_ASSERT(std::exchange(write_info_.closure_, nullptr) != nullptr);
+}
+
 // ---- WinSocket::OpState ----
 
 WinSocket::OpState::OpState(WinSocket* win_socket) noexcept
@@ -117,13 +121,11 @@ WinSocket::OpState::OpState(WinSocket* win_socket) noexcept
 }
 
 void WinSocket::OpState::SetReady() {
-  GPR_ASSERT(!has_pending_iocp_);
-  auto* closure = closure_.exchange(nullptr);
-  if (closure) {
-    win_socket_->thread_pool_->Run(closure);
-  } else {
-    has_pending_iocp_ = true;
-  }
+  auto* closure = std::exchange(closure_, nullptr);
+  // If an IOCP event is returned for a socket, and no callback has been
+  // registered for notification, this is invalid usage.
+  GPR_ASSERT(closure != nullptr);
+  win_socket_->thread_pool_->Run(closure);
 }
 
 void WinSocket::OpState::SetError(int wsa_error) {
@@ -134,6 +136,11 @@ void WinSocket::OpState::SetResult(OverlappedResult result) {
   result_ = result;
 }
 
+void WinSocket::OpState::SetErrorStatus(absl::Status error_status) {
+  result_ = OverlappedResult{/*wsa_error=*/0, /*bytes_transferred=*/0,
+                             /*error_status=*/error_status};
+}
+
 void WinSocket::OpState::GetOverlappedResult() {
   GetOverlappedResult(win_socket_->raw_socket());
 }

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

@@ -35,6 +35,7 @@ class WinSocket {
   struct OverlappedResult {
     int wsa_error;
     DWORD bytes_transferred;
+    absl::Status error_status;
   };
 
   // State related to a Read or Write socket operation
@@ -46,10 +47,13 @@ class WinSocket {
     // the WinSocket's ThreadPool. Otherwise, a "pending iocp" flag will
     // be set.
     void SetReady();
-    // Set error results for a completed op
+    // Set WSA error results for a completed op.
     void SetError(int wsa_error);
     // Set an OverlappedResult. Useful when WSARecv returns immediately.
     void SetResult(OverlappedResult result);
+    // Set error results for a completed op.
+    // This is a manual override, meant to override any WSA status code.
+    void SetErrorStatus(absl::Status error_status);
     // Retrieve the results of an overlapped operation (via Winsock API) and
     // store them locally.
     void GetOverlappedResult();
@@ -67,19 +71,27 @@ class WinSocket {
 
     OVERLAPPED overlapped_;
     WinSocket* win_socket_ = nullptr;
-    std::atomic<EventEngine::Closure*> closure_{nullptr};
-    bool has_pending_iocp_ = false;
+    EventEngine::Closure* closure_ = nullptr;
     OverlappedResult result_;
   };
 
   WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept;
   ~WinSocket();
-  // Calling NotifyOnRead means either of two things:
-  //  - The IOCP already completed in the background, and we need to call
-  //    the callback now.
-  //  - The IOCP hasn't completed yet, and we're queuing it for later.
+  // Provide a closure that will be called when an IOCP completion has occurred.
+  //
+  // Notification callbacks *must be registered* before any WSASend or WSARecv
+  // operations are started. Only one closure can be registered at a time for
+  // each read or send operation.
   void NotifyOnRead(EventEngine::Closure* on_read);
   void NotifyOnWrite(EventEngine::Closure* on_write);
+  // Remove the notification callback for read/write events.
+  //
+  // This method should only be called if no IOCP event is pending for the
+  // socket. It is UB if an IOCP event comes through and a notification is not
+  // registered.
+  void UnregisterReadCallback();
+  void UnregisterWriteCallback();
+
   bool IsShutdown();
   // Shutdown socket operations, but do not delete the WinSocket.
   // Connections will be disconnected, and the socket will be closed.

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

@@ -76,10 +76,13 @@ WindowsEndpoint::~WindowsEndpoint() {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
 }
 
-absl::Status WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
+void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
   if (socket->IsShutdown()) {
-    return absl::UnavailableError("Socket is shutting down.");
+    socket->read_info()->SetErrorStatus(
+        absl::UnavailableError("Socket is shutting down."));
+    thread_pool->Run(&handle_read_event);
+    return;
   }
   // Prepare the WSABUF struct
   GPR_ASSERT(buffer->Count() <= kMaxWSABUFCount);
@@ -101,26 +104,26 @@ absl::Status WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
     socket->read_info()->SetResult(
         {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
     thread_pool->Run(&handle_read_event);
-    return absl::OkStatus();
+    return;
   }
   // If the endpoint has already received some data, and the next call would
   // block, return the data in case that is all the data the reader expects.
   if (handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
-    return absl::OkStatus();
+    return;
   }
   // Otherwise, let's retry, by queuing a read.
-  status =
-      WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
-              &bytes_read, &flags, socket->read_info()->overlapped(), nullptr);
+  socket->NotifyOnRead(&handle_read_event);
+  status = WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
+                   nullptr, &flags, socket->read_info()->overlapped(), nullptr);
   wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != 0 && wsa_error != WSA_IO_PENDING) {
-    // Async read returned immediately with an error
-    return GRPC_WSA_ERROR(
+    // The async read attempt returned an error immediately.
+    socket->UnregisterReadCallback();
+    socket->read_info()->SetErrorStatus(GRPC_WSA_ERROR(
         wsa_error,
-        absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str());
+        absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str()));
+    thread_pool->Run(&handle_read_event);
   }
-  socket->NotifyOnRead(&handle_read_event);
-  return absl::OkStatus();
 }
 
 bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
@@ -140,13 +143,7 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     buffer->AppendIndexed(Slice(allocator_.MakeSlice(min_read_size)));
   }
   io_state_->handle_read_event.Prime(io_state_, buffer, std::move(on_read));
-  auto status = io_state_->DoTcpRead(buffer);
-  if (!status.ok()) {
-    // The read could not be completed.
-    io_state_->thread_pool->Run(
-        [cb = io_state_->handle_read_event.ResetAndReturnCallback(),
-         status]() mutable { cb(status); });
-  }
+  io_state_->DoTcpRead(buffer);
   return false;
 }
 
@@ -212,6 +209,8 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
     }
   }
   auto write_info = io_state_->socket->write_info();
+  io_state_->handle_write_event.Prime(io_state_, data, std::move(on_writable));
+  io_state_->socket->NotifyOnWrite(&io_state_->handle_write_event);
   status =
       WSASend(io_state_->socket->raw_socket(), &buffers[async_buffers_offset],
               (DWORD)(data->Count() - async_buffers_offset), nullptr, 0,
@@ -219,17 +218,12 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status != 0) {
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
-      io_state_->thread_pool->Run(
-          [cb = std::move(on_writable), wsa_error]() mutable {
-            cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
-          });
-      return false;
+      io_state_->socket->UnregisterWriteCallback();
+      io_state_->socket->write_info()->SetErrorStatus(
+          GRPC_WSA_ERROR(wsa_error, "WSASend"));
+      io_state_->thread_pool->Run(&io_state_->handle_write_event);
     }
   }
-  // As all is now setup, we can now ask for the IOCP notification. It may
-  // trigger the callback immediately however, but no matter.
-  io_state_->handle_write_event.Prime(io_state_, data, std::move(on_writable));
-  io_state_->socket->NotifyOnWrite(&io_state_->handle_write_event);
   return false;
 }
 const EventEngine::ResolvedAddress& WindowsEndpoint::GetPeerAddress() const {
@@ -288,8 +282,12 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
                                    io_state->endpoint);
-  absl::Status status;
   const auto result = io_state->socket->read_info()->result();
+  if (!result.error_status.ok()) {
+    buffer_->Clear();
+    return ResetAndReturnCallback()(result.error_status);
+  }
+  absl::Status status;
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "Async Read Error");
     buffer_->Clear();
@@ -317,10 +315,7 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   }
   // Doing another read. Let's keep the AsyncIOState alive a bit longer.
   io_state_ = std::move(io_state);
-  status = io_state_->DoTcpRead(buffer_);
-  if (!status.ok()) {
-    return ResetAndReturnCallback()(status);
-  }
+  io_state_->DoTcpRead(buffer_);
 }
 
 bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
@@ -349,6 +344,10 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
                                    io_state->endpoint);
   const auto result = io_state->socket->write_info()->result();
+  if (!result.error_status.ok()) {
+    buffer_->Clear();
+    return ResetAndReturnCallback()(result.error_status);
+  }
   absl::Status status;
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "WSASend");

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

@@ -97,7 +97,7 @@ class WindowsEndpoint : public EventEngine::Endpoint {
 
     // Perform the low-level calls and execute the HandleReadClosure
     // asynchronously.
-    absl::Status DoTcpRead(SliceBuffer* buffer);
+    void DoTcpRead(SliceBuffer* buffer);
 
     WindowsEndpoint* const endpoint;
     std::unique_ptr<WinSocket> socket;

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

@@ -35,6 +35,7 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/event_engine/windows/grpc_polled_fd_windows.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/event_engine/windows/windows_engine.h"
@@ -99,7 +100,7 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
 
 WindowsEventEngine::WindowsEventEngine()
     : thread_pool_(
-          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
       iocp_(thread_pool_.get()),
       timer_manager_(thread_pool_),
       iocp_worker_(thread_pool_.get(), &iocp_) {
@@ -194,10 +195,49 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   return handle;
 }
 
+#if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+
+WindowsEventEngine::WindowsDNSResolver::WindowsDNSResolver(
+    grpc_core::OrphanablePtr<AresResolver> ares_resolver)
+    : ares_resolver_(std::move(ares_resolver)) {}
+
+void WindowsEventEngine::WindowsDNSResolver::LookupHostname(
+    LookupHostnameCallback on_resolve, absl::string_view name,
+    absl::string_view default_port) {
+  ares_resolver_->LookupHostname(name, default_port, std::move(on_resolve));
+}
+
+void WindowsEventEngine::WindowsDNSResolver::LookupSRV(
+    LookupSRVCallback on_resolve, absl::string_view name) {
+  ares_resolver_->LookupSRV(name, std::move(on_resolve));
+}
+
+void WindowsEventEngine::WindowsDNSResolver::LookupTXT(
+    LookupTXTCallback on_resolve, absl::string_view name) {
+  ares_resolver_->LookupTXT(name, std::move(on_resolve));
+}
+
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 WindowsEventEngine::GetDNSResolver(
-    EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
+    EventEngine::DNSResolver::ResolverOptions const& options) {
+#if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  auto ares_resolver = AresResolver::CreateAresResolver(
+      options.dns_server,
+      std::make_unique<GrpcPolledFdFactoryWindows>(poller()),
+      shared_from_this());
+  if (!ares_resolver.ok()) {
+    return ares_resolver.status();
+  }
+  return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
+      std::move(*ares_resolver));
+#else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  // TODO(yijiem): Implement a basic A/AAAA-only native resolver in
+  // WindowsEventEngine.
+  (void)options;
   grpc_core::Crash("unimplemented");
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
 
 bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
@@ -218,18 +258,21 @@ void WindowsEventEngine::OnConnectCompleted(
     const auto& overlapped_result = state->socket->write_info()->result();
     // return early if we cannot cancel the connection timeout timer.
     if (!Cancel(state->timer_handle)) return;
-    if (overlapped_result.wsa_error != 0) {
+    if (!overlapped_result.error_status.ok()) {
+      state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
+      endpoint = overlapped_result.error_status;
+    } else if (overlapped_result.wsa_error != 0) {
       state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
       endpoint = GRPC_WSA_ERROR(overlapped_result.wsa_error, "ConnectEx");
     } else {
-      // This code should be running in a thread pool thread already, so the
-      // callback can be run directly.
       ChannelArgsEndpointConfig cfg;
       endpoint = std::make_unique<WindowsEndpoint>(
           state->address, std::move(state->socket), std::move(state->allocator),
           cfg, thread_pool_.get(), shared_from_this());
     }
   }
+  // This code should be running in a thread pool thread already, so the
+  // callback can be run directly.
   cb(std::move(endpoint));
 }
 
@@ -298,43 +341,19 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  // Connect
-  auto watched_socket = iocp_.Watch(sock);
-  auto* info = watched_socket->write_info();
-  bool success =
-      ConnectEx(watched_socket->raw_socket(), address.address(), address.size(),
-                nullptr, 0, nullptr, info->overlapped());
-  // It wouldn't be unusual to get a success immediately. But we'll still get an
-  // IOCP notification, so let's ignore it.
-  if (!success) {
-    int last_error = WSAGetLastError();
-    if (last_error != ERROR_IO_PENDING) {
-      Run([on_connect = std::move(on_connect),
-           status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
-        on_connect(status);
-      });
-      watched_socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
-      return EventEngine::ConnectionHandle::kInvalid;
-    }
-  }
-  GPR_ASSERT(watched_socket != nullptr);
+  // Prepare the socket to receive a connection
   auto connection_state = std::make_shared<ConnectionState>();
   grpc_core::MutexLock lock(&connection_state->mu);
+  connection_state->socket = iocp_.Watch(sock);
+  GPR_ASSERT(connection_state->socket != nullptr);
+  auto* info = connection_state->socket->write_info();
   connection_state->address = address;
-  connection_state->socket = std::move(watched_socket);
-  connection_state->on_connected_user_callback = std::move(on_connect);
   connection_state->allocator = std::move(memory_allocator);
+  connection_state->on_connected_user_callback = std::move(on_connect);
   connection_state->on_connected =
       SelfDeletingClosure::Create([this, connection_state]() mutable {
         OnConnectCompleted(std::move(connection_state));
       });
-  {
-    grpc_core::MutexLock conn_lock(&connection_mu_);
-    connection_state->connection_handle =
-        ConnectionHandle{reinterpret_cast<intptr_t>(connection_state.get()),
-                         aba_token_.fetch_add(1)};
-    known_connection_handles_.insert(connection_state->connection_handle);
-  }
   connection_state->timer_handle =
       RunAfter(timeout, [this, connection_state]() {
         grpc_core::MutexLock lock(&connection_state->mu);
@@ -342,10 +361,36 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
           connection_state->on_connected_user_callback(
               absl::DeadlineExceededError("Connection timed out"));
         }
-        // else: The connection attempt could not be canceled. We can assume the
-        // connection callback will be called.
+        // else: The connection attempt could not be canceled. We can assume
+        // the connection callback will be called.
       });
+  // Connect
   connection_state->socket->NotifyOnWrite(connection_state->on_connected);
+  bool success =
+      ConnectEx(connection_state->socket->raw_socket(), address.address(),
+                address.size(), nullptr, 0, nullptr, info->overlapped());
+  // It wouldn't be unusual to get a success immediately. But we'll still get an
+  // IOCP notification, so let's ignore it.
+  if (!success) {
+    int last_error = WSAGetLastError();
+    if (last_error != ERROR_IO_PENDING) {
+      if (!Cancel(connection_state->timer_handle)) {
+        return EventEngine::ConnectionHandle::kInvalid;
+      }
+      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);
+      });
+      return EventEngine::ConnectionHandle::kInvalid;
+    }
+  }
+  connection_state->connection_handle =
+      ConnectionHandle{reinterpret_cast<intptr_t>(connection_state.get()),
+                       aba_token_.fetch_add(1)};
+  grpc_core::MutexLock connection_handle_lock(&connection_mu_);
+  known_connection_handles_.insert(connection_state->connection_handle);
   return connection_state->connection_handle;
 }
 
@@ -386,7 +431,7 @@ bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
 bool WindowsEventEngine::CancelConnectInternalStateLocked(
     ConnectionState* connection_state) {
   connection_state->socket->Shutdown(DEBUG_LOCATION, "CancelConnect");
-  // Release the connection_state shared_ptr. connection_state is now invalid.
+  // Release the connection_state shared_ptr owned by the connected callback.
   delete connection_state->on_connected;
   GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
                           HandleToString<EventEngine::ConnectionHandle>(

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

@@ -13,8 +13,11 @@
 // limitations under the License.
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
+
 #ifdef GPR_WINDOWS
 
 #include <memory>
@@ -28,6 +31,7 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
+#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
@@ -47,7 +51,11 @@ class WindowsEventEngine : public EventEngine,
  public:
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:
-    ~WindowsDNSResolver() override;
+    WindowsDNSResolver() = delete;
+#if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+    explicit WindowsDNSResolver(
+        grpc_core::OrphanablePtr<AresResolver> ares_resolver);
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
     void LookupHostname(LookupHostnameCallback on_resolve,
                         absl::string_view name,
                         absl::string_view default_port) override;
@@ -55,6 +63,11 @@ class WindowsEventEngine : public EventEngine,
                    absl::string_view name) override;
     void LookupTXT(LookupTXTCallback on_resolve,
                    absl::string_view name) override;
+
+#if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+   private:
+    grpc_core::OrphanablePtr<AresResolver> ares_resolver_;
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   };
 
   WindowsEventEngine();
@@ -100,7 +113,8 @@ class WindowsEventEngine : public EventEngine,
     grpc_core::Mutex mu
         ABSL_ACQUIRED_BEFORE(WindowsEventEngine::connection_mu_);
     EventEngine::ConnectionHandle connection_handle ABSL_GUARDED_BY(mu);
-    EventEngine::TaskHandle timer_handle ABSL_GUARDED_BY(mu);
+    EventEngine::TaskHandle timer_handle ABSL_GUARDED_BY(mu) =
+        EventEngine::TaskHandle::kInvalid;
     EventEngine::OnConnectCallback on_connected_user_callback
         ABSL_GUARDED_BY(mu);
     EventEngine::Closure* on_connected ABSL_GUARDED_BY(mu);

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

@@ -121,6 +121,7 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
   auto 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 bytes_received = 0;
   int success =
@@ -132,13 +133,11 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
   if (success != 0) {
     int last_error = WSAGetLastError();
     if (last_error != ERROR_IO_PENDING) {
+      io_state_->listener_socket->UnregisterReadCallback();
       return fail(GRPC_WSA_ERROR(last_error, "AcceptEx"));
     }
   }
-  // We're ready to do the accept. Calling NotifyOnRead may immediately process
-  // an accept that happened in the meantime.
   io_state_->accept_socket = accept_socket;
-  io_state_->listener_socket->NotifyOnRead(&io_state_->on_accept_cb);
   GRPC_EVENT_ENGINE_TRACE(
       "SinglePortSocketListener::%p listening. listener_socket::%p", this,
       io_state_->listener_socket.get());

data/src/core/lib/event_engine/work_queue/basic_work_queue.cc

@@ -23,6 +23,8 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+BasicWorkQueue::BasicWorkQueue(void* owner) : owner_(owner) {}
+
 bool BasicWorkQueue::Empty() const {
   grpc_core::MutexLock lock(&mu_);
   return q_.empty();

data/src/core/lib/event_engine/work_queue/basic_work_queue.h

@@ -36,7 +36,8 @@ namespace experimental {
 // closures are added to the back.
 class BasicWorkQueue : public WorkQueue {
  public:
-  BasicWorkQueue() = default;
+  BasicWorkQueue() : owner_(nullptr) {}
+  explicit BasicWorkQueue(void* owner);
   // Returns whether the queue is empty
   bool Empty() const override ABSL_LOCKS_EXCLUDED(mu_);
   // Returns the size of the queue.
@@ -59,10 +60,12 @@ class BasicWorkQueue : public WorkQueue {
   // Wraps an AnyInvocable and adds it to the the queue.
   void Add(absl::AnyInvocable<void()> invocable) override
       ABSL_LOCKS_EXCLUDED(mu_);
+  const void* owner() override { return owner_; }
 
  private:
   mutable grpc_core::Mutex mu_;
   std::deque<EventEngine::Closure*> q_ ABSL_GUARDED_BY(mu_);
+  const void* const owner_ = nullptr;
 };
 
 }  // namespace experimental

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

@@ -54,6 +54,10 @@ class WorkQueue {
   virtual void Add(EventEngine::Closure* closure) = 0;
   // Wraps an AnyInvocable and adds it to the the queue.
   virtual void Add(absl::AnyInvocable<void()> invocable) = 0;
+  // Returns an optional owner id for queue identification.
+  // TODO(hork): revisit if this can be moved to the thread pool implementation
+  // if dynamic queue type experiments are warranted.
+  virtual const void* owner() = 0;
 };
 
 }  // namespace experimental