grpc 1.73.0 → 1.75.0

data/src/core/lib/channel/promise_based_filter.h

@@ -196,7 +196,10 @@ struct CallHasAsyncErrorInterceptor<
 template <typename Derived>
 struct CallHasAsyncErrorInterceptor<
     Derived, std::enable_if_t<IsFusedFilter<Derived>::value>> {
-  static constexpr bool value = Derived::FusedFilterHasAsyncErrorInterceptor();
+  // Fused filter types return a promise, which resolves to a
+  // ServerMetadataHandle type. So we assume that an async error interceptor is
+  // always needed.
+  static constexpr bool value = true;
 };
 
 // Given a boolean X export a type:
@@ -1304,11 +1307,9 @@ class BaseCallData : public Activity, private Wakeable {
     }
   };
 
-  class Flusher : public latent_see::InnerScope {
+  class Flusher {
    public:
-    explicit Flusher(BaseCallData* call,
-                     latent_see::Metadata* desc = GRPC_LATENT_SEE_METADATA(
-                         "PromiseBasedFilter::Flusher"));
+    explicit Flusher(BaseCallData* call);
     // Calls closures, schedules batches, relinquishes call combiner.
     ~Flusher();
 
@@ -1979,11 +1980,11 @@ struct ChannelFilterWithFlagsMethods {
   static absl::Status InitChannelElem(grpc_channel_element* elem,
                                       grpc_channel_element_args* args) {
     CHECK(args->is_last == ((kFlags & kFilterIsLast) != 0));
-    auto status = F::Create(
-        args->channel_args,
-        ChannelFilter::Args(args->channel_stack, elem,
-                            grpc_channel_stack_filter_instance_number,
-                            args->old_blackboard, args->new_blackboard));
+    auto status =
+        F::Create(args->channel_args,
+                  ChannelFilter::Args(args->channel_stack, elem,
+                                      grpc_channel_stack_filter_instance_number,
+                                      args->blackboard));
     if (!status.ok()) {
       new (elem->channel_data) F*(nullptr);
       return absl_status_to_grpc_error(status.status());

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,12 +19,13 @@
 #include <utility>
 
 #include "absl/status/status.h"
-#include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1
 
-#include <ares.h>
 #include <grpc/event_engine/event_engine.h>
+// ares.h is not self-contained w.r.t. windows headers so pull in
+// event_engine.h first
+#include <ares.h>
 
 #include <list>
 #include <memory>
@@ -42,6 +43,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 +76,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 +88,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 +140,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 +161,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

@@ -24,6 +24,7 @@
 #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"
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
 #include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
@@ -31,6 +32,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/useful.h"
 
 #ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
 #define GRPC_CFSTREAM_MAX_THREADPOOL_SIZE 16u
@@ -58,7 +60,8 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
 
 CFEventEngine::CFEventEngine()
     : thread_pool_(MakeThreadPool(grpc_core::Clamp(
-          gpr_cpu_num_cores(), 2u, GRPC_CFSTREAM_MAX_THREADPOOL_SIZE))),
+          gpr_cpu_num_cores(), 2u,
+          static_cast<unsigned int>(GRPC_CFSTREAM_MAX_THREADPOOL_SIZE)))),
       timer_manager_(thread_pool_) {}
 
 CFEventEngine::~CFEventEngine() {
@@ -79,11 +82,14 @@ CFEventEngine::~CFEventEngine() {
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
 CFEventEngine::CreateListener(
-    Listener::AcceptCallback /* on_accept */,
-    absl::AnyInvocable<void(absl::Status)> /* on_shutdown */,
-    const EndpointConfig& /* config */,
-    std::unique_ptr<MemoryAllocatorFactory> /* memory_allocator_factory */) {
-  grpc_core::Crash("unimplemented");
+    Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  return std::make_unique<CFSocketListener>(
+      std::static_pointer_cast<CFEventEngine>(shared_from_this()),
+      std::move(on_accept), std::move(on_shutdown), config,
+      std::move(memory_allocator_factory));
 }
 
 CFEventEngine::ConnectionHandle CFEventEngine::Connect(

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:
   CFEventEngine();
   ~CFEventEngine() override;
@@ -60,6 +57,7 @@ class CFEventEngine : public EventEngine,
   TaskHandle RunAfter(Duration when,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
+  ThreadPool* thread_pool() const { return thread_pool_.get(); }
 
  private:
   struct Closure;