grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -54,7 +54,6 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
@@ -70,6 +69,7 @@
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -280,9 +280,9 @@ AresResolver::AresResolver(
 }
 
 AresResolver::~AresResolver() {
-  CHECK(fd_node_list_.empty());
-  CHECK(callback_map_.empty());
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK(fd_node_list_.empty());
+  GRPC_CHECK(callback_map_.empty());
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
 }
 
@@ -367,7 +367,7 @@ void AresResolver::LookupHostname(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   if (AresIsIpv6LoopbackAvailable()) {
     // Note that using AF_UNSPEC for both IPv6 and IPv4 queries does not work in
     // all cases, e.g. for localhost:<> it only gets back the IPv6 result (i.e.
@@ -415,7 +415,7 @@ void AresResolver::LookupSRV(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_query(channel_, std::string(host).c_str(), ns_c_in, ns_t_srv,
              &AresResolver::OnSRVQueryDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -451,7 +451,7 @@ void AresResolver::LookupTXT(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_search(channel_, std::string(host).c_str(), ns_c_in, ns_t_txt,
               &AresResolver::OnTXTDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -576,7 +576,7 @@ void AresResolver::MaybeStartTimerLocked() {
 
 void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  CHECK(fd_node->readable_registered);
+  GRPC_CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
@@ -598,7 +598,7 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
 
 void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  CHECK(fd_node->writable_registered);
+  GRPC_CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
@@ -650,7 +650,7 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
                                           int /*timeouts*/,
                                           struct hostent* hostent) {
   auto* hostname_qa = static_cast<HostnameQueryArg*>(arg);
-  CHECK_GT(hostname_qa->pending_requests--, 0);
+  GRPC_CHECK_GT(hostname_qa->pending_requests--, 0);
   auto* ares_resolver = hostname_qa->ares_resolver;
   if (status != ARES_SUCCESS) {
     std::string error_msg =
@@ -722,8 +722,8 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
       delete hostname_qa;
       return;
     }
-    CHECK(std::holds_alternative<
-          EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
+    GRPC_CHECK(std::holds_alternative<
+               EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = std::get<EventEngine::DNSResolver::LookupHostnameCallback>(
         std::move(nh.mapped()));
     if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
@@ -751,8 +751,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   if (nh.empty()) {
     return;
   }
-  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
-      nh.mapped()));
+  GRPC_CHECK(
+      std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
+          nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupSRVCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -814,8 +815,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   if (nh.empty()) {
     return;
   }
-  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
-      nh.mapped()));
+  GRPC_CHECK(
+      std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
+          nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupTXTCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -894,7 +896,7 @@ void AresResolver::Reset(const absl::Status& reason) {
   callback_map_.clear();
   ShutdownLocked(reason, "resolver reset");
   CheckSocketsLocked();
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
   channel_ = nullptr;
 }
@@ -903,10 +905,10 @@ void AresResolver::Restart() {
   grpc_core::MutexLock lock(&mutex_);
   polled_fd_factory_ = polled_fd_factory_->NewEmptyInstance();
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
-  CHECK_EQ(channel_, nullptr);
+  GRPC_CHECK_EQ(channel_, nullptr);
   absl::Status status =
       InitAresChannel(dns_server_, *polled_fd_factory_, &channel_);
-  CHECK_OK(status);
+  GRPC_CHECK_OK(status);
 }
 
 #endif  // GRPC_ENABLE_FORK_SUPPORT
@@ -922,7 +924,7 @@ void AresResolver::ShutdownLocked(const absl::Status& shutdown_status,
       GRPC_TRACE_LOG(cares_resolver, INFO) << absl::Substitute(
           "(EventEngine c-ares resolver) resolver: $0 shutdown fd: $1 ($2)",
           this, fd_node->polled_fd->GetName(), reason);
-      CHECK(fd_node->polled_fd->ShutdownLocked(shutdown_status));
+      GRPC_CHECK(fd_node->polled_fd->ShutdownLocked(shutdown_status));
       fd_node->already_shutdown = true;
     }
   }

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

@@ -21,7 +21,6 @@
 #include <CoreFoundation/CoreFoundation.h>
 #include <grpc/support/cpu.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 #include "src/core/lib/event_engine/cf_engine/cfsocket_listener.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
 
 #ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
@@ -74,7 +74,7 @@ CFEventEngine::~CFEventEngine() {
                    << HandleToString(handle);
       }
     }
-    CHECK(GPR_LIKELY(known_handles_.empty()));
+    GRPC_CHECK(GPR_LIKELY(known_handles_.empty()));
     timer_manager_.Shutdown();
   }
   thread_pool_->Quiesce();

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -18,13 +18,13 @@
 #include <AvailabilityMacros.h>
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 
 namespace grpc_event_engine::experimental {
@@ -148,7 +148,7 @@ void DNSServiceResolverImpl::ResolveCallback(
 
   grpc_core::ReleasableMutexLock lock(&that->request_mu_);
   auto request_it = that->requests_.find(sdRef);
-  CHECK(request_it != that->requests_.end());
+  GRPC_CHECK(request_it != that->requests_.end());
 
   if (errorCode != kDNSServiceErr_NoError &&
       errorCode != kDNSServiceErr_NoSuchRecord) {

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.h

@@ -24,8 +24,8 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -45,7 +45,7 @@ class DNSServiceResolverImpl
   explicit DNSServiceResolverImpl(std::shared_ptr<CFEventEngine> engine)
       : engine_(std::move((engine))) {}
   ~DNSServiceResolverImpl() override {
-    CHECK(requests_.empty());
+    GRPC_CHECK(requests_.empty());
     dispatch_release(queue_);
   }
 

data/src/core/lib/event_engine/extensions/channelz.h

@@ -30,7 +30,7 @@ class ChannelzExtension {
   static absl::string_view EndpointExtensionName() {
     return "io.grpc.event_engine.extension.channelz";
   }
-  virtual void AddJson(grpc_core::channelz::DataSink& sink) = 0;
+  virtual void AddData(grpc_core::channelz::DataSink& sink) = 0;
 
   void SetSocketNode(
       grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node) {
@@ -51,7 +51,7 @@ class ChannelzExtension {
     }
     ~EndpointDataSource() { SourceDestructing(); }
     void AddData(grpc_core::channelz::DataSink sink) override {
-      ep_->AddJson(sink);
+      ep_->AddData(sink);
     }
 
    private:

data/src/core/lib/event_engine/extensions/supports_fd.h

@@ -107,16 +107,16 @@ class EventEngineSupportsFdExtension {
   /// file descriptor. \a config - Additional configuration to applied to the
   /// endpoint. \a memory_allocator - The endpoint may use the provided memory
   /// allocator to track memory allocations.
-  virtual std::unique_ptr<EventEngine::Endpoint> CreatePosixEndpointFromFd(
-      int fd, const EndpointConfig& config,
-      MemoryAllocator memory_allocator) = 0;
+  virtual absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>
+  CreatePosixEndpointFromFd(int fd, const EndpointConfig& config,
+                            MemoryAllocator memory_allocator) = 0;
 
   /// Creates an EventEngine::Endpoint from an fd which is already assumed to be
   /// connected to a remote peer. See \a CreatePosixEndpointFromFd for details.
   /// This has the same behavior, but the \a memory_allocator is taken from the
   /// EndpointConfig's resource quota.
-  virtual std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromFd(
-      int fd, const EndpointConfig& config) = 0;
+  virtual absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>
+  CreateEndpointFromFd(int fd, const EndpointConfig& config) = 0;
 
   /// Creates an EventEngine::Endpoint from a file descriptor that is configured
   /// and bound locally but not yet connected to a remote peer. Returns a

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.cc

@@ -22,7 +22,6 @@
 #include <atomic>
 #include <memory>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 // This polling engine is only relevant on linux kernels supporting epoll
 // epoll_create() or epoll_create1()
@@ -247,13 +247,13 @@ Epoll1Poller::Epoll1Poller(std::shared_ptr<ThreadPool> thread_pool)
     : thread_pool_(thread_pool), was_kicked_(false), closed_(false) {
   g_epoll_set_.epfd = posix_interface().EpollCreateAndCloexec().value();
   wakeup_fd_ = CreateWakeupFd(&posix_interface()).value();
-  CHECK(wakeup_fd_ != nullptr);
-  CHECK(g_epoll_set_.epfd.ready());
+  GRPC_CHECK(wakeup_fd_ != nullptr);
+  GRPC_CHECK(g_epoll_set_.epfd.ready());
   GRPC_TRACE_LOG(event_engine_poller, INFO)
       << "grpc epoll fd: " << g_epoll_set_.epfd;
   auto result = posix_interface().EpollCtlAdd(
       g_epoll_set_.epfd, false, wakeup_fd_->ReadFd(), wakeup_fd_.get());
-  CHECK(result.ok()) << result.StrError();
+  GRPC_CHECK(result.ok()) << result.StrError();
   g_epoll_set_.num_events = 0;
   g_epoll_set_.cursor = 0;
 }
@@ -330,7 +330,7 @@ bool Epoll1Poller::ProcessEpollEvents(int max_epoll_events_to_handle,
     struct epoll_event* ev = &g_epoll_set_.events[c];
     void* data_ptr = ev->data.ptr;
     if (data_ptr == wakeup_fd_.get()) {
-      CHECK(wakeup_fd_->ConsumeWakeup().ok());
+      GRPC_CHECK(wakeup_fd_->ConsumeWakeup().ok());
       was_kicked = true;
     } else {
       Epoll1EventHandle* handle = reinterpret_cast<Epoll1EventHandle*>(
@@ -453,7 +453,7 @@ void Epoll1Poller::Kick() {
     return;
   }
   was_kicked_ = true;
-  CHECK(wakeup_fd_->Wakeup().ok());
+  GRPC_CHECK(wakeup_fd_->Wakeup().ok());
 }
 
 #ifdef GRPC_ENABLE_FORK_SUPPORT
@@ -472,7 +472,7 @@ void Epoll1Poller::HandleForkInChild() {
   }
   g_epoll_set_ = {};
   g_epoll_set_.epfd = posix_interface().EpollCreateAndCloexec().value();
-  CHECK(g_epoll_set_.epfd.ready());
+  GRPC_CHECK(g_epoll_set_.epfd.ready());
   GRPC_TRACE_LOG(event_engine_poller, INFO)
       << "Post-fork grpc epoll fd: " << g_epoll_set_.epfd;
   g_epoll_set_.num_events = 0;
@@ -488,7 +488,7 @@ void Epoll1Poller::ResetKickState() {
   wakeup_fd_ = *CreateWakeupFd(&posix_interface());
   auto status = posix_interface().EpollCtlAdd(
       g_epoll_set_.epfd, false, wakeup_fd_->ReadFd(), wakeup_fd_.get());
-  CHECK(status.ok()) << status.StrError();
+  GRPC_CHECK(status.ok()) << status.StrError();
   grpc_core::MutexLock lock(&mu_);
   was_kicked_ = false;
 }

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -28,7 +28,6 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -38,6 +37,7 @@
 #include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 #ifdef GRPC_POSIX_SOCKET_EV_POLL
 
@@ -239,7 +239,7 @@ EventHandle* PollPoller::CreateHandle(FileDescriptor fd,
                                       bool track_err) {
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
-  DCHECK(track_err == false);
+  GRPC_DCHECK(track_err == false);
   PollEventHandle* handle = new PollEventHandle(fd, shared_from_this());
   // We need to send a kick to the thread executing Work(..) so that it can
   // add this new Fd into the list of Fds to poll.
@@ -258,7 +258,7 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done,
     if (release_fd != nullptr) {
       *release_fd = fd_;
     }
-    CHECK(!is_orphaned_);
+    GRPC_CHECK(!is_orphaned_);
     is_orphaned_ = true;
     // Perform shutdown operations if not already done so.
     if (!is_shutdown_) {
@@ -473,7 +473,7 @@ void PollPoller::KickExternal(bool ext) {
   }
   was_kicked_ = true;
   was_kicked_ext_ = ext;
-  CHECK(wakeup_fd_->Wakeup().ok());
+  GRPC_CHECK(wakeup_fd_->Wakeup().ok());
 }
 
 void PollPoller::Kick() { KickExternal(true); }
@@ -513,14 +513,14 @@ PollPoller::PollPoller(std::shared_ptr<ThreadPool> thread_pool,
       poll_handles_list_head_(nullptr),
       closed_(false) {
   wakeup_fd_ = *CreateWakeupFd(&posix_interface());
-  CHECK(wakeup_fd_ != nullptr);
+  GRPC_CHECK(wakeup_fd_ != nullptr);
 }
 
 PollPoller::~PollPoller() {
   // Assert that no active handles are present at the time of destruction.
   // They should have been orphaned before reaching this state.
-  CHECK_EQ(num_poll_handles_, 0);
-  CHECK_EQ(poll_handles_list_head_, nullptr);
+  GRPC_CHECK_EQ(num_poll_handles_, 0);
+  GRPC_CHECK_EQ(poll_handles_list_head_, nullptr);
 }
 
 Poller::WorkResult PollPoller::Work(
@@ -563,7 +563,7 @@ Poller::WorkResult PollPoller::Work(
 
     pfd_count = 1;
     auto wakeup_fd = posix_interface().GetFd(wakeup_fd_->ReadFd());
-    CHECK(wakeup_fd.ok()) << wakeup_fd.StrError();
+    GRPC_CHECK(wakeup_fd.ok()) << wakeup_fd.StrError();
     pfds[0].fd = *wakeup_fd;
     pfds[0].events = POLLIN;
     pfds[0].revents = 0;
@@ -575,7 +575,7 @@ Poller::WorkResult PollPoller::Work(
         // There shouldn't be any orphaned fds at this point. This is because
         // prior to marking a handle as orphaned it is first removed from
         // poll handle list for the poller under the poller lock.
-        CHECK(!head->IsOrphaned());
+        GRPC_CHECK(!head->IsOrphaned());
         if (!head->IsPollhup()) {
           if (auto file_descriptor = posix_interface().GetFd(head->WrappedFd());
               file_descriptor.ok()) {
@@ -656,7 +656,7 @@ Poller::WorkResult PollPoller::Work(
       }
     } else {
       if (pfds[0].revents & kPollinCheck) {
-        CHECK(wakeup_fd_->ConsumeWakeup().ok());
+        GRPC_CHECK(wakeup_fd_->ConsumeWakeup().ok());
       }
       for (i = 1; i < pfd_count; i++) {
         PollEventHandle* head = watchers[i];

data/src/core/lib/event_engine/posix_engine/lockfree_event.cc

@@ -19,11 +19,11 @@
 #include <atomic>
 #include <cstdint>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 //  'state' holds the to call when the fd is readable or writable respectively.
@@ -76,7 +76,7 @@ void LockfreeEvent::DestroyEvent() {
     if (curr & kShutdownBit) {
       grpc_core::internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
     } else {
-      CHECK(curr == kClosureNotReady || curr == kClosureReady);
+      GRPC_CHECK(curr == kClosureNotReady || curr == kClosureReady);
     }
     // we CAS in a shutdown, no error value here. If this event is interacted
     // with post-deletion (see the note in the constructor) we want the bit

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -31,7 +31,6 @@
 #include <string>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -46,6 +45,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/load_file.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
@@ -247,7 +247,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;
 }
 
@@ -310,8 +310,8 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
     iov[i].iov_len = slice.length();
   }
 
-  CHECK_NE(incoming_buffer_->Length(), 0u);
-  DCHECK_GT(min_progress_size_, 0);
+  GRPC_CHECK_NE(incoming_buffer_->Length(), 0u);
+  GRPC_DCHECK_GT(min_progress_size_, 0);
 
   do {
     // Assume there is something on the queue. If we receive TCP_INQ from
@@ -377,11 +377,12 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
     }
     grpc_core::global_stats().IncrementTcpReadSize(read_bytes);
     AddToEstimate(static_cast<size_t>(read_bytes));
-    DCHECK((size_t)read_bytes <= incoming_buffer_->Length() - total_read_bytes);
+    GRPC_DCHECK((size_t)read_bytes <=
+                incoming_buffer_->Length() - total_read_bytes);
 
 #ifdef GRPC_HAVE_TCP_INQ
     if (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 &&
@@ -430,7 +431,7 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
     inq_ = 1;
   }
 
-  DCHECK_GT(total_read_bytes, 0u);
+  GRPC_DCHECK_GT(total_read_bytes, 0u);
   status = absl::OkStatus();
   if (grpc_core::IsTcpFrameSizeTuningEnabled()) {
     // Update min progress size based on the total number of bytes read in
@@ -613,7 +614,7 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
   grpc_core::ReleasableMutexLock lock(&read_mu_);
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "Endpoint[" << this << "]: Read";
-  CHECK(read_cb_ == nullptr);
+  GRPC_CHECK(read_cb_ == nullptr);
   incoming_buffer_ = buffer;
   incoming_buffer_->Clear();
   incoming_buffer_->Swap(last_read_buffer_);
@@ -687,8 +688,8 @@ TcpZerocopySendRecord* PosixEndpointImpl::TcpGetSendZerocopyRecord(
     }
     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);
       outgoing_byte_idx_ = 0;
       outgoing_buffer_ = nullptr;
     }
@@ -775,10 +776,10 @@ void PosixEndpointImpl::ZerocopyDisableAndWaitForRemaining() {
 
 // Reads \a cmsg to process zerocopy control messages.
 void PosixEndpointImpl::ProcessZerocopy(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) {
@@ -788,7 +789,7 @@ void PosixEndpointImpl::ProcessZerocopy(struct cmsghdr* cmsg) {
     // both; if so, batch the unref/put.
     TcpZerocopySendRecord* record =
         tcp_zerocopy_send_ctx_->ReleaseSendRecord(seq);
-    DCHECK(record);
+    GRPC_DCHECK(record);
     UnrefMaybePutZerocopySendRecord(record);
   }
   if (tcp_zerocopy_send_ctx_->UpdateZeroCopyOptMemStateAfterFree()) {
@@ -1086,7 +1087,7 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
       outgoing_slice_idx++;
       outgoing_byte_idx_ = 0;
     }
-    CHECK_GT(iov_size, 0u);
+    GRPC_CHECK_GT(iov_size, 0u);
 
     msg.msg_name = nullptr;
     msg.msg_namelen = 0;
@@ -1132,7 +1133,7 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
       }
     }
 
-    CHECK_EQ(outgoing_byte_idx_, 0u);
+    GRPC_CHECK_EQ(outgoing_byte_idx_, 0u);
     bytes_counter_ += *send_result;
     trailing = sending_length - static_cast<size_t>(*send_result);
     while (trailing > 0) {
@@ -1171,7 +1172,7 @@ void PosixEndpointImpl::HandleWrite(absl::Status status) {
                           ? TcpFlushZerocopy(current_zerocopy_send_, status)
                           : TcpFlush(status);
   if (!flush_result) {
-    DCHECK(status.ok());
+    GRPC_DCHECK(status.ok());
     handle_->NotifyOnWrite(on_write_);
   } else {
     GRPC_TRACE_LOG(event_engine_endpoint, INFO)
@@ -1190,9 +1191,9 @@ bool PosixEndpointImpl::Write(
   absl::Status status = absl::OkStatus();
   TcpZerocopySendRecord* zerocopy_send_record = nullptr;
 
-  CHECK(write_cb_ == nullptr);
-  DCHECK_EQ(current_zerocopy_send_, nullptr);
-  DCHECK_NE(data, nullptr);
+  GRPC_CHECK(write_cb_ == nullptr);
+  GRPC_DCHECK_EQ(current_zerocopy_send_, nullptr);
+  GRPC_DCHECK_NE(data, nullptr);
 
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "Endpoint[" << this << "]: Write " << data->Length() << " bytes";
@@ -1293,7 +1294,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
       poller_(handle->Poller()),
       engine_(engine) {
   FileDescriptor fd = handle_->WrappedFd();
-  CHECK(options.resource_quota != nullptr);
+  GRPC_CHECK(options.resource_quota != nullptr);
   auto& posix_interface = poller_->posix_interface();
   auto peer_addr_string = posix_interface.PeerAddressString(fd);
   mem_quota_ = options.resource_quota->memory_quota();
@@ -1405,7 +1406,7 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     EventHandle* handle, PosixEngineClosure* on_shutdown,
     std::shared_ptr<EventEngine> engine, MemoryAllocator&& allocator,
     const PosixTcpOptions& options) {
-  DCHECK_NE(handle, nullptr);
+  GRPC_DCHECK_NE(handle, nullptr);
   return std::make_unique<PosixEndpoint>(handle, on_shutdown, std::move(engine),
                                          std::move(allocator), options);
 }