grpc 1.52.0 → 1.53.0.pre2

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

@@ -27,14 +27,15 @@
 #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"
+#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 IOCP::IOCP(Executor* executor) noexcept
     : executor_(executor),
-      iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL,
-                                          (ULONG_PTR)NULL, 0)) {
+      iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr,
+                                          (ULONG_PTR) nullptr, 0)) {
   GPR_ASSERT(iocp_handle_);
   WSASocketFlagsInit();
 }
@@ -48,17 +49,18 @@ std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
       reinterpret_cast<HANDLE>(socket), iocp_handle_,
       reinterpret_cast<uintptr_t>(wrapped_socket.get()), 0);
   if (!ret) {
-    char* utf8_message = gpr_format_message(WSAGetLastError());
-    gpr_log(GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
-    gpr_free(utf8_message);
-    __debugbreak();
-    abort();
+    grpc_core::Crash(
+        GRPC_WSA_ERROR(WSAGetLastError(), "Unable to add socket to iocp")
+            .ToString());
   }
   GPR_ASSERT(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());
   while (outstanding_kicks_.load() > 0) {
     Work(std::chrono::hours(42), []() {});
   }
@@ -67,56 +69,38 @@ void IOCP::Shutdown() {
 
 Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
                               absl::FunctionRef<void()> schedule_poll_again) {
-  static const absl::Status kDeadlineExceeded = absl::DeadlineExceededError(
-      absl::StrFormat("IOCP::%p: Received no completions", this));
-  static const absl::Status kKicked =
-      absl::AbortedError(absl::StrFormat("IOCP::%p: Awoken from a kick", this));
   DWORD bytes = 0;
   ULONG_PTR completion_key;
   LPOVERLAPPED overlapped;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    gpr_log(GPR_DEBUG, "IOCP::%p doing work", this);
-  }
+  GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p doing work", this);
   BOOL success = GetQueuedCompletionStatus(
       iocp_handle_, &bytes, &completion_key, &overlapped,
       static_cast<DWORD>(Milliseconds(timeout)));
-  if (success == 0 && overlapped == NULL) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-      gpr_log(GPR_DEBUG, "IOCP::%p deadline exceeded", this);
-    }
+  if (success == 0 && overlapped == nullptr) {
+    GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p deadline exceeded", this);
     return Poller::WorkResult::kDeadlineExceeded;
   }
   GPR_ASSERT(completion_key && overlapped);
   if (overlapped == &kick_overlap_) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-      gpr_log(GPR_DEBUG, "IOCP::%p kicked", this);
-    }
+    GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p kicked", this);
     outstanding_kicks_.fetch_sub(1);
     if (completion_key == (ULONG_PTR)&kick_token_) {
       return Poller::WorkResult::kKicked;
     }
     grpc_core::Crash(
-        absl::StrFormat("Unknown custom completion key: %p", completion_key));
+        absl::StrFormat("Unknown custom completion key: %lu", completion_key));
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    gpr_log(GPR_DEBUG, "IOCP::%p got event on OVERLAPPED::%p", this,
-            overlapped);
-  }
-  WinSocket* socket = reinterpret_cast<WinSocket*>(completion_key);
-  // TODO(hork): move the following logic into the WinSocket impl.
+  GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p got event on OVERLAPPED::%p", this,
+                                 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
+  // (which keeps the socket alive) has done an asynchronous WSARecv and is
+  // 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);
-  if (socket->IsShutdown()) {
-    info->SetError(WSAESHUTDOWN);
-  } else {
-    info->GetOverlappedResult();
-  }
-  if (info->closure() != nullptr) {
-    schedule_poll_again();
-    executor_->Run(info->closure());
-    return Poller::WorkResult::kOk;
-  }
-  // No callback registered. Set ready and return an empty set
+  info->GetOverlappedResult();
   info->SetReady();
   schedule_poll_again();
   return Poller::WorkResult::kOk;
