grpc 1.75.0 → 1.78.1

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

@@ -29,7 +29,6 @@
 
 #include <string>
 
-#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/iomgr/block_annotate.h"
@@ -43,6 +42,7 @@
 #include "src/core/util/host_port.h"
 #include "src/core/util/string.h"
 #include "src/core/util/thd.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_core {
 

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

@@ -39,9 +39,9 @@
 
 #include <string>
 
-#include "absl/log/check.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/util/crash.h"
+#include "absl/log/check.h"
 
 uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
 

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

@@ -46,15 +46,15 @@
 
 #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/sockaddr.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 // set a socket to use zerocopy
 grpc_error_handle grpc_set_socket_zerocopy(int fd) {
@@ -416,7 +416,7 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
 // set a socket using a grpc_socket_mutator
 grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
                                                grpc_socket_mutator* mutator) {
-  CHECK(mutator);
+  GRPC_CHECK(mutator);
   if (!grpc_socket_mutator_mutate_fd(mutator, fd, usage)) {
     return GRPC_ERROR_CREATE("grpc_socket_mutator failed.");
   }

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

@@ -29,9 +29,6 @@
 #include <grpc/support/log_windows.h>
 #include <mswsock.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset.h"
@@ -39,6 +36,9 @@
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_format.h"
 
 static DWORD s_wsa_socket_flags;
 
@@ -157,7 +157,7 @@ void grpc_winsocket_finish(grpc_winsocket* winsocket) {
 
 void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
   gpr_mu_lock(&winsocket->state_mu);
-  CHECK(!winsocket->destroy_called);
+  GRPC_CHECK(!winsocket->destroy_called);
   winsocket->destroy_called = true;
   bool should_destroy = check_destroyable(winsocket);
   gpr_mu_unlock(&winsocket->state_mu);
@@ -172,7 +172,7 @@ void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
 //-) The IOCP hasn't completed yet, and we're queuing it for later.
 static void socket_notify_on_iocp(grpc_winsocket* socket, grpc_closure* closure,
                                   grpc_winsocket_callback_info* info) {
-  CHECK(info->closure == NULL);
+  GRPC_CHECK(info->closure == NULL);
   gpr_mu_lock(&socket->state_mu);
   if (info->has_pending_iocp) {
     info->has_pending_iocp = 0;
@@ -194,7 +194,7 @@ void grpc_socket_notify_on_read(grpc_winsocket* socket, grpc_closure* closure) {
 
 bool grpc_socket_become_ready(grpc_winsocket* socket,
                               grpc_winsocket_callback_info* info) {
-  CHECK(!info->has_pending_iocp);
+  GRPC_CHECK(!info->has_pending_iocp);
   if (info->closure) {
     // Only run the closure once at shutdown.
     if (!info->closure_already_executed_at_shutdown) {

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

@@ -30,7 +30,6 @@
 #include <netinet/in.h>
 #include <string.h>
 
-#include "absl/log/log.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
@@ -43,6 +42,7 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/host_port.h"
+#include "absl/log/log.h"
 
 struct CFStreamConnect {
   gpr_mu mu;

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

@@ -32,10 +32,6 @@
 
 #include <memory>
 
-#include "absl/container/flat_hash_map.h"
-#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/resolved_address_internal.h"
 #include "src/core/lib/event_engine/shim.h"
@@ -53,8 +49,12 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/net/socket_mutator.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/string.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 
@@ -103,7 +103,7 @@ static grpc_error_handle prepare_socket(
     const grpc_core::PosixTcpOptions& options) {
   grpc_error_handle err;
 
-  CHECK_GE(fd, 0);
+  GRPC_CHECK_GE(fd, 0);
 
   err = grpc_set_socket_nonblocking(fd, 1);
   if (!err.ok()) goto error;
@@ -187,7 +187,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
       << ": on_writable: error=" << grpc_core::StatusToString(error);
 
   gpr_mu_lock(&ac->mu);
-  CHECK(ac->fd);
+  GRPC_CHECK(ac->fd);
   fd = ac->fd;
   ac->fd = nullptr;
   bool connect_cancelled = ac->connect_cancelled;
@@ -438,7 +438,7 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
     auto it = shard->pending_connections.find(connection_handle);
     if (it != shard->pending_connections.end()) {
       ac = it->second;
-      CHECK_NE(ac, nullptr);
+      GRPC_CHECK_NE(ac, nullptr);
       // Trying to acquire ac->mu here would could cause a deadlock because
       // the on_writable method tries to acquire the two mutexes used
       // here in the reverse order. But we dont need to acquire ac->mu before

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

@@ -28,7 +28,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
-#include "absl/log/check.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
@@ -42,6 +41,7 @@
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 
@@ -82,7 +82,7 @@ static void on_alarm(void* acp, grpc_error_handle /* error */) {
 static void on_connect(void* acp, grpc_error_handle error) {
   async_connect* ac = (async_connect*)acp;
   grpc_endpoint** ep = ac->endpoint;
-  CHECK(*ep == NULL);
+  GRPC_CHECK(*ep == NULL);
   grpc_closure* on_done = ac->on_done;
 
   gpr_mu_lock(&ac->mu);
@@ -101,7 +101,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
       BOOL wsa_success =
           WSAGetOverlappedResult(socket->socket, &socket->write_info.overlapped,
                                  &transferred_bytes, FALSE, &flags);
-      CHECK_EQ(transferred_bytes, 0);
+      GRPC_CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);
@@ -242,7 +242,7 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   return 0;
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   grpc_error_handle final_error =
       GRPC_ERROR_CREATE_REFERENCING("Failed to connect", &error, 1);
   if (socket != NULL) {

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

@@ -45,12 +45,6 @@
 #include <optional>
 #include <unordered_map>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -70,10 +64,16 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/event_log.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 #ifndef SOL_TCP
 #define SOL_TCP IPPROTO_TCP
@@ -155,7 +155,7 @@ class TcpZerocopySendRecord {
   //  sendmsg() failed or when tcp_write() is done.
   bool Unref() {
     const intptr_t prior = ref_.fetch_sub(1, std::memory_order_acq_rel);
-    DCHECK_GT(prior, 0);
+    GRPC_DCHECK_GT(prior, 0);
     if (prior == 1) {
       AllSendsComplete();
       return true;
@@ -170,9 +170,9 @@ class TcpZerocopySendRecord {
   };
 
   void AssertEmpty() {
-    DCHECK_EQ(buf_.count, 0u);
-    DCHECK_EQ(buf_.length, 0u);
-    DCHECK_EQ(ref_.load(std::memory_order_relaxed), 0);
+    GRPC_DCHECK_EQ(buf_.count, 0u);
+    GRPC_DCHECK_EQ(buf_.length, 0u);
+    GRPC_DCHECK_EQ(ref_.load(std::memory_order_relaxed), 0);
   }
 
   // When all sendmsg() calls associated with this tcp_write() have been
@@ -180,7 +180,7 @@ class TcpZerocopySendRecord {
   // for each sendmsg()) and all reference counts have been dropped, drop our
   // reference to the underlying data since we no longer need it.
   void AllSendsComplete() {
-    DCHECK_EQ(ref_.load(std::memory_order_relaxed), 0);
+    GRPC_DCHECK_EQ(ref_.load(std::memory_order_relaxed), 0);
     grpc_slice_buffer_reset_and_unref(&buf_);
   }
 
@@ -260,7 +260,7 @@ class TcpZerocopySendCtx {
     --last_send_;
     if (ReleaseSendRecord(last_send_)->Unref()) {
       // We should still be holding the ref taken by tcp_write().
-      DCHECK(0);
+      GRPC_DCHECK(0);
     }
   }
 
@@ -296,8 +296,8 @@ class TcpZerocopySendCtx {
   // max_sends_ tcp_write() instances with zerocopy enabled in flight at the
   // same time.
   void PutSendRecord(TcpZerocopySendRecord* record) {
-    DCHECK(record >= send_records_);
-    DCHECK(record < send_records_ + max_sends_);
+    GRPC_DCHECK(record >= send_records_);
+    GRPC_DCHECK(record < send_records_ + max_sends_);
     MutexLock guard(&lock_);
     PutSendRecordLocked(record);
   }
@@ -316,7 +316,7 @@ class TcpZerocopySendCtx {
   bool enabled() const { return enabled_; }
 
   void set_enabled(bool enabled) {
-    DCHECK(!enabled || !memory_limited());
+    GRPC_DCHECK(!enabled || !memory_limited());
     enabled_ = enabled;
   }
 
@@ -354,7 +354,7 @@ class TcpZerocopySendCtx {
       zcopy_enobuf_state_ = OMemState::CHECK;
       return false;
     }
-    DCHECK(zcopy_enobuf_state_ != OMemState::CHECK);
+    GRPC_DCHECK(zcopy_enobuf_state_ != OMemState::CHECK);
     if (zcopy_enobuf_state_ == OMemState::FULL) {
       // A previous sendmsg attempt was blocked by ENOBUFS. Return true to
       // mark the fd as writable so the next write attempt could be made.
@@ -428,7 +428,7 @@ class TcpZerocopySendCtx {
 
   TcpZerocopySendRecord* ReleaseSendRecordLocked(uint32_t seq) {
     auto iter = ctx_lookup_.find(seq);
-    DCHECK(iter != ctx_lookup_.end());
+    GRPC_DCHECK(iter != ctx_lookup_.end());
     TcpZerocopySendRecord* record = iter->second;
     ctx_lookup_.erase(iter);
     return record;
@@ -446,7 +446,7 @@ class TcpZerocopySendCtx {
   }
 
   void PutSendRecordLocked(TcpZerocopySendRecord* record) {
-    DCHECK(free_send_records_size_ < max_sends_);
+    GRPC_DCHECK(free_send_records_size_ < max_sends_);
     free_send_records_[free_send_records_size_] = record;
     free_send_records_size_++;
   }
@@ -635,7 +635,7 @@ static void run_poller(backup_poller* p) {
   g_backup_poller_mu->Lock();
   // last "uncovered" notification is the ref that keeps us polling
   if (g_uncovered_notifications_pending == 1) {
-    CHECK(g_backup_poller == p);
+    GRPC_CHECK(g_backup_poller == p);
     g_backup_poller = nullptr;
     g_uncovered_notifications_pending = 0;
     g_backup_poller_mu->Unlock();
@@ -660,7 +660,7 @@ static void drop_uncovered(grpc_tcp* /*tcp*/) {
   p = g_backup_poller;
   old_count = g_uncovered_notifications_pending--;
   g_backup_poller_mu->Unlock();
-  CHECK_GT(old_count, 1);
+  GRPC_CHECK_GT(old_count, 1);
   GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " uncover cnt "
                             << old_count << "->" << old_count - 1;
 }
@@ -914,8 +914,8 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     iov[i].iov_len = GRPC_SLICE_LENGTH(tcp->incoming_buffer->slices[i]);
   }
 
-  CHECK_NE(tcp->incoming_buffer->length, 0u);
-  DCHECK_GT(tcp->min_progress_size, 0);
+  GRPC_CHECK_NE(tcp->incoming_buffer->length, 0u);
+  GRPC_DCHECK_GT(tcp->min_progress_size, 0);
 
   do {
     // Assume there is something on the queue. If we receive TCP_INQ from
@@ -981,12 +981,12 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
 
     grpc_core::global_stats().IncrementTcpReadSize(read_bytes);
     add_to_estimate(tcp, static_cast<size_t>(read_bytes));
-    DCHECK((size_t)read_bytes <=
-           tcp->incoming_buffer->length - total_read_bytes);
+    GRPC_DCHECK((size_t)read_bytes <=
+                tcp->incoming_buffer->length - total_read_bytes);
 
 #ifdef GRPC_HAVE_TCP_INQ
     if (tcp->inq_capable) {
-      DCHECK(!(msg.msg_flags & MSG_CTRUNC));
+      GRPC_DCHECK(!(msg.msg_flags & MSG_CTRUNC));
       struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
       for (; cmsg != nullptr; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
         if (cmsg->cmsg_level == SOL_TCP && cmsg->cmsg_type == TCP_CM_INQ &&
@@ -1029,7 +1029,7 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     finish_estimate(tcp);
   }
 
-  DCHECK_GT(total_read_bytes, 0u);
+  GRPC_DCHECK_GT(total_read_bytes, 0u);
   *error = absl::OkStatus();
   if (grpc_core::IsTcpFrameSizeTuningEnabled()) {
     // Update min progress size based on the total number of bytes read in
@@ -1146,7 +1146,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
 static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
                      grpc_closure* cb, bool urgent, int min_progress_size) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  CHECK_EQ(tcp->read_cb, nullptr);
+  GRPC_CHECK_EQ(tcp->read_cb, nullptr);
   tcp->read_cb = cb;
   tcp->read_mu.Lock();
   tcp->incoming_buffer = incoming_buffer;
@@ -1228,8 +1228,8 @@ static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
     }
     if (zerocopy_send_record != nullptr) {
       zerocopy_send_record->PrepareForSends(buf);
-      DCHECK_EQ(buf->count, 0u);
-      DCHECK_EQ(buf->length, 0u);
+      GRPC_DCHECK_EQ(buf->count, 0u);
+      GRPC_DCHECK_EQ(buf->length, 0u);
       tcp->outgoing_byte_idx = 0;
       tcp->outgoing_buffer = nullptr;
     }
@@ -1290,10 +1290,10 @@ static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp,
                                             uint32_t seq, const char* tag);
 // Reads \a cmsg to process zerocopy control messages.
 static void process_zerocopy(grpc_tcp* tcp, struct cmsghdr* cmsg) {
-  DCHECK(cmsg);
+  GRPC_DCHECK(cmsg);
   auto serr = reinterpret_cast<struct sock_extended_err*>(CMSG_DATA(cmsg));
-  DCHECK_EQ(serr->ee_errno, 0u);
-  DCHECK(serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY);
+  GRPC_DCHECK_EQ(serr->ee_errno, 0u);
+  GRPC_DCHECK(serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY);
   const uint32_t lo = serr->ee_info;
   const uint32_t hi = serr->ee_data;
   for (uint32_t seq = lo; seq <= hi; ++seq) {
@@ -1303,7 +1303,7 @@ static void process_zerocopy(grpc_tcp* tcp, struct cmsghdr* cmsg) {
     // both; if so, batch the unref/put.
     TcpZerocopySendRecord* record =
         tcp->tcp_zerocopy_send_ctx.ReleaseSendRecord(seq);
-    DCHECK(record);
+    GRPC_DCHECK(record);
     UnrefMaybePutZerocopySendRecord(tcp, record, seq, "CALLBACK RCVD");
   }
   if (tcp->tcp_zerocopy_send_ctx.UpdateZeroCopyOMemStateAfterFree()) {
@@ -1488,14 +1488,14 @@ static bool tcp_write_with_timestamps(grpc_tcp* /*tcp*/, struct msghdr* /*msg*/,
                                       int* /* saved_errno */,
                                       int /*additional_flags*/) {
   LOG(ERROR) << "Write with timestamps not supported for this platform";
-  CHECK(0);
+  GRPC_CHECK(0);
   return false;
 }
 
 static void tcp_handle_error(void* /*arg*/ /* grpc_tcp */,
                              grpc_error_handle /*error*/) {
   LOG(ERROR) << "Error handling is not supported for this platform";
-  CHECK(0);
+  GRPC_CHECK(0);
 }
 #endif  // GRPC_LINUX_ERRQUEUE
 
@@ -1534,7 +1534,7 @@ msg_iovlen_type TcpZerocopySendRecord::PopulateIovs(size_t* unwind_slice_idx,
     ++(out_offset_.slice_idx);
     out_offset_.byte_idx = 0;
   }
-  DCHECK_GT(iov_size, 0u);
+  GRPC_DCHECK_GT(iov_size, 0u);
   return iov_size;
 }
 
@@ -1685,7 +1685,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
       outgoing_slice_idx++;
       tcp->outgoing_byte_idx = 0;
     }
-    CHECK_GT(iov_size, 0u);
+    GRPC_CHECK_GT(iov_size, 0u);
 
     msg.msg_name = nullptr;
     msg.msg_namelen = 0;
@@ -1733,7 +1733,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
       }
     }
 
-    CHECK_EQ(tcp->outgoing_byte_idx, 0u);
+    GRPC_CHECK_EQ(tcp->outgoing_byte_idx, 0u);
     grpc_core::EventLog::Append("tcp-write-outstanding", -sent_length);
     tcp->bytes_counter += sent_length;
     trailing = sending_length - static_cast<size_t>(sent_length);
@@ -1783,7 +1783,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
     GRPC_TRACE_LOG(tcp, INFO) << "write: delayed";
     notify_on_write(tcp);
     // tcp_flush does not populate error if it has returned false.
-    DCHECK(error.ok());
+    GRPC_DCHECK(error.ok());
   } else {
     cb = tcp->write_cb;
     tcp->write_cb = nullptr;
@@ -1818,8 +1818,8 @@ static void tcp_write(
     }
   }
 
-  CHECK_EQ(tcp->write_cb, nullptr);
-  DCHECK_EQ(tcp->current_zerocopy_send, nullptr);
+  GRPC_CHECK_EQ(tcp->write_cb, nullptr);
+  GRPC_DCHECK_EQ(tcp->current_zerocopy_send, nullptr);
 
   if (buf->length == 0) {
     grpc_core::Closure::Run(DEBUG_LOCATION, cb,
@@ -1839,7 +1839,7 @@ static void tcp_write(
   tcp->outgoing_buffer_arg =
       args.TakeDeprecatedAndDiscouragedGoogleSpecificPointer();
   if (tcp->outgoing_buffer_arg) {
-    CHECK(grpc_event_engine_can_track_errors());
+    GRPC_CHECK(grpc_event_engine_can_track_errors());
   }
 
   bool flush_result =
@@ -1944,10 +1944,10 @@ grpc_endpoint* grpc_tcp_create(
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_core::PosixTcpOptions& options,
                                absl::string_view peer_string) {
-  CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
+  GRPC_CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
       << "This function must not be called when the pollset_alternative "
          "experiment is enabled. This is a bug.";
-  CHECK(
+  GRPC_CHECK(
       !grpc_core::IsEventEngineForAllOtherEndpointsEnabled() ||
       grpc_event_engine::experimental::EventEngineExperimentDisabledForPython())
       << "The event_engine_for_all_other_endpoints experiment should prevent "
@@ -1956,7 +1956,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   tcp->base.vtable = &vtable;
   tcp->peer_string = std::string(peer_string);
   tcp->fd = grpc_fd_wrapped_fd(em_fd);
-  CHECK(options.resource_quota != nullptr);
+  GRPC_CHECK(options.resource_quota != nullptr);
   tcp->memory_owner =
       options.resource_quota->memory_quota()->CreateMemoryOwner();
   tcp->self_reservation = tcp->memory_owner.MakeReservation(sizeof(grpc_tcp));
@@ -2047,7 +2047,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
 
 int grpc_tcp_fd(grpc_endpoint* ep) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  CHECK(ep->vtable == &vtable);
+  GRPC_CHECK(ep->vtable == &vtable);
   return grpc_fd_wrapped_fd(tcp->em_fd);
 }
 
@@ -2058,7 +2058,7 @@ void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
         grpc_event_engine_endpoint_destroy_and_release_fd(ep, fd, done);
   }
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  CHECK(ep->vtable == &vtable);
+  GRPC_CHECK(ep->vtable == &vtable);
   tcp->release_fd = fd;
   tcp->release_fd_cb = done;
   grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);

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

@@ -65,6 +65,11 @@ void grpc_tcp_server_shutdown_starting_add(grpc_tcp_server* s,
   grpc_tcp_server_impl->shutdown_starting_add(s, shutdown_starting);
 }
 
+void grpc_tcp_server_shutdown_ending_add(grpc_tcp_server* s,
+                                         grpc_closure* shutdown_ending) {
+  grpc_tcp_server_impl->shutdown_ending_add(s, shutdown_ending);
+}
+
 void grpc_tcp_server_unref(grpc_tcp_server* s) {
   grpc_tcp_server_impl->unref(s);
 }

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

@@ -78,6 +78,8 @@ typedef struct grpc_tcp_server_vtable {
   grpc_tcp_server* (*ref)(grpc_tcp_server* s);
   void (*shutdown_starting_add)(grpc_tcp_server* s,
                                 grpc_closure* shutdown_starting);
+  void (*shutdown_ending_add)(grpc_tcp_server* s,
+                              grpc_closure* shutdown_ending);
   void (*unref)(grpc_tcp_server* s);
   void (*shutdown_listeners)(grpc_tcp_server* s);
   int (*pre_allocated_fd)(grpc_tcp_server* s);
@@ -135,6 +137,11 @@ grpc_tcp_server* grpc_tcp_server_ref(grpc_tcp_server* s);
 void grpc_tcp_server_shutdown_starting_add(grpc_tcp_server* s,
                                            grpc_closure* shutdown_starting);
 
+// shutdown_ending is called when ref count has reached zero and the server
+// has just been destroyed. Calling grpc_tcp_server_ref() from it has no effect.
+void grpc_tcp_server_shutdown_ending_add(grpc_tcp_server* s,
+                                         grpc_closure* shutdown_ending);
+
 // If the refcount drops to zero, enqueue calls on exec_ctx to
 // shutdown_listeners and delete s.
 void grpc_tcp_server_unref(grpc_tcp_server* s);