grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -46,7 +46,6 @@
 #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"
@@ -70,6 +69,7 @@
 #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"
@@ -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);

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

@@ -50,12 +50,12 @@
 
 #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,6 +74,7 @@
 #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"
 
 static std::atomic<int64_t> num_dropped_connections{0};
@@ -89,7 +90,8 @@ 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);
+  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 +159,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 +239,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);
@@ -283,8 +292,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 +315,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 +327,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 +356,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 +422,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 +560,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 +612,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 +644,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 +659,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 +787,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 +800,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,6 +837,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_unref(grpc_tcp_server* s) {
   if (gpr_unref(&s->refs)) {
     grpc_tcp_server_shutdown_listeners(s);
@@ -882,16 +900,17 @@ 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_CHECK(
+          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 +979,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

@@ -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,7 +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"
@@ -43,6 +42,7 @@
 #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"
 
 #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,7 +31,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"
@@ -39,6 +38,7 @@
 #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"
 
 // 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;