@@ -140,7 +124,7 @@ DWORD IOCP::WSASocketFlagsInit() {
   // versions, see
   // https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
   // for details.
-  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
                           wsa_socket_flags | WSA_FLAG_NO_HANDLE_INHERIT);
   if (sock != INVALID_SOCKET) {
     // Windows 7, Windows 2008 R2 with SP1 or later

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

@@ -11,8 +11,8 @@
 // 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_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -66,4 +66,4 @@ class IOCP final : public Poller {
 
 #endif
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_IOCP_H

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

@@ -18,8 +18,10 @@
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.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"
 #include "src/core/lib/iomgr/error.h"
 
@@ -34,28 +36,29 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+// ---- WinSocket ----
+
 WinSocket::WinSocket(SOCKET socket, Executor* executor) noexcept
     : socket_(socket),
       executor_(executor),
-      read_info_(OpState(this)),
-      write_info_(OpState(this)) {}
+      read_info_(this),
+      write_info_(this) {}
 
-WinSocket::~WinSocket() { GPR_ASSERT(is_shutdown_.load()); }
+WinSocket::~WinSocket() {
+  GPR_ASSERT(is_shutdown_.load());
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p destroyed", this);
+}
 
-SOCKET WinSocket::socket() { return socket_; }
+SOCKET WinSocket::raw_socket() { return socket_; }
 
-void WinSocket::MaybeShutdown(absl::Status why) {
+void WinSocket::Shutdown() {
   // if already shutdown, return early. Otherwise, set the shutdown flag.
   if (is_shutdown_.exchange(true)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-      gpr_log(GPR_DEBUG, "WinSocket::%p already shutting down", this);
-    }
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p already shutting down",
+                                     this);
     return;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    gpr_log(GPR_DEBUG, "WinSocket::%p shutting down now. Reason: %s", this,
-            why.ToString().c_str());
-  }
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p shutting down now.", this);
   // Grab the function pointer for DisconnectEx for that specific socket.
   // It may change depending on the interface.
   GUID guid = WSAID_DISCONNECTEX;
@@ -74,6 +77,15 @@ void WinSocket::MaybeShutdown(absl::Status why) {
     gpr_free(utf8_message);
   }
   closesocket(socket_);
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p socket closed", this);
+}
+
+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());
+  Shutdown();
 }
 
 void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
@@ -85,7 +97,8 @@ void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
   if (std::exchange(info.has_pending_iocp_, false)) {
     executor_->Run(closure);
   } else {
-    info.closure_ = closure;
+    EventEngine::Closure* prev = nullptr;
+    GPR_ASSERT(info.closure_.compare_exchange_strong(prev, closure));
   }
 }
 
@@ -97,46 +110,56 @@ void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
   NotifyOnReady(write_info_, on_write);
 }
 
+// ---- WinSocket::OpState ----
+
 WinSocket::OpState::OpState(WinSocket* win_socket) noexcept
-    : win_socket_(win_socket), closure_(nullptr) {}
+    : win_socket_(win_socket) {
+  memset(&overlapped_, 0, sizeof(OVERLAPPED));
+}
 
 void WinSocket::OpState::SetReady() {
   GPR_ASSERT(!has_pending_iocp_);
-  if (closure_) {
-    win_socket_->executor_->Run(closure_);
+  auto* closure = closure_.exchange(nullptr);
+  if (closure) {
+    win_socket_->executor_->Run(closure);
   } else {
     has_pending_iocp_ = true;
   }
 }
 
 void WinSocket::OpState::SetError(int wsa_error) {
-  bytes_transferred_ = 0;
-  wsa_error_ = wsa_error;
+  result_ = OverlappedResult{/*wsa_error=*/wsa_error, /*bytes_transferred=*/0};
+}
+
+void WinSocket::OpState::SetResult(OverlappedResult result) {
+  result_ = result;
 }
 
 void WinSocket::OpState::GetOverlappedResult() {
+  GetOverlappedResult(win_socket_->raw_socket());
+}
+
+void WinSocket::OpState::GetOverlappedResult(SOCKET sock) {
+  if (win_socket_->IsShutdown()) {
+    result_ = OverlappedResult{/*wsa_error=*/WSA_OPERATION_ABORTED,
+                               /*bytes_transferred=*/0};
+    return;
+  }
   DWORD flags = 0;
   DWORD bytes;
-  BOOL success = WSAGetOverlappedResult(win_socket_->socket(), &overlapped_,
-                                        &bytes, FALSE, &flags);
-  bytes_transferred_ = bytes;
-  wsa_error_ = success ? 0 : WSAGetLastError();
+  BOOL success =
+      WSAGetOverlappedResult(sock, &overlapped_, &bytes, FALSE, &flags);
+  result_ = OverlappedResult{/*wsa_error=*/success ? 0 : WSAGetLastError(),
+                             /*bytes_transferred=*/bytes};
 }
 
-void WinSocket::SetReadable() { read_info_.SetReady(); }
-
-void WinSocket::SetWritable() { write_info_.SetReady(); }
-
 bool WinSocket::IsShutdown() { return is_shutdown_.load(); }
 
 WinSocket::OpState* WinSocket::GetOpInfoForOverlapped(OVERLAPPED* overlapped) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    gpr_log(GPR_DEBUG,
-            "WinSocket::%p looking for matching OVERLAPPED::%p. "
-            "read(%p) write(%p)",
-            this, overlapped, &read_info_.overlapped_,
-            &write_info_.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_);
   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

@@ -11,8 +11,8 @@
 // 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_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
 
 #include <grpc/support/port_platform.h>
 
@@ -24,14 +24,19 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/event_engine/executor/executor.h"
-#include "src/core/lib/event_engine/socket_notifier.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-class WinSocket final : public SocketNotifier {
+class WinSocket {
  public:
+  struct OverlappedResult {
+    int wsa_error;
+    DWORD bytes_transferred;
+  };
+
   // State related to a Read or Write socket operation
   class OpState {
    public:
@@ -43,25 +48,28 @@ class WinSocket final : public SocketNotifier {
     void SetReady();
     // Set error results for a completed op
     void SetError(int wsa_error);
-    // Retrieve results of overlapped operation (via Winsock API)
+    // Set an OverlappedResult. Useful when WSARecv returns immediately.
+    void SetResult(OverlappedResult result);
+    // Retrieve the results of an overlapped operation (via Winsock API) and
+    // store them locally.
     void GetOverlappedResult();
+    // Retrieve the results of an overlapped operation (via Winsock API) and
+    // store them locally. This overload allows acceptance of connections on new
+    // sockets.
+    void GetOverlappedResult(SOCKET sock);
+    // Retrieve the cached result from GetOverlappedResult
+    const OverlappedResult& result() const { return result_; }
     // OVERLAPPED, needed for Winsock API calls
     LPOVERLAPPED overlapped() { return &overlapped_; }
-    // Data from the previous operation, set via GetOverlappedResult
-    DWORD bytes_transferred() const { return bytes_transferred_; }
-    // Previous error if set.
-    int wsa_error() const { return wsa_error_; }
-    EventEngine::Closure* closure() { return closure_; }
 
    private:
     friend class WinSocket;
 
     OVERLAPPED overlapped_;
     WinSocket* win_socket_ = nullptr;
-    EventEngine::Closure* closure_ = nullptr;
+    std::atomic<EventEngine::Closure*> closure_{nullptr};
     bool has_pending_iocp_ = false;
-    DWORD bytes_transferred_;
-    int wsa_error_;
+    OverlappedResult result_;
   };
 
   WinSocket(SOCKET socket, Executor* executor) noexcept;
@@ -70,16 +78,17 @@ class WinSocket final : public SocketNotifier {
   //  - 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.
-  void NotifyOnRead(EventEngine::Closure* on_read) override;
-  void NotifyOnWrite(EventEngine::Closure* on_write) override;
-  void SetReadable() override;
-  void SetWritable() override;
-  // Schedule a shutdown of the socket operations. Will call the pending
-  // operations to abort them. We need to do that this way because of the
-  // various callsites of that function, which happens to be in various
-  // mutex hold states, and that'd be unsafe to call them directly.
-  void MaybeShutdown(absl::Status why) override;
-  bool IsShutdown() override;
+  void NotifyOnRead(EventEngine::Closure* on_read);
+  void NotifyOnWrite(EventEngine::Closure* on_write);
+  bool IsShutdown();
+  // Shutdown socket operations, but do not delete the WinSocket.
+  // Connections will be disconnected, and the socket will be closed.
+  // If the socket is managed by a shared_ptr (most should be), then the
+  // WinSocket will be deleted when the last outstanding overlapped event comes
+  // back.
+  void Shutdown();
+  void Shutdown(const grpc_core::DebugLocation& location,
+                absl::string_view reason);
 
   // Return the appropriate OpState for a given OVERLAPPED
   // Returns nullptr if the overlapped does not match either read or write ops.
@@ -88,7 +97,7 @@ class WinSocket final : public SocketNotifier {
   OpState* read_info() { return &read_info_; }
   OpState* write_info() { return &write_info_; }
   // Accessor method for underlying socket
-  SOCKET socket();
+  SOCKET raw_socket();
 
  private:
   void NotifyOnReady(OpState& info, EventEngine::Closure* closure);
@@ -117,4 +126,4 @@ absl::Status PrepareSocket(SOCKET sock);
 
 #endif
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WIN_SOCKET_H