grpc 1.75.0 → 1.78.0

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

@@ -50,12 +50,9 @@
 
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/memory_allocator_factory.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
 #include "src/core/lib/event_engine/query_extensions.h"
@@ -74,7 +71,11 @@
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/strerror.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 static std::atomic<int64_t> num_dropped_connections{0};
 static constexpr grpc_core::Duration kRetryAcceptWaitTime{
@@ -89,7 +90,13 @@ using ::grpc_event_engine::experimental::SliceBuffer;
 
 static void finish_shutdown(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
-  CHECK(s->shutdown);
+  GRPC_CHECK(s->shutdown);
+  if (grpc_core::ExecCtx::Get() == nullptr) {
+    grpc_core::ExecCtx exec_ctx;
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
+  } else {
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
+  }
   gpr_mu_unlock(&s->mu);
   if (s->shutdown_complete != nullptr) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->shutdown_complete,
@@ -157,10 +164,17 @@ static grpc_error_handle CreateEventEngineListener(
               addr.len =
                   static_cast<socklen_t>(sizeof(struct sockaddr_storage));
               // Get the fd of the socket connected to peer.
-              int fd =
-                  reinterpret_cast<
-                      grpc_event_engine::experimental::PosixEndpoint*>(ep.get())
-                      ->GetWrappedFd();
+              auto* supports_fd =
+                  grpc_event_engine::experimental::QueryExtension<
+                      grpc_event_engine::experimental::
+                          EndpointSupportsFdExtension>(ep.get());
+              if (supports_fd == nullptr) {
+                LOG(ERROR)
+                    << "SERVER_CONNECT ERROR: unsupported endpoint created. "
+                       "Endpoint doesn't support file descriptor extension. ";
+                return;
+              }
+              int fd = supports_fd->GetWrappedFd();
               if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                               &(addr.len)) < 0) {
                 LOG(ERROR) << "Failed getpeername: "
@@ -230,7 +244,7 @@ static grpc_error_handle CreateEventEngineListener(
     listener = engine->CreateListener(
         std::move(accept_cb),
         [s, ee = keeper, shutdown_complete](absl::Status status) {
-          CHECK_EQ(gpr_atm_no_barrier_load(&s->refs.count), 0);
+          GRPC_CHECK_EQ(gpr_atm_no_barrier_load(&s->refs.count), 0);
           grpc_event_engine::experimental::RunEventEngineClosure(
               shutdown_complete, absl_status_to_grpc_error(status));
           finish_shutdown(s);
@@ -271,6 +285,8 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->shutdown = false;
   s->shutdown_starting.head = nullptr;
   s->shutdown_starting.tail = nullptr;
+  s->shutdown_ending.head = nullptr;
+  s->shutdown_ending.tail = nullptr;
   if (!grpc_event_engine::experimental::UseEventEngineListener()) {
     s->shutdown_complete = shutdown_complete;
   } else {
@@ -283,8 +299,8 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->nports = 0;
   s->options = ::TcpOptionsFromEndpointConfig(config);
   s->fd_handler = nullptr;
-  CHECK(s->options.resource_quota != nullptr);
-  CHECK(s->on_accept_cb);
+  GRPC_CHECK(s->options.resource_quota != nullptr);
+  GRPC_CHECK(s->on_accept_cb);
   s->memory_quota = s->options.resource_quota->memory_quota();
   s->pre_allocated_fd = -1;
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
@@ -306,7 +322,7 @@ static void destroyed_port(void* server, grpc_error_handle /*error*/) {
     gpr_mu_unlock(&s->mu);
     finish_shutdown(s);
   } else {
-    CHECK(s->destroyed_ports < s->nports);
+    GRPC_CHECK(s->destroyed_ports < s->nports);
     gpr_mu_unlock(&s->mu);
   }
 }
@@ -318,7 +334,7 @@ static void deactivated_all_ports(grpc_tcp_server* s) {
   // delete ALL the things
   gpr_mu_lock(&s->mu);
 
-  CHECK(s->shutdown);
+  GRPC_CHECK(s->shutdown);
 
   if (s->head) {
     grpc_tcp_listener* sp;
@@ -347,7 +363,7 @@ static void deactivated_all_ports(grpc_tcp_server* s) {
 
 static void tcp_server_destroy(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
-  CHECK(!s->shutdown);
+  GRPC_CHECK(!s->shutdown);
   s->shutdown = true;
   // shutdown all fd's
   if (s->active_ports) {
@@ -413,7 +429,8 @@ static void on_read(void* arg, grpc_error_handle err) {
       goto error;
     }
 
-    if (sp->server->memory_quota->IsMemoryPressureHigh()) {
+    if (sp->server->memory_quota
+            ->RejectNewConnectionsUnderHighMemoryPressure()) {
       int64_t dropped_connections_count =
           num_dropped_connections.fetch_add(1, std::memory_order_relaxed) + 1;
       if (dropped_connections_count % 1000 == 1) {
@@ -550,8 +567,8 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
   } else {
     grpc_error_handle root_err =
         GRPC_ERROR_CREATE("Failed to add any wildcard listeners");
-    CHECK(!v6_err.ok());
-    CHECK(!v4_err.ok());
+    GRPC_CHECK(!v6_err.ok());
+    GRPC_CHECK(!v4_err.ok());
     root_err = grpc_error_add_child(root_err, v6_err);
     root_err = grpc_error_add_child(root_err, v4_err);
     return root_err;
@@ -602,7 +619,7 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     sp->port = port;
     sp->port_index = listener->port_index;
     sp->fd_index = listener->fd_index + count - i;
-    CHECK(sp->emfd);
+    GRPC_CHECK(sp->emfd);
     grpc_tcp_server_listener_initialize_retry_timer(sp);
     while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
@@ -634,7 +651,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
             if (!listen_fd.ok()) {
               return;
             }
-            DCHECK_GT(*listen_fd, 0);
+            GRPC_DCHECK_GT(*listen_fd, 0);
             s->listen_fd_to_index_map.insert_or_assign(
                 *listen_fd, std::tuple(s->n_bind_ports, fd_index++));
           });
@@ -649,7 +666,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     gpr_mu_unlock(&s->mu);
     return port.status();
   }
-  CHECK(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
+  GRPC_CHECK(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
   grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
   grpc_resolved_address addr6_v4mapped;
@@ -777,12 +794,12 @@ static void tcp_server_start(grpc_tcp_server* s,
   size_t i;
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  CHECK(s->on_accept_cb);
-  CHECK_EQ(s->active_ports, 0u);
+  GRPC_CHECK(s->on_accept_cb);
+  GRPC_CHECK_EQ(s->active_ports, 0u);
   s->pollsets = pollsets;
   if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    CHECK(!s->shutdown_listeners);
-    CHECK(GRPC_LOG_IF_ERROR("listener_start", s->ee_listener->Start()));
+    GRPC_CHECK(!s->shutdown_listeners);
+    GRPC_CHECK(GRPC_LOG_IF_ERROR("listener_start", s->ee_listener->Start()));
     gpr_mu_unlock(&s->mu);
     return;
   }
@@ -790,7 +807,7 @@ static void tcp_server_start(grpc_tcp_server* s,
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
         !grpc_is_vsock(&sp->addr) && pollsets->size() > 1) {
-      CHECK(GRPC_LOG_IF_ERROR(
+      GRPC_CHECK(GRPC_LOG_IF_ERROR(
           "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1))));
       for (i = 0; i < pollsets->size(); i++) {
         grpc_pollset_add_fd((*pollsets)[i], sp->emfd);
@@ -827,11 +844,24 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
   gpr_mu_unlock(&s->mu);
 }
 
+static void tcp_server_shutdown_ending_add(grpc_tcp_server* s,
+                                           grpc_closure* shutdown_ending) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
+                           absl::OkStatus());
+  gpr_mu_unlock(&s->mu);
+}
+
 static void tcp_server_unref(grpc_tcp_server* s) {
   if (gpr_unref(&s->refs)) {
     grpc_tcp_server_shutdown_listeners(s);
     gpr_mu_lock(&s->mu);
-    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
+    if (grpc_core::ExecCtx::Get() == nullptr) {
+      grpc_core::ExecCtx exec_ctx;
+      grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
+    } else {
+      grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
+    }
     gpr_mu_unlock(&s->mu);
     tcp_server_destroy(s);
   }
@@ -882,16 +912,16 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
           grpc_event_engine::experimental::QueryExtension<
               grpc_event_engine::experimental::ListenerSupportsFdExtension>(
               s_->ee_listener.get());
-      CHECK_NE(listener_supports_fd, nullptr);
+      GRPC_CHECK_NE(listener_supports_fd, nullptr);
       grpc_event_engine::experimental::SliceBuffer pending_data;
       if (buf != nullptr) {
         pending_data =
             grpc_event_engine::experimental::SliceBuffer::TakeCSliceBuffer(
                 buf->data.raw.slice_buffer);
       }
-      CHECK(GRPC_LOG_IF_ERROR("listener_handle_external_connection",
-                              listener_supports_fd->HandleExternalConnection(
-                                  listener_fd, fd, &pending_data)));
+      GRPC_LOG_IF_ERROR("listener_handle_external_connection",
+                        listener_supports_fd->HandleExternalConnection(
+                            listener_fd, fd, &pending_data));
       return;
     }
     grpc_pollset* read_notifier_pollset;
@@ -960,6 +990,7 @@ grpc_tcp_server_vtable grpc_posix_tcp_server_vtable = {
     tcp_server_port_fd,
     tcp_server_ref,
     tcp_server_shutdown_starting_add,
+    tcp_server_shutdown_ending_add,
     tcp_server_unref,
     tcp_server_shutdown_listeners,
     tcp_server_pre_allocated_fd,

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

@@ -23,7 +23,6 @@
 
 #include <memory>
 
-#include "absl/container/flat_hash_map.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -31,6 +30,7 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
+#include "absl/container/flat_hash_map.h"
 
 // one listening port
 typedef struct grpc_tcp_listener {
@@ -90,6 +90,9 @@ struct grpc_tcp_server {
   // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting{nullptr, nullptr};
 
+  // List of closures passed to shutdown_ending_add().
+  grpc_closure_list shutdown_ending{nullptr, nullptr};
+
   // shutdown callback
   grpc_closure* shutdown_complete = nullptr;
 

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

@@ -33,9 +33,6 @@
 
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -43,6 +40,9 @@
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/vsock.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -109,7 +109,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   grpc_error_handle err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
   if (!err.ok()) return err;
-  CHECK_GT(port, 0);
+  GRPC_CHECK_GT(port, 0);
   absl::StatusOr<std::string> addr_str = grpc_sockaddr_to_string(addr, true);
   if (!addr_str.ok()) {
     return GRPC_ERROR_CREATE(addr_str.status().ToString());
@@ -142,7 +142,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   sp->fd_index = fd_index;
   sp->is_sibling = 0;
   sp->sibling = nullptr;
-  CHECK(sp->emfd);
+  GRPC_CHECK(sp->emfd);
   gpr_mu_unlock(&s->mu);
 
   *listener = sp;
@@ -206,7 +206,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   grpc_resolved_address sockname_temp;
   grpc_error_handle err;
 
-  CHECK_GE(fd, 0);
+  GRPC_CHECK_GE(fd, 0);
 
   if (so_reuseport && !grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
@@ -269,7 +269,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   return absl::OkStatus();
 
 error:
-  CHECK(!err.ok());
+  GRPC_CHECK(!err.ok());
   if (fd >= 0) {
     close(fd);
   }

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

@@ -31,14 +31,14 @@
 
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 // Return the listener in s with address addr or NULL.
 static grpc_tcp_listener* find_listener_with_addr(grpc_tcp_server* s,
@@ -165,7 +165,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
-      CHECK(requested_port == new_sp->port);
+      GRPC_CHECK(requested_port == new_sp->port);
       ++fd_index;
       if (sp != nullptr) {
         new_sp->is_sibling = 1;

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

@@ -35,9 +35,6 @@
 
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/memory_allocator_factory.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
@@ -58,6 +55,9 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -123,6 +123,9 @@ struct grpc_tcp_server {
   // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting;
 
+  // List of closures passed to shutdown_ending_add().
+  grpc_closure_list shutdown_ending;
+
   // shutdown callback
   grpc_closure* shutdown_complete;
 
@@ -188,6 +191,8 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->tail = NULL;
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
+  s->shutdown_ending.head = NULL;
+  s->shutdown_ending.tail = NULL;
   s->shutdown_complete = shutdown_complete;
   new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   *server = s;
@@ -219,6 +224,7 @@ static void finish_shutdown_locked(grpc_tcp_server* s) {
                             absl::OkStatus());
   }
 
+  grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
   grpc_core::ExecCtx::Run(
       DEBUG_LOCATION,
       GRPC_CLOSURE_CREATE(destroy_server, s, grpc_schedule_on_exec_ctx),
@@ -238,6 +244,14 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
   gpr_mu_unlock(&s->mu);
 }
 
+static void tcp_server_shutdown_ending_add(grpc_tcp_server* s,
+                                           grpc_closure* shutdown_ending) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
+                           absl::OkStatus());
+  gpr_mu_unlock(&s->mu);
+}
+
 static void tcp_server_destroy(grpc_tcp_server* s) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
@@ -303,7 +317,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return absl::OkStatus();
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
                                         &error, 1);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -312,7 +326,7 @@ failure:
 
 static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
   sp->shutting_down = 0;
-  CHECK_GT(sp->server->active_ports, 0u);
+  GRPC_CHECK_GT(sp->server->active_ports, 0u);
   if (0 == --sp->server->active_ports) {
     finish_shutdown_locked(sp->server);
   }
@@ -370,7 +384,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -463,7 +477,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   // the former socked we created has now either been destroy or assigned
   // to the new connection. We need to create a new one for the next
   // connection.
-  CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+  GRPC_CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
   if (0 == --sp->outstanding_calls) {
     decrement_active_ports_and_notify_locked(sp);
   }
@@ -499,7 +513,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
     return error;
   }
 
-  CHECK_GE(port, 0);
+  GRPC_CHECK_GE(port, 0);
   gpr_mu_lock(&s->mu);
   sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
@@ -519,7 +533,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   sp->port = port;
   sp->port_index = port_index;
   GRPC_CLOSURE_INIT(&sp->on_accept, on_accept, sp, grpc_schedule_on_exec_ctx);
-  CHECK(sp->socket);
+  GRPC_CHECK(sp->socket);
   gpr_mu_unlock(&s->mu);
   *listener = sp;
 
@@ -596,7 +610,7 @@ done:
     error = error_out;
     *port = -1;
   } else {
-    CHECK(sp != NULL);
+    GRPC_CHECK(sp != NULL);
     *port = sp->port;
   }
   return error;
@@ -606,9 +620,9 @@ static void tcp_server_start(grpc_tcp_server* s,
                              const std::vector<grpc_pollset*>* /*pollsets*/) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  CHECK_EQ(s->active_ports, 0u);
+  GRPC_CHECK_EQ(s->active_ports, 0u);
   for (sp = s->head; sp; sp = sp->next) {
-    CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+    GRPC_CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
     s->active_ports++;
   }
   gpr_mu_unlock(&s->mu);
@@ -637,12 +651,19 @@ static int tcp_pre_allocated_fd(grpc_tcp_server* /* s */) { return -1; }
 static void tcp_set_pre_allocated_fd(grpc_tcp_server* /* s */, int /* fd */) {}
 
 grpc_tcp_server_vtable grpc_windows_tcp_server_vtable = {
-    tcp_server_create,        tcp_server_start,
-    tcp_server_add_port,      tcp_server_create_fd_handler,
-    tcp_server_port_fd_count, tcp_server_port_fd,
-    tcp_server_ref,           tcp_server_shutdown_starting_add,
-    tcp_server_unref,         tcp_server_shutdown_listeners,
-    tcp_pre_allocated_fd,     tcp_set_pre_allocated_fd};
+    tcp_server_create,
+    tcp_server_start,
+    tcp_server_add_port,
+    tcp_server_create_fd_handler,
+    tcp_server_port_fd_count,
+    tcp_server_port_fd,
+    tcp_server_ref,
+    tcp_server_shutdown_starting_add,
+    tcp_server_shutdown_ending_add,
+    tcp_server_unref,
+    tcp_server_shutdown_listeners,
+    tcp_pre_allocated_fd,
+    tcp_set_pre_allocated_fd};
 
 // ---- EventEngine shim ------------------------------------------------------
 
@@ -655,7 +676,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
                                              grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
-  CHECK_NE(on_accept_cb, nullptr);
+  GRPC_CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
@@ -677,7 +698,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   {
     void* tmp_quota = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
-    CHECK_NE(tmp_quota, nullptr);
+    GRPC_CHECK_NE(tmp_quota, nullptr);
     resource_quota =
         reinterpret_cast<grpc_core::ResourceQuota*>(tmp_quota)->Ref();
   }
@@ -685,13 +706,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   gpr_mu_init(&s->mu);
   EventEngine* engine = reinterpret_cast<EventEngine*>(
       config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
-  CHECK_NE(engine, nullptr);
+  GRPC_CHECK_NE(engine, nullptr);
   auto listener = engine->CreateListener(
       std::move(accept_cb), std::move(on_shutdown), config,
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
           resource_quota->memory_quota()));
   GRPC_RETURN_IF_ERROR(listener.status());
-  CHECK_NE(listener->get(), nullptr);
+  GRPC_CHECK_NE(listener->get(), nullptr);
   GRPC_TRACE_LOG(event_engine, INFO)
       << "EventEngine::" << engine << ": created Listener::" << listener->get();
   s->ee_listener = std::move(*listener);
@@ -706,6 +727,8 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   s->tail = nullptr;
   s->shutdown_starting.head = nullptr;
   s->shutdown_starting.tail = nullptr;
+  s->shutdown_ending.head = nullptr;
+  s->shutdown_ending.tail = nullptr;
   s->shutdown_complete = grpc_core::NewClosure([](absl::Status) {
     grpc_core::Crash("iomgr shutdown_complete callback should be unused");
   });
@@ -715,13 +738,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
 
 static void event_engine_start(grpc_tcp_server* s,
                                const std::vector<grpc_pollset*>* /*pollsets*/) {
-  CHECK(s->ee_listener->Start().ok());
+  GRPC_CHECK(s->ee_listener->Start().ok());
 }
 
 static grpc_error_handle event_engine_add_port(
     grpc_tcp_server* s, const grpc_resolved_address* addr, int* port) {
-  CHECK_NE(addr, nullptr);
-  CHECK_NE(port, nullptr);
+  GRPC_CHECK_NE(addr, nullptr);
+  GRPC_CHECK_NE(port, nullptr);
   auto ee_addr = CreateResolvedAddress(*addr);
   auto out_port = s->ee_listener->Bind(ee_addr);
   *port = out_port.ok() ? *out_port : -1;
@@ -767,6 +790,7 @@ static void event_engine_unref(grpc_tcp_server* s) {
     gpr_mu_unlock(&s->mu);
     gpr_mu_destroy(&s->mu);
     std::destroy_at(&s->ee_listener);
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
     gpr_free(s);
   }
 }
@@ -779,14 +803,29 @@ static void event_engine_shutdown_starting_add(
   gpr_mu_unlock(&s->mu);
 }
 
+static void event_engine_shutdown_ending_add(grpc_tcp_server* s,
+                                             grpc_closure* shutdown_ending) {
+  gpr_mu_lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
+                           absl::OkStatus());
+  gpr_mu_unlock(&s->mu);
+}
+
 }  // namespace
 
 grpc_tcp_server_vtable grpc_windows_event_engine_tcp_server_vtable = {
-    event_engine_create,        event_engine_start,
-    event_engine_add_port,      event_engine_create_fd_handler,
-    event_engine_port_fd_count, event_engine_port_fd,
-    event_engine_ref,           event_engine_shutdown_starting_add,
-    event_engine_unref,         event_engine_shutdown_listeners,
-    tcp_pre_allocated_fd,       tcp_set_pre_allocated_fd};
+    event_engine_create,
+    event_engine_start,
+    event_engine_add_port,
+    event_engine_create_fd_handler,
+    event_engine_port_fd_count,
+    event_engine_port_fd,
+    event_engine_ref,
+    event_engine_shutdown_starting_add,
+    event_engine_shutdown_ending_add,
+    event_engine_unref,
+    event_engine_shutdown_listeners,
+    tcp_pre_allocated_fd,
+    tcp_set_pre_allocated_fd};
 
 #endif  // GRPC_WINSOCK_SOCKET

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

@@ -27,8 +27,6 @@
 #include <grpc/support/string_util.h>
 #include <limits.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -40,8 +38,10 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/string.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
 // Nasty workaround for nasty bug when using the 64 bits msys compiler
@@ -182,7 +182,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {
-        CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
+        GRPC_CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
         if (static_cast<size_t>(info->bytes_transferred) !=
             tcp->read_slices->length) {
           grpc_slice_buffer_trim_end(
@@ -191,7 +191,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
                   static_cast<size_t>(info->bytes_transferred),
               &tcp->last_read_buffer);
         }
-        CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
+        GRPC_CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
         if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
           size_t i;
@@ -256,7 +256,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           GRPC_SLICE_MALLOC(DEFAULT_TARGET_READ_SIZE));
   }
 
-  CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
+  GRPC_CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
   for (i = 0; i < tcp->read_slices->count; i++) {
     buffers[i].len = (ULONG)GRPC_SLICE_LENGTH(
         tcp->read_slices->slices[i]);  // we know slice size fits in 32bit.
@@ -313,7 +313,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      CHECK(info->bytes_transferred <= tcp->write_slices->length);
+      GRPC_CHECK(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -359,7 +359,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   tcp->write_cb = cb;
   tcp->write_slices = slices;
-  CHECK(tcp->write_slices->count <= UINT_MAX);
+  GRPC_CHECK(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) {
     buffers = (WSABUF*)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count);
     allocated = buffers;
@@ -367,7 +367,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   for (i = 0; i < tcp->write_slices->count; i++) {
     len = GRPC_SLICE_LENGTH(tcp->write_slices->slices[i]);
-    CHECK(len <= ULONG_MAX);
+    GRPC_CHECK(len <= ULONG_MAX);
     buffers[i].len = (ULONG)len;
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }