grpc 1.63.0 → 1.66.0

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <utility>
 
@@ -28,6 +26,7 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -78,8 +77,9 @@ class ThreadyEventEngine final : public EventEngine {
  private:
   class ThreadyDNSResolver final : public DNSResolver {
    public:
-    explicit ThreadyDNSResolver(std::unique_ptr<DNSResolver> impl)
-        : impl_(std::move(impl)) {}
+    ThreadyDNSResolver(std::unique_ptr<DNSResolver> impl,
+                       std::shared_ptr<ThreadyEventEngine> engine)
+        : impl_(std::move(impl)), engine_(std::move(engine)) {}
     void LookupHostname(LookupHostnameCallback on_resolve,
                         absl::string_view name,
                         absl::string_view default_port) override;
@@ -90,7 +90,7 @@ class ThreadyEventEngine final : public EventEngine {
 
    private:
     std::unique_ptr<DNSResolver> impl_;
-    ThreadyEventEngine* engine_;
+    std::shared_ptr<ThreadyEventEngine> engine_;
   };
 
   void Asynchronously(absl::AnyInvocable<void()> fn);

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

@@ -11,13 +11,12 @@
 // 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/event_engine/time_util.h"
 
 #include <chrono>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -14,11 +14,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -11,8 +11,6 @@
 // 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/event_engine/utils.h"
 
 #include <stdint.h>
@@ -22,6 +20,7 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/time.h"
 

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

@@ -14,13 +14,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <string>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/time.h"
 

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

@@ -23,6 +23,7 @@
 #include <ares.h>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -132,8 +133,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         shutdown_called_);
     grpc_core::CSliceUnref(read_buf_);
     grpc_core::CSliceUnref(write_buf_);
-    GPR_ASSERT(read_closure_ == nullptr);
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK(read_closure_ == nullptr);
+    CHECK(write_closure_ == nullptr);
     if (!shutdown_called_) {
       winsocket_->Shutdown(DEBUG_LOCATION, "~GrpcPolledFdWindows");
     }
@@ -141,15 +142,15 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   void RegisterForOnReadableLocked(
       absl::AnyInvocable<void(absl::Status)> read_closure) override {
-    GPR_ASSERT(read_closure_ == nullptr);
+    CHECK(read_closure_ == nullptr);
     read_closure_ = std::move(read_closure);
     grpc_core::CSliceUnref(read_buf_);
-    GPR_ASSERT(!read_buf_has_data_);
+    CHECK(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(kReadBufferSize);
     if (connect_done_) {
       ContinueRegisterForOnReadableLocked();
     } else {
-      GPR_ASSERT(pending_continue_register_for_on_readable_locked_ == false);
+      CHECK(pending_continue_register_for_on_readable_locked_ == false);
       pending_continue_register_for_on_readable_locked_ = true;
     }
   }
@@ -160,16 +161,16 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       GRPC_ARES_RESOLVER_TRACE_LOG(
           "fd:|%s| RegisterForOnWriteableLocked called", GetName());
     } else {
-      GPR_ASSERT(socket_type_ == SOCK_STREAM);
+      CHECK(socket_type_ == SOCK_STREAM);
       GRPC_ARES_RESOLVER_TRACE_LOG(
           "fd:|%s| RegisterForOnWriteableLocked called tcp_write_state_: %d "
           "connect_done_: %d",
           GetName(), tcp_write_state_, connect_done_);
     }
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK(write_closure_ == nullptr);
     write_closure_ = std::move(write_closure);
     if (!connect_done_) {
-      GPR_ASSERT(!pending_continue_register_for_on_writeable_locked_);
+      CHECK(!pending_continue_register_for_on_writeable_locked_);
       pending_continue_register_for_on_writeable_locked_ = true;
     } else {
       ContinueRegisterForOnWriteableLocked();
@@ -179,7 +180,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   bool IsFdStillReadableLocked() override { return read_buf_has_data_; }
 
   bool ShutdownLocked(absl::Status error) override {
-    GPR_ASSERT(!shutdown_called_);
+    CHECK(!shutdown_called_);
     if (!absl::IsCancelled(error)) {
       return false;
     }
@@ -223,7 +224,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // c-ares overloads this recv_from virtual socket function to receive
     // data on both UDP and TCP sockets, and from is nullptr for TCP.
     if (from != nullptr) {
-      GPR_ASSERT(*from_len <= recv_from_source_addr_len_);
+      CHECK(*from_len <= recv_from_source_addr_len_);
       memcpy(from, &recv_from_source_addr_, recv_from_source_addr_len_);
       *from_len = recv_from_source_addr_len_;
     }
@@ -291,7 +292,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnReadableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullReadClosure(GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
       return;
@@ -328,7 +329,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnWriteableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullWriteClosure(
           GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
@@ -338,7 +339,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       ScheduleAndNullWriteClosure(absl::OkStatus());
       return;
     }
-    GPR_ASSERT(socket_type_ == SOCK_STREAM);
+    CHECK(socket_type_ == SOCK_STREAM);
     int wsa_error_code = 0;
     switch (tcp_write_state_) {
       case WRITE_IDLE:
@@ -386,7 +387,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // Therefore, the sendv handler for UDP sockets must only attempt
     // to write everything inline.
     GRPC_ARES_RESOLVER_TRACE_LOG("fd:|%s| SendVUDP called", GetName());
-    GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
+    CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
     grpc_core::CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
     DWORD bytes_sent = 0;
@@ -434,12 +435,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         // send again. If c-ares still needs to send even more data, we'll get
         // to it eventually.
         grpc_slice currently_attempted = FlattenIovec(iov, iov_count);
-        GPR_ASSERT(GRPC_SLICE_LENGTH(currently_attempted) >=
-                   GRPC_SLICE_LENGTH(write_buf_));
+        CHECK(GRPC_SLICE_LENGTH(currently_attempted) >=
+              GRPC_SLICE_LENGTH(write_buf_));
         ares_ssize_t total_sent = 0;
         for (size_t i = 0; i < GRPC_SLICE_LENGTH(write_buf_); i++) {
-          GPR_ASSERT(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
-                     GRPC_SLICE_START_PTR(write_buf_)[i]);
+          CHECK(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
+                GRPC_SLICE_START_PTR(write_buf_)[i]);
           total_sent++;
         }
         grpc_core::CSliceUnref(currently_attempted);
@@ -458,9 +459,9 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         " pending_register_for_writeable:%d",
         GetName(), pending_continue_register_for_on_readable_locked_,
         pending_continue_register_for_on_writeable_locked_);
-    GPR_ASSERT(!connect_done_);
+    CHECK(!connect_done_);
     connect_done_ = true;
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK_EQ(wsa_connect_error_, 0);
     if (shutdown_called_) {
       wsa_connect_error_ = WSA_OPERATION_ABORTED;
     } else {
@@ -469,7 +470,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       BOOL wsa_success = WSAGetOverlappedResult(
           winsocket_->raw_socket(), winsocket_->write_info()->overlapped(),
           &transferred_bytes, FALSE, &flags);
-      GPR_ASSERT(transferred_bytes == 0);
+      CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         wsa_connect_error_ = WSAGetLastError();
         char* msg = gpr_format_message(wsa_connect_error_);
@@ -491,8 +492,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   int ConnectUDP(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
                  ares_socklen_t target_len) {
     GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s ConnectUDP", GetName());
-    GPR_ASSERT(!connect_done_);
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK(!connect_done_);
+    CHECK_EQ(wsa_connect_error_, 0);
     SOCKET s = winsocket_->raw_socket();
     int out =
         WSAConnect(s, target, target_len, nullptr, nullptr, nullptr, nullptr);
@@ -620,7 +621,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   void OnIocpWriteable() {
     grpc_core::MutexLock lock(mu_);
     GRPC_ARES_RESOLVER_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
-    GPR_ASSERT(socket_type_ == SOCK_STREAM);
+    CHECK(socket_type_ == SOCK_STREAM);
     absl::Status error;
     if (winsocket_->write_info()->result().wsa_error != 0) {
       error = GRPC_WSA_ERROR(winsocket_->write_info()->result().wsa_error,
@@ -631,7 +632,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
           GetName(), winsocket_->write_info()->result().wsa_error,
           grpc_core::StatusToString(error).c_str());
     }
-    GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
+    CHECK(tcp_write_state_ == WRITE_PENDING);
     if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
@@ -712,7 +713,7 @@ class CustomSockFuncs {
     GRPC_ARES_RESOLVER_TRACE_LOG(
         "fd:|%s| created with params af:%d type:%d protocol:%d",
         polled_fd->GetName(), af, type, protocol);
-    GPR_ASSERT(self->sockets_.insert({s, std::move(polled_fd)}).second);
+    CHECK(self->sockets_.insert({s, std::move(polled_fd)}).second);
     return s;
   }
 
@@ -722,7 +723,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->Connect(&wsa_error_ctx, target, target_len);
   }
 
@@ -732,7 +733,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->SendV(&wsa_error_ctx, iov, iovec_count);
   }
 
@@ -743,7 +744,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->RecvFrom(&wsa_error_ctx, data, data_len, flags, from,
                                 from_len);
   }
@@ -802,7 +803,7 @@ void GrpcPolledFdFactoryWindows::Initialize(grpc_core::Mutex* mutex,
 std::unique_ptr<GrpcPolledFd> GrpcPolledFdFactoryWindows::NewGrpcPolledFdLocked(
     ares_socket_t as) {
   auto it = sockets_.find(as);
-  GPR_ASSERT(it != sockets_.end());
+  CHECK(it != sockets_.end());
   return std::make_unique<GrpcPolledFdWrapper>(it->second.get());
 }
 

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

@@ -17,6 +17,7 @@
 
 #include <chrono>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
@@ -24,7 +25,6 @@
 
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/time_util.h"
-#include "src/core/lib/event_engine/trace.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/crash.h"
@@ -37,7 +37,7 @@ IOCP::IOCP(ThreadPool* thread_pool) noexcept
     : thread_pool_(thread_pool),
       iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr,
                                           (ULONG_PTR) nullptr, 0)) {
-  GPR_ASSERT(iocp_handle_);
+  CHECK(iocp_handle_);
   WSASocketFlagsInit();
 }
 
@@ -54,18 +54,18 @@ std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
         GRPC_WSA_ERROR(WSAGetLastError(), "Unable to add socket to iocp")
             .ToString());
   }
-  GPR_ASSERT(ret == iocp_handle_);
+  CHECK(ret == iocp_handle_);
   return wrapped_socket;
 }
 
 void IOCP::Shutdown() {
-  GRPC_EVENT_ENGINE_POLLER_TRACE(
-      "IOCP::%p shutting down. Outstanding kicks: %d", this,
-      outstanding_kicks_.load());
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "IOCP::" << this
+      << " shutting down. Outstanding kicks: " << outstanding_kicks_.load();
   while (outstanding_kicks_.load() > 0) {
     Work(std::chrono::hours(42), []() {});
   }
-  GPR_ASSERT(CloseHandle(iocp_handle_));
+  CHECK(CloseHandle(iocp_handle_));
 }
 
 Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
@@ -73,17 +73,20 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
   DWORD bytes = 0;
   ULONG_PTR completion_key;
   LPOVERLAPPED overlapped;
-  GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p doing work", this);
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "IOCP::" << this << " doing work";
   BOOL success = GetQueuedCompletionStatus(
       iocp_handle_, &bytes, &completion_key, &overlapped,
       static_cast<DWORD>(Milliseconds(timeout)));
   if (success == 0 && overlapped == nullptr) {
-    GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p deadline exceeded", this);
+    GRPC_TRACE_LOG(event_engine_poller, INFO)
+        << "IOCP::" << this << " deadline exceeded";
     return Poller::WorkResult::kDeadlineExceeded;
   }
-  GPR_ASSERT(completion_key && overlapped);
+  CHECK(completion_key);
+  CHECK(overlapped);
   if (overlapped == &kick_overlap_) {
-    GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p kicked", this);
+    GRPC_TRACE_LOG(event_engine_poller, INFO) << "IOCP::" << this << " kicked";
     outstanding_kicks_.fetch_sub(1);
     if (completion_key == (ULONG_PTR)&kick_token_) {
       return Poller::WorkResult::kKicked;
@@ -91,8 +94,8 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
     grpc_core::Crash(
         absl::StrFormat("Unknown custom completion key: %lu", completion_key));
   }
-  GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p got event on OVERLAPPED::%p", this,
-                                 overlapped);
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "IOCP::" << this << " got event on OVERLAPPED::" << overlapped;
   // Safety note: socket is guaranteed to exist when managed by a
   // WindowsEndpoint. If an overlapped event came in, then either a read event
   // handler is registered, which keeps the socket alive, or the WindowsEndpoint
@@ -100,7 +103,7 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
   // about to register for notification of an overlapped event.
   auto* socket = reinterpret_cast<WinSocket*>(completion_key);
   WinSocket::OpState* info = socket->GetOpInfoForOverlapped(overlapped);
-  GPR_ASSERT(info != nullptr);
+  CHECK_NE(info, nullptr);
   info->GetOverlappedResult();
   info->SetReady();
   schedule_poll_again();
@@ -109,9 +112,9 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
 
 void IOCP::Kick() {
   outstanding_kicks_.fetch_add(1);
-  GPR_ASSERT(PostQueuedCompletionStatus(
-      iocp_handle_, 0, reinterpret_cast<ULONG_PTR>(&kick_token_),
-      &kick_overlap_));
+  CHECK(PostQueuedCompletionStatus(iocp_handle_, 0,
+                                   reinterpret_cast<ULONG_PTR>(&kick_token_),
+                                   &kick_overlap_));
 }
 
 DWORD IOCP::GetDefaultSocketFlags() {

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

@@ -32,7 +32,7 @@ namespace experimental {
 class IOCP final : public Poller {
  public:
   explicit IOCP(ThreadPool* thread_pool) noexcept;
-  ~IOCP();
+  ~IOCP() override;
   // Not copyable
   IOCP(const IOCP&) = delete;
   IOCP& operator=(const IOCP&) = delete;

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

@@ -14,12 +14,14 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GPR_WINDOWS
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #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/windows/win_socket.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -45,8 +47,9 @@ WinSocket::WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept
       write_info_(this) {}
 
 WinSocket::~WinSocket() {
-  GPR_ASSERT(is_shutdown_.load());
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p destroyed", this);
+  CHECK(is_shutdown_.load());
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " destroyed";
 }
 
 SOCKET WinSocket::raw_socket() { return socket_; }
@@ -54,8 +57,8 @@ SOCKET WinSocket::raw_socket() { return socket_; }
 void WinSocket::Shutdown() {
   // if already shutdown, return early. Otherwise, set the shutdown flag.
   if (is_shutdown_.exchange(true)) {
-    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p already shutting down",
-                                     this);
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << "WinSocket::" << this << " already shutting down";
     return;
   }
   // Grab the function pointer for DisconnectEx for that specific socket.
@@ -66,35 +69,43 @@ void WinSocket::Shutdown() {
   int status = WSAIoctl(socket_, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid,
                         sizeof(guid), &DisconnectEx, sizeof(DisconnectEx),
                         &ioctl_num_bytes, NULL, NULL);
-
-  if (status == 0) {
-    DisconnectEx(socket_, NULL, 0, 0);
-  } else {
+  if (status != 0) {
     char* utf8_message = gpr_format_message(WSAGetLastError());
-    gpr_log(GPR_INFO, "Unable to retrieve DisconnectEx pointer : %s",
-            utf8_message);
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << "Unable to retrieve DisconnectEx pointer : " << utf8_message;
     gpr_free(utf8_message);
+  } else if (DisconnectEx(socket_, NULL, 0, 0) == FALSE) {
+    auto last_error = WSAGetLastError();
+    // DisconnectEx may be called when the socket is not connected. Ignore that
+    // error, and log all others.
+    if (last_error != WSAENOTCONN) {
+      char* utf8_message = gpr_format_message(last_error);
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "DisconnectEx failed: " << utf8_message;
+      gpr_free(utf8_message);
+    }
   }
   closesocket(socket_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p socket closed", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " socket closed";
 }
 
 void WinSocket::Shutdown(const grpc_core::DebugLocation& location,
                          absl::string_view reason) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "WinSocket::%p Shut down from %s:%d. Reason: %s", this, location.file(),
-      location.line(), reason.data());
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " Shut down from " << location.file() << ":"
+      << location.line() << ". Reason: " << reason.data();
   Shutdown();
 }
 
 void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
   if (IsShutdown()) {
-    info.SetError(WSAESHUTDOWN);
+    info.SetResult(WSAESHUTDOWN, 0, "NotifyOnReady");
     thread_pool_->Run(closure);
     return;
   };
   // It is an error if any notification is already registered for this socket.
-  GPR_ASSERT(std::exchange(info.closure_, closure) == nullptr);
+  CHECK_EQ(std::exchange(info.closure_, closure), nullptr);
 }
 
 void WinSocket::NotifyOnRead(EventEngine::Closure* on_read) {
@@ -106,11 +117,11 @@ void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
 }
 
 void WinSocket::UnregisterReadCallback() {
-  GPR_ASSERT(std::exchange(read_info_.closure_, nullptr) != nullptr);
+  CHECK_NE(std::exchange(read_info_.closure_, nullptr), nullptr);
 }
 
 void WinSocket::UnregisterWriteCallback() {
-  GPR_ASSERT(std::exchange(write_info_.closure_, nullptr) != nullptr);
+  CHECK_NE(std::exchange(write_info_.closure_, nullptr), nullptr);
 }
 
 // ---- WinSocket::OpState ----
@@ -124,16 +135,17 @@ void WinSocket::OpState::SetReady() {
   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);
+  CHECK_NE(closure, nullptr);
   win_socket_->thread_pool_->Run(closure);
 }
 
-void WinSocket::OpState::SetError(int wsa_error) {
-  result_ = OverlappedResult{/*wsa_error=*/wsa_error, /*bytes_transferred=*/0};
-}
-
-void WinSocket::OpState::SetResult(OverlappedResult result) {
-  result_ = result;
+void WinSocket::OpState::SetResult(int wsa_error, DWORD bytes,
+                                   absl::string_view context) {
+  bytes = wsa_error == 0 ? bytes : 0;
+  result_ = OverlappedResult{
+      /*wsa_error=*/wsa_error, /*bytes_transferred=*/bytes,
+      /*error_status=*/wsa_error == 0 ? absl::OkStatus()
+                                      : GRPC_WSA_ERROR(wsa_error, context)};
 }
 
 void WinSocket::OpState::SetErrorStatus(absl::Status error_status) {
@@ -147,25 +159,25 @@ void WinSocket::OpState::GetOverlappedResult() {
 
 void WinSocket::OpState::GetOverlappedResult(SOCKET sock) {
   if (win_socket_->IsShutdown()) {
-    result_ = OverlappedResult{/*wsa_error=*/WSA_OPERATION_ABORTED,
-                               /*bytes_transferred=*/0};
+    SetResult(WSA_OPERATION_ABORTED, 0, "GetOverlappedResult");
     return;
   }
   DWORD flags = 0;
   DWORD bytes;
   BOOL success =
       WSAGetOverlappedResult(sock, &overlapped_, &bytes, FALSE, &flags);
-  result_ = OverlappedResult{/*wsa_error=*/success ? 0 : WSAGetLastError(),
-                             /*bytes_transferred=*/bytes};
+  auto wsa_error = success ? 0 : WSAGetLastError();
+  SetResult(wsa_error, bytes, "WSAGetOverlappedResult");
 }
 
 bool WinSocket::IsShutdown() { return is_shutdown_.load(); }
 
 WinSocket::OpState* WinSocket::GetOpInfoForOverlapped(OVERLAPPED* overlapped) {
-  GRPC_EVENT_ENGINE_POLLER_TRACE(
-      "WinSocket::%p looking for matching OVERLAPPED::%p. "
-      "read(%p) write(%p)",
-      this, overlapped, &read_info_.overlapped_, &write_info_.overlapped_);
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "WinSocket::" << this
+      << " looking for matching OVERLAPPED::" << overlapped << ". read("
+      << &read_info_.overlapped_ << ") write(" << &write_info_.overlapped_
+      << ")";
   if (overlapped == &read_info_.overlapped_) return &read_info_;
   if (overlapped == &write_info_.overlapped_) return &write_info_;
   return nullptr;

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

@@ -47,12 +47,11 @@ class WinSocket {
     // the WinSocket's ThreadPool. Otherwise, a "pending iocp" flag will
     // be set.
     void SetReady();
-    // 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 WSA result for a completed op.
+    // If the error is non-zero, bytes will be overridden to 0.
+    void SetResult(int wsa_error, DWORD bytes, absl::string_view context);
     // Set error results for a completed op.
-    // This is a manual override, meant to override any WSA status code.
+    // This is a manual override, meant to ignore any WSA status code.
     void SetErrorStatus(absl::Status error_status);
     // Retrieve the results of an overlapped operation (via Winsock API) and
     // store them locally.