grpc 1.72.0 → 1.74.0.pre2

data/src/core/lib/debug/trace_flags.cc

@@ -48,6 +48,7 @@ DebugOnlyTraceFlag slice_refcount_trace(false, "slice_refcount");
 DebugOnlyTraceFlag stream_refcount_trace(false, "stream_refcount");
 DebugOnlyTraceFlag subchannel_refcount_trace(false, "subchannel_refcount");
 DebugOnlyTraceFlag work_serializer_trace(false, "work_serializer");
+DebugOnlyTraceFlag ztrace_trace(false, "ztrace");
 TraceFlag api_trace(false, "api");
 TraceFlag apple_polling_trace(false, "apple_polling");
 TraceFlag backend_metric_trace(false, "backend_metric");
@@ -78,7 +79,6 @@ TraceFlag event_engine_dns_trace(false, "event_engine_dns");
 TraceFlag event_engine_endpoint_trace(false, "event_engine_endpoint");
 TraceFlag event_engine_endpoint_data_trace(false, "event_engine_endpoint_data");
 TraceFlag event_engine_poller_trace(false, "event_engine_poller");
-TraceFlag executor_trace(false, "executor");
 TraceFlag fault_injection_filter_trace(false, "fault_injection_filter");
 TraceFlag flowctl_trace(false, "flowctl");
 TraceFlag fork_trace(false, "fork");
@@ -161,7 +161,6 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"event_engine_endpoint", &event_engine_endpoint_trace},
           {"event_engine_endpoint_data", &event_engine_endpoint_data_trace},
           {"event_engine_poller", &event_engine_poller_trace},
-          {"executor", &executor_trace},
           {"fault_injection_filter", &fault_injection_filter_trace},
           {"flowctl", &flowctl_trace},
           {"fork", &fork_trace},
@@ -235,6 +234,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"stream_refcount", &stream_refcount_trace},
           {"subchannel_refcount", &subchannel_refcount_trace},
           {"work_serializer", &work_serializer_trace},
+          {"ztrace", &ztrace_trace},
 #endif
       }));
   return *all;

data/src/core/lib/debug/trace_flags.h

@@ -47,6 +47,7 @@ extern DebugOnlyTraceFlag slice_refcount_trace;
 extern DebugOnlyTraceFlag stream_refcount_trace;
 extern DebugOnlyTraceFlag subchannel_refcount_trace;
 extern DebugOnlyTraceFlag work_serializer_trace;
+extern DebugOnlyTraceFlag ztrace_trace;
 extern TraceFlag api_trace;
 extern TraceFlag apple_polling_trace;
 extern TraceFlag backend_metric_trace;
@@ -76,7 +77,6 @@ extern TraceFlag event_engine_dns_trace;
 extern TraceFlag event_engine_endpoint_trace;
 extern TraceFlag event_engine_endpoint_data_trace;
 extern TraceFlag event_engine_poller_trace;
-extern TraceFlag executor_trace;
 extern TraceFlag fault_injection_filter_trace;
 extern TraceFlag flowctl_trace;
 extern TraceFlag fork_trace;

data/src/core/lib/debug/trace_impl.h

@@ -75,7 +75,6 @@ class TraceFlag {
     value_.store(enabled, std::memory_order_relaxed);
   }
 
-  TraceFlag* next_tracer_;
   const char* const name_;
   std::atomic<bool> value_;
 };

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

@@ -15,6 +15,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -53,13 +54,14 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/hash/hash.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
 #include "src/core/config/config_vars.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -67,7 +69,6 @@
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/orphanable.h"
@@ -107,9 +108,9 @@ absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
 constexpr EventEngine::Duration kAresBackupPollAlarmDuration =
     std::chrono::seconds(1);
 
-bool IsIpv6LoopbackAvailable() {
+bool AresIsIpv6LoopbackAvailable() {
 #ifdef GRPC_POSIX_SOCKET_ARES_EV_DRIVER
-  return PosixSocketWrapper::IsIpv6LoopbackAvailable();
+  return IsIpv6LoopbackAvailable();
 #elif defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   // TODO(yijiem): implement this for Windows
   return true;
@@ -189,73 +190,118 @@ struct HostnameQueryArg : public QueryArg {
   std::vector<EventEngine::ResolvedAddress> result;
 };
 
-}  // namespace
-
-absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
-AresResolver::CreateAresResolver(
-    absl::string_view dns_server,
-    std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-    std::shared_ptr<EventEngine> event_engine) {
+absl::Status InitAresChannel(absl::string_view dns_server,
+                             GrpcPolledFdFactory& polled_fd_factory,
+                             ares_channel* channel) {
   ares_options opts = {};
   opts.flags |= ARES_FLAG_STAYOPEN;
   if (g_event_engine_grpc_ares_test_only_force_tcp) {
     opts.flags |= ARES_FLAG_USEVC;
   }
-  ares_channel channel;
-  int status = ares_init_options(&channel, &opts, ARES_OPT_FLAGS);
+  int status = ares_init_options(channel, &opts, ARES_OPT_FLAGS);
   if (status != ARES_SUCCESS) {
     LOG(ERROR) << "ares_init_options failed, status: " << status;
     return AresStatusToAbslStatus(
         status,
         absl::StrCat("Failed to init c-ares channel: ", ares_strerror(status)));
   }
-  event_engine_grpc_ares_test_only_inject_config(&channel);
-  polled_fd_factory->ConfigureAresChannelLocked(channel);
+  event_engine_grpc_ares_test_only_inject_config(channel);
+  polled_fd_factory.ConfigureAresChannelLocked(*channel);
   if (!dns_server.empty()) {
-    absl::Status status = SetRequestDNSServer(dns_server, &channel);
+    absl::Status status = SetRequestDNSServer(dns_server, channel);
     if (!status.ok()) {
       return status;
     }
   }
-  return grpc_core::MakeOrphanable<AresResolver>(
-      std::move(polled_fd_factory), std::move(event_engine), channel);
+  return absl::OkStatus();
+}
+
+}  // namespace
+
+// AresResolver::ReinitHandle
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+AresResolver::ReinitHandle::ReinitHandle(AresResolver* resolver)
+    : resolver_(resolver) {}
+
+void AresResolver::ReinitHandle::OnResolverGone() {
+  grpc_core::MutexLock lock(&mutex_);
+  resolver_ = nullptr;
+}
+
+void AresResolver::ReinitHandle::Reset(const absl::Status& status) {
+  grpc_core::MutexLock lock(&mutex_);
+  if (resolver_ != nullptr) {
+    resolver_->Reset(status);
+  }
+}
+
+void AresResolver::ReinitHandle::Restart() {
+  grpc_core::MutexLock lock(&mutex_);
+  if (resolver_ != nullptr) {
+    resolver_->Restart();
+  }
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+// AresResolver
+
+absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
+AresResolver::CreateAresResolver(
+    absl::string_view dns_server,
+    std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
+    std::shared_ptr<EventEngine> event_engine) {
+  ares_channel channel;
+  absl::Status status =
+      InitAresChannel(dns_server, *polled_fd_factory, &channel);
+  if (!status.ok()) {
+    return status;
+  }
+  return grpc_core::MakeOrphanable<AresResolver>(std::move(polled_fd_factory),
+                                                 std::move(event_engine),
+                                                 channel, dns_server);
 }
 
 AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-    std::shared_ptr<EventEngine> event_engine, ares_channel channel)
+    std::shared_ptr<EventEngine> event_engine, ares_channel channel,
+    absl::string_view dns_server)
     : RefCountedDNSResolverInterface(
           GRPC_TRACE_FLAG_ENABLED(cares_resolver) ? "AresResolver" : nullptr),
       channel_(channel),
       polled_fd_factory_(std::move(polled_fd_factory)),
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+      dns_server_(dns_server),
+#endif  // GRPC_ENABLE_FORK_SUPPORT
       event_engine_(std::move(event_engine)) {
+  (void)dns_server;  // Used whether or not compiled with fork support
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
 }
 
 AresResolver::~AresResolver() {
   CHECK(fd_node_list_.empty());
   CHECK(callback_map_.empty());
+  CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
 }
 
 void AresResolver::Orphan() {
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Do this before locking &mutex_ - ensures there will be no deadlock if
+  // resolver is being orphaned during fork.
+  {
+    grpc_core::MutexLock handle_lock(&reinit_handle_mu_);
+    if (reinit_handle_ != nullptr) {
+      reinit_handle_->OnResolverGone();
+    }
+  }
+#endif
   {
     grpc_core::MutexLock lock(&mutex_);
     shutting_down_ = true;
-    if (ares_backup_poll_alarm_handle_.has_value()) {
-      event_engine_->Cancel(*ares_backup_poll_alarm_handle_);
-      ares_backup_poll_alarm_handle_.reset();
-    }
-    for (const auto& fd_node : fd_node_list_) {
-      if (!fd_node->already_shutdown) {
-        GRPC_TRACE_LOG(cares_resolver, INFO)
-            << "(EventEngine c-ares resolver) resolver: " << this
-            << " shutdown fd: " << fd_node->polled_fd->GetName();
-        CHECK(fd_node->polled_fd->ShutdownLocked(
-            absl::CancelledError("AresResolver::Orphan")));
-        fd_node->already_shutdown = true;
-      }
-    }
+    ShutdownLocked(absl::CancelledError("AresResolver::Orphan"),
+                   "resolver orphaned");
   }
   Unref(DEBUG_LOCATION, "Orphan");
 }
@@ -321,7 +367,8 @@ void AresResolver::LookupHostname(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
-  if (IsIpv6LoopbackAvailable()) {
+  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.
     // ::1).
@@ -368,6 +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);
   ares_query(channel_, std::string(host).c_str(), ns_c_in, ns_t_srv,
              &AresResolver::OnSRVQueryDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -403,6 +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);
   ares_search(channel_, std::string(host).c_str(), ns_c_in, ns_t_txt,
               &AresResolver::OnTXTDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -411,15 +460,17 @@ void AresResolver::LookupTXT(
 
 void AresResolver::CheckSocketsLocked() {
   FdNodeList new_list;
-  if (!shutting_down_) {
+  if (!shutting_down_ && channel_ != nullptr) {
     ares_socket_t socks[ARES_GETSOCK_MAXNUM] = {};
     int socks_bitmask = ares_getsock(channel_, socks, ARES_GETSOCK_MAXNUM);
     for (size_t i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
       if (ARES_GETSOCK_READABLE(socks_bitmask, i) ||
           ARES_GETSOCK_WRITABLE(socks_bitmask, i)) {
-        auto iter = std::find_if(
-            fd_node_list_.begin(), fd_node_list_.end(),
-            [sock = socks[i]](const auto& node) { return node->as == sock; });
+        auto iter = std::find_if(fd_node_list_.begin(), fd_node_list_.end(),
+                                 [sock = socks[i]](const auto& node) {
+                                   return node->as == sock &&
+                                          node->polled_fd->IsCurrent();
+                                 });
         if (iter == fd_node_list_.end()) {
           GRPC_TRACE_LOG(cares_resolver, INFO)
               << "(EventEngine c-ares resolver) resolver:" << this
@@ -530,14 +581,16 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
       << "; request: " << this << "; status: " << status;
-  if (status.ok() && !shutting_down_) {
+  if (status.ok() && !shutting_down_ && channel_ != nullptr) {
     ares_process_fd(channel_, fd_node->as, ARES_SOCKET_BAD);
-  } else {
+  } else if (fd_node->polled_fd->IsCurrent() && channel_ != nullptr) {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made
     // on this request will be cancelled by the following ares_cancel(). The
     // remaining file descriptors in this request will be cleaned up in the
     // following Work() method.
+    //
+    // Nothing is done if the handle is not current.
     ares_cancel(channel_);
   }
   CheckSocketsLocked();
@@ -550,9 +603,9 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
       << "; request:" << this << "; status: " << status;
-  if (status.ok() && !shutting_down_) {
+  if (status.ok() && !shutting_down_ && channel_ != nullptr) {
     ares_process_fd(channel_, ARES_SOCKET_BAD, fd_node->as);
-  } else {
+  } else if (fd_node->polled_fd->IsCurrent() && channel_ != nullptr) {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made
     // on this request will be cancelled by the following ares_cancel(). The
@@ -577,7 +630,7 @@ void AresResolver::OnAresBackupPollAlarm() {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) request:" << this
       << " OnAresBackupPollAlarm shutting_down=" << shutting_down_;
-  if (!shutting_down_) {
+  if (!shutting_down_ && channel_ != nullptr) {
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
         GRPC_TRACE_LOG(cares_resolver, INFO)
@@ -665,7 +718,10 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
   if (hostname_qa->pending_requests == 0) {
     auto nh =
         ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
-    CHECK(!nh.empty());
+    if (nh.empty()) {
+      delete hostname_qa;
+      return;
+    }
     CHECK(std::holds_alternative<
           EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = std::get<EventEngine::DNSResolver::LookupHostnameCallback>(
@@ -692,7 +748,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  CHECK(!nh.empty());
+  if (nh.empty()) {
+    return;
+  }
   CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
       nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupSRVCallback>(
@@ -753,7 +811,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  CHECK(!nh.empty());
+  if (nh.empty()) {
+    return;
+  }
   CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
       nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupTXTCallback>(
@@ -809,6 +869,65 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
       });
 }
 
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+std::weak_ptr<AresResolver::ReinitHandle> AresResolver::GetReinitHandle() {
+  grpc_core::MutexLock lock(&reinit_handle_mu_);
+  if (reinit_handle_ == nullptr) {
+    reinit_handle_ = ReinitHandle::New(this);
+  }
+  return reinit_handle_;
+}
+
+void AresResolver::Reset(const absl::Status& reason) {
+  auto self = RefIfNonZero();
+  if (self == nullptr) {
+    return;
+  }
+  grpc_core::MutexLock lock(&mutex_);
+  for (auto& [_, callback] : callback_map_) {
+    event_engine_->Run(
+        [callback = std::move(callback), reason = reason]() mutable {
+          std::visit([&](auto& cb) { cb(reason); }, callback);
+        });
+  }
+  callback_map_.clear();
+  ShutdownLocked(reason, "resolver reset");
+  CheckSocketsLocked();
+  CHECK_NE(channel_, nullptr);
+  ares_destroy(channel_);
+  channel_ = nullptr;
+}
+
+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);
+  absl::Status status =
+      InitAresChannel(dns_server_, *polled_fd_factory_, &channel_);
+  CHECK_OK(status);
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+void AresResolver::ShutdownLocked(const absl::Status& shutdown_status,
+                                  absl::string_view reason) {
+  if (ares_backup_poll_alarm_handle_.has_value()) {
+    event_engine_->Cancel(*ares_backup_poll_alarm_handle_);
+    ares_backup_poll_alarm_handle_.reset();
+  }
+  for (const auto& fd_node : fd_node_list_) {
+    if (!fd_node->already_shutdown) {
+      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));
+      fd_node->already_shutdown = true;
+    }
+  }
+}
+
 }  // namespace grpc_event_engine::experimental
 
 void noop_inject_channel_config(ares_channel* /*channel*/) {}

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

@@ -19,7 +19,6 @@
 #include <utility>
 
 #include "absl/status/status.h"
-#include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1
 
@@ -42,6 +41,32 @@ namespace grpc_event_engine::experimental {
 
 class AresResolver : public RefCountedDNSResolverInterface {
  public:
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Handle to trigger reinitialization of this AresResolver instance after a
+  // fork(). Avoids global resolver management and POSIX-specific dependencies
+  // within AresResolver.
+  class ReinitHandle {
+   public:
+    static std::shared_ptr<ReinitHandle> New(AresResolver* resolver) {
+      return std::shared_ptr<ReinitHandle>(new ReinitHandle(resolver));
+    }
+
+    ReinitHandle(ReinitHandle&& other) = delete;
+    ReinitHandle(const ReinitHandle& other) = delete;
+    void OnResolverGone();
+    // Clears resources (such as CARES handles) held by the associated resolver.
+    void Reset(const absl::Status& status);
+    // Reinitializes the associated resolver after Reset.
+    void Restart();
+
+   private:
+    explicit ReinitHandle(AresResolver* resolver);
+
+    grpc_core::Mutex mutex_;
+    AresResolver* resolver_ ABSL_GUARDED_BY(&mutex_);
+  };
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
   static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
   CreateAresResolver(absl::string_view dns_server,
                      std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
@@ -49,7 +74,8 @@ class AresResolver : public RefCountedDNSResolverInterface {
 
   // Do not instantiate directly -- use CreateAresResolver() instead.
   AresResolver(std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-               std::shared_ptr<EventEngine> event_engine, ares_channel channel);
+               std::shared_ptr<EventEngine> event_engine, ares_channel channel,
+               absl::string_view dns_server);
   ~AresResolver() override;
   void Orphan() override ABSL_LOCKS_EXCLUDED(mutex_);
 
@@ -60,6 +86,9 @@ class AresResolver : public RefCountedDNSResolverInterface {
                  absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
   void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback callback,
                  absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  std::weak_ptr<ReinitHandle> GetReinitHandle();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
  private:
   // A FdNode saves (not owns) a live socket/fd which c-ares creates, and owns a
@@ -109,6 +138,17 @@ class AresResolver : public RefCountedDNSResolverInterface {
   static void OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
                               unsigned char* buf,
                               int len) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Is executed on fork before the poller is restarted. Cleans up the resources
+  // from the previous generation.
+  void Reset(const absl::Status& reason);
+  // Is executed on fork after the poller is restarted. Makes the resolver
+  // usable once more.
+  void Restart();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  void ShutdownLocked(const absl::Status& shutdown_status,
+                      absl::string_view reason)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   grpc_core::Mutex mutex_;
   bool shutting_down_ ABSL_GUARDED_BY(mutex_) = false;
@@ -119,6 +159,12 @@ class AresResolver : public RefCountedDNSResolverInterface {
   std::optional<EventEngine::TaskHandle> ares_backup_poll_alarm_handle_
       ABSL_GUARDED_BY(mutex_);
   std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory_;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  std::string dns_server_;
+  grpc_core::Mutex reinit_handle_mu_;
+  std::shared_ptr<ReinitHandle> reinit_handle_
+      ABSL_GUARDED_BY(reinit_handle_mu_);
+#endif  // GRPC_ENABLE_FORK_SUPPORT
   std::shared_ptr<EventEngine> event_engine_;
 };
 

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

@@ -31,6 +31,11 @@
 #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/useful.h"
+
+#ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
+#define GRPC_CFSTREAM_MAX_THREADPOOL_SIZE 16u
+#endif  // GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
 
 namespace grpc_event_engine::experimental {
 
@@ -53,8 +58,9 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
 };
 
 CFEventEngine::CFEventEngine()
-    : thread_pool_(
-          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+    : thread_pool_(MakeThreadPool(grpc_core::Clamp(
+          gpr_cpu_num_cores(), 2u,
+          static_cast<unsigned int>(GRPC_CFSTREAM_MAX_THREADPOOL_SIZE)))),
       timer_manager_(thread_pool_) {}
 
 CFEventEngine::~CFEventEngine() {

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

@@ -26,14 +26,11 @@
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
 
-class CFEventEngine : public EventEngine,
-                      public Scheduler,
-                      public grpc_core::KeepsGrpcInitialized {
+class CFEventEngine : public EventEngine, public Scheduler {
  public:
   CFEventEngine();
   ~CFEventEngine() override;

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

@@ -255,9 +255,9 @@ void CFStreamEndpointImpl::Shutdown() {
   CFWriteStreamClose(cf_write_stream_);
 }
 
-bool CFStreamEndpointImpl::Read(
-    absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-    const EventEngine::Endpoint::ReadArgs* /* args */) {
+bool CFStreamEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
+                                SliceBuffer* buffer,
+                                EventEngine::Endpoint::ReadArgs /* args */) {
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "CFStreamEndpointImpl::Read, this: " << this;
 
@@ -304,7 +304,7 @@ void CFStreamEndpointImpl::DoRead(
 
 bool CFStreamEndpointImpl::Write(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
-    const EventEngine::Endpoint::WriteArgs* /* args */) {
+    EventEngine::Endpoint::WriteArgs /* args */) {
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "CFStreamEndpointImpl::Write, this: " << this;
 

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

@@ -44,9 +44,9 @@ class CFStreamEndpointImpl
   void Shutdown();
 
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-            const EventEngine::Endpoint::ReadArgs* args);
+            EventEngine::Endpoint::ReadArgs args);
   bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-             SliceBuffer* data, const EventEngine::Endpoint::WriteArgs* args);
+             SliceBuffer* data, EventEngine::Endpoint::WriteArgs args);
 
   const EventEngine::ResolvedAddress& GetPeerAddress() const {
     return peer_address_;
@@ -109,12 +109,12 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
   ~CFStreamEndpoint() override { impl_->Shutdown(); }
 
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-            const ReadArgs* args) override {
-    return impl_->Read(std::move(on_read), buffer, args);
+            ReadArgs args) override {
+    return impl_->Read(std::move(on_read), buffer, std::move(args));
   }
   bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-             SliceBuffer* data, const WriteArgs* args) override {
-    return impl_->Write(std::move(on_writable), data, args);
+             SliceBuffer* data, WriteArgs args) override {
+    return impl_->Write(std::move(on_writable), data, std::move(args));
   }
 
   const EventEngine::ResolvedAddress& GetPeerAddress() const override {
@@ -124,6 +124,10 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
     return impl_->GetLocalAddress();
   }
 
+  std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const override {
+    return nullptr;
+  }
+
  public:
   void Connect(absl::AnyInvocable<void(absl::Status)> on_connect,
                EventEngine::ResolvedAddress addr) {

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

@@ -45,7 +45,7 @@ std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
 namespace grpc_event_engine::experimental {
 
 std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_shared<PosixEventEngine>();
+  return PosixEventEngine::MakePosixEventEngine();
 }
 
 }  // namespace grpc_event_engine::experimental

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

@@ -0,0 +1,40 @@
+// Copyright 2025 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/lib/event_engine/endpoint_channel_arg_wrapper.h"
+
+#include "src/core/util/useful.h"
+namespace grpc_event_engine {
+namespace experimental {
+
+EndpointChannelArgWrapper::EndpointChannelArgWrapper(
+    std::unique_ptr<EventEngine::Endpoint> endpoint)
+    : endpoint_(std::move(endpoint)) {}
+
+std::unique_ptr<EventEngine::Endpoint>
+EndpointChannelArgWrapper::TakeEndpoint() {
+  return std::move(endpoint_);
+}
+
+absl::string_view EndpointChannelArgWrapper::ChannelArgName() {
+  return "grpc.internal.subchannel_endpoint";
+}
+
+int EndpointChannelArgWrapper::ChannelArgsCompare(
+    const EndpointChannelArgWrapper* a, const EndpointChannelArgWrapper* b) {
+  return QsortCompare(a, b);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine