grpc 1.73.0 → 1.75.0

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

@@ -21,43 +21,46 @@
 
 #include <algorithm>
 #include <atomic>
-#include <chrono>
 #include <cstdint>
 #include <cstring>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
+#include "absl/base/no_destructor.h"
 #include "absl/cleanup/cleanup.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/ares_resolver.h"
-#include "src/core/lib/event_engine/forkable.h"
-#include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h"
 #include "src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/crash.h"
-#include "src/core/util/no_destruct.h"
+#include "src/core/util/fork.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 #include <errno.h>       // IWYU pragma: keep
+#include <pthread.h>     // IWYU pragma: keep
 #include <stdint.h>      // IWYU pragma: keep
 #include <sys/socket.h>  // IWYU pragma: keep
+#include <unistd.h>      // IWYU pragma: keep
 
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller_posix_default.h"
@@ -67,32 +70,178 @@
 
 // IWYU pragma: no_include <ratio>
 
-#if defined(GRPC_POSIX_SOCKET_TCP) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING true
-#else
-#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING false
-#endif
-
 using namespace std::chrono_literals;
 
 namespace grpc_event_engine::experimental {
 
 namespace {
 
-grpc_core::NoDestruct<ObjectGroupForkHandler> g_timer_fork_manager;
-
-class TimerForkCallbackMethods {
- public:
-  static void Prefork() { g_timer_fork_manager->Prefork(); }
-  static void PostforkParent() { g_timer_fork_manager->PostforkParent(); }
-  static void PostforkChild() { g_timer_fork_manager->PostforkChild(); }
+#if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+// Thread pool can outlive EE but we need to ensure the ordering if both
+// entities are alive.
+template <template <typename> typename PtrType>
+struct ForkHandlerPointers {
+  PtrType<PosixEventEngine> event_engine;
+  PtrType<ThreadPool> executor;
+  PtrType<TimerManager> timer_manager;
+
+  ForkHandlerPointers(PtrType<PosixEventEngine> event_engine,
+                      PtrType<ThreadPool> executor,
+                      PtrType<TimerManager> timer_manager)
+      : event_engine(std::move(event_engine)),
+        executor(std::move(executor)),
+        timer_manager(std::move(timer_manager)) {}
 };
 
+// Fork support - mutex and global list of event engines
+// Should never be destroyed to avoid race conditions on process shutdown
+absl::NoDestructor<grpc_core::Mutex> fork_mu;
+absl::NoDestructor<absl::InlinedVector<ForkHandlerPointers<std::weak_ptr>, 16>>
+    fork_handlers ABSL_GUARDED_BY(fork_mu.get());
+
+// "Locks" event engines and returns a collection so callbacks can be invoked
+// without holding a lock.
+std::vector<ForkHandlerPointers<std::shared_ptr>> LockForkHandlers() {
+  grpc_core::MutexLock lock(fork_mu.get());
+  std::vector<ForkHandlerPointers<std::shared_ptr>> locked;
+  // Not all weak_ptrs might be locked. If an engine enters dtor, it will stop
+  // on a mutex in DeregisterEventEngineForFork but the weak pointer will not
+  // be lockable here.
+  locked.reserve(fork_handlers->size());
+  for (const auto& [event_engine, executor, timer_manager] : *fork_handlers) {
+    locked.emplace_back(event_engine.lock(), executor.lock(),
+                        timer_manager.lock());
+  }
+  return locked;
+}
+
+void PrepareFork() {
+  for (const auto& [event_engine, executor, timer_manager] :
+       LockForkHandlers()) {
+    if (event_engine != nullptr) {
+      event_engine->BeforeFork();
+    }
+    if (timer_manager != nullptr) {
+      timer_manager->PrepareFork();
+    }
+    if (executor != nullptr) {
+      executor->PrepareFork();
+    }
+  }
+}
+
+void PostForkInParent() {
+  for (const auto& [event_engine, executor, timer_manager] :
+       LockForkHandlers()) {
+    if (executor != nullptr) {
+      executor->PostFork();
+    }
+    if (timer_manager) {
+      timer_manager->PostFork();
+    }
+    if (event_engine != nullptr) {
+      event_engine->AfterFork(PosixEventEngine::OnForkRole::kParent);
+    }
+  }
+}
+
+void PostForkInChild() {
+  for (const auto& [event_engine, executor, timer_manager] :
+       LockForkHandlers()) {
+    if (executor != nullptr) {
+      executor->PostFork();
+    }
+    if (timer_manager) {
+      timer_manager->PostFork();
+    }
+    if (event_engine != nullptr) {
+      event_engine->AfterFork(PosixEventEngine::OnForkRole::kChild);
+    }
+  }
+}
+
+void RegisterEventEngineForFork(
+    const std::shared_ptr<PosixEventEngine>& posix_engine,
+    const std::shared_ptr<ThreadPool>& executor,
+    const std::shared_ptr<TimerManager>& timer_manager) {
+  if (!grpc_core::Fork::Enabled()) {
+    return;
+  }
+  grpc_core::MutexLock lock(fork_mu.get());
+  // We have mutex, cleanup if there's any expired event engines
+  fork_handlers->erase(
+      std::remove_if(fork_handlers->begin(), fork_handlers->end(),
+                     [](const auto& ptr) {
+                       return ptr.event_engine.expired() &&
+                              ptr.executor.expired();
+                     }),
+      fork_handlers->end());
+  fork_handlers->emplace_back(posix_engine, executor, timer_manager);
+  static bool handlers_installed = false;
+  if (!handlers_installed) {
+    pthread_atfork(PrepareFork, PostForkInParent, PostForkInChild);
+    handlers_installed = true;
+  }
+}
+
+#else  // GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+void RegisterEventEngineForFork(
+    const std::shared_ptr<PosixEventEngine>& /* posix_engine */,
+    const std::shared_ptr<ThreadPool>& /* executor */,
+    const std::shared_ptr<TimerManager>& /* timer_manager */) {}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
 }  // namespace
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+PosixEventEngine::PollingCycle::PollingCycle(
+    std::shared_ptr<ThreadPool> executor,
+    std::shared_ptr<PosixEventPoller> poller)
+    : executor_(std::move(executor)),
+      poller_(std::move(poller)),
+      is_scheduled_(1) {
+  CHECK_NE(poller_, nullptr);
+  executor_->Run([this]() { PollerWorkInternal(); });
+}
+
+PosixEventEngine::PollingCycle::~PollingCycle() {
+  done_ = true;
+  poller_->Kick();
+  grpc_core::MutexLock lock(&mu_);
+  while (is_scheduled_ > 0) {
+    cond_.Wait(&mu_);
+  }
+}
+
+void PosixEventEngine::PollingCycle::PollerWorkInternal() {
+  grpc_core::MutexLock lock(&mu_);
+  --is_scheduled_;
+  CHECK_EQ(is_scheduled_, 0);
+  bool again = false;
+  // TODO(vigneshbabu): The timeout specified here is arbitrary. For
+  // instance, this can be improved by setting the timeout to the next
+  // expiring timer.
+  auto result = poller_->Work(24h, [&]() { again = true; });
+  if (result == Poller::WorkResult::kDeadlineExceeded) {
+    // The EventEngine is not shutting down but the next asynchronous
+    // PollerWorkInternal did not get scheduled. Schedule it now.
+    again = true;
+  }
+  if (!done_ && again) {
+    executor_->Run([this]() { PollerWorkInternal(); });
+    ++is_scheduled_;
+  }
+  cond_.SignalAll();
+}
+
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
 void AsyncConnect::Start(EventEngine::Duration timeout) {
   on_writable_ = PosixEngineClosure::ToPermanentClosure(
       [this](absl::Status status) { OnWritable(std::move(status)); });
@@ -120,9 +269,7 @@ void AsyncConnect::OnTimeoutExpired(absl::Status status) {
 
 void AsyncConnect::OnWritable(absl::Status status)
     ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  int so_error = 0;
   socklen_t so_error_size;
-  int err;
   int done;
   int consumed_refs = 1;
   EventHandle* fd;
@@ -185,14 +332,21 @@ void AsyncConnect::OnWritable(absl::Status status)
     return;
   }
 
+  int so_error = 0;
+  PosixError err;
   do {
     so_error_size = sizeof(so_error);
-    err = getsockopt(fd->WrappedFd(), SOL_SOCKET, SO_ERROR, &so_error,
-                     &so_error_size);
-  } while (err < 0 && errno == EINTR);
-  if (err < 0) {
-    status = absl::FailedPreconditionError(
-        absl::StrCat("getsockopt: ", std::strerror(errno)));
+    err = fd->Poller()->posix_interface().GetSockOpt(
+        fd->WrappedFd(), SOL_SOCKET, SO_ERROR, &so_error, &so_error_size);
+  } while (err.IsPosixError(EINTR));
+  if (!err.ok()) {
+    if (err.IsWrongGenerationError()) {
+      status = absl::FailedPreconditionError(
+          "getsockopt: file descriptor was created pre fork");
+    } else {
+      status = absl::FailedPreconditionError(
+          absl::StrCat("getsockopt: ", err.StrError()));
+    }
     return;
   }
 
@@ -238,16 +392,26 @@ void AsyncConnect::OnWritable(absl::Status status)
 
 EventEngine::ConnectionHandle
 PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
-    int fd, EventEngine::OnConnectCallback on_connect,
+    const FileDescriptor& fd, EventEngine::OnConnectCallback on_connect,
     const EventEngine::ResolvedAddress& addr,
     const PosixTcpOptions& tcp_options, MemoryAllocator memory_allocator,
     EventEngine::Duration timeout) {
-  int err;
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  PosixError err;
   int connect_errno;
+  PosixEventPoller* poller = poller_.get();
   do {
-    err = connect(fd, addr.address(), addr.size());
-  } while (err < 0 && errno == EINTR);
-  connect_errno = (err < 0) ? errno : 0;
+    err = poller->posix_interface().Connect(fd, addr.address(), addr.size());
+  } while (err.IsPosixError(EINTR));
+  if (err.IsWrongGenerationError()) {
+    Run([on_connect = std::move(on_connect),
+         ep = absl::FailedPreconditionError(
+             "connect failed: file descriptor was created before "
+             "fork")]() mutable { on_connect(std::move(ep)); });
+    return EventEngine::ConnectionHandle::kInvalid;
+  }
+
+  connect_errno = err.errno_value().value_or(0);
 
   auto addr_uri = ResolvedAddressToURI(addr);
   if (!addr_uri.ok()) {
@@ -259,7 +423,6 @@ PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
   }
 
   std::string name = absl::StrCat("tcp-client:", addr_uri.value());
-  PosixEventPoller* poller = poller_manager_->Poller();
   EventHandle* handle =
       poller->CreateHandle(fd, name, poller->CanTrackErrors());
 
@@ -300,6 +463,9 @@ PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
   // Start asynchronous connect and return the connection id.
   ac->Start(timeout);
   return {static_cast<intptr_t>(connection_id), 0};
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  grpc_core::Crash("Polling is not available on this platform");
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 void PosixEventEngine::OnConnectFinishInternal(int connection_handle) {
@@ -311,145 +477,57 @@ void PosixEventEngine::OnConnectFinishInternal(int connection_handle) {
   }
 }
 
-PosixEnginePollerManager::PosixEnginePollerManager(
-    std::shared_ptr<ThreadPool> executor)
-    : poller_(grpc_event_engine::experimental::MakeDefaultPoller(this)),
-      executor_(std::move(executor)),
-      trigger_shutdown_called_(false) {}
-
-PosixEnginePollerManager::PosixEnginePollerManager(
-    std::shared_ptr<PosixEventPoller> poller)
-    : poller_(std::move(poller)),
-      poller_state_(PollerState::kExternal),
-      executor_(nullptr),
-      trigger_shutdown_called_(false) {
-  DCHECK_NE(poller_, nullptr);
-}
-
-void PosixEnginePollerManager::Run(
-    experimental::EventEngine::Closure* closure) {
-  if (executor_ != nullptr) {
-    executor_->Run(closure);
-  }
-}
-
-void PosixEnginePollerManager::Run(absl::AnyInvocable<void()> cb) {
-  if (executor_ != nullptr) {
-    executor_->Run(std::move(cb));
-  }
-}
-
-void PosixEnginePollerManager::TriggerShutdown() {
-  DCHECK(trigger_shutdown_called_ == false);
-  trigger_shutdown_called_ = true;
-  // If the poller is external, dont try to shut it down. Otherwise
-  // set poller state to PollerState::kShuttingDown.
-  if (poller_state_.exchange(PollerState::kShuttingDown) ==
-      PollerState::kExternal) {
-    poller_ = nullptr;
-    return;
-  }
-  poller_->Kick();
-}
-
 std::shared_ptr<PosixEventEngine> PosixEventEngine::MakePosixEventEngine() {
-  // Constructor is private, can't use std::make_shared
-  return std::shared_ptr<PosixEventEngine>(new PosixEventEngine());
+  // Can't use make_shared as ctor is private
+  std::shared_ptr<PosixEventEngine> engine(new PosixEventEngine());
+  RegisterEventEngineForFork(engine, engine->executor_, engine->timer_manager_);
+  return engine;
 }
 
-#ifdef GRPC_POSIX_SOCKET_TCP
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 
-// The posix EventEngine returned by this method would have a shared ownership
-// of the poller and would not be in-charge of driving the poller by calling
-// its Work(..) method. Instead its up to the test to drive the poller. The
-// returned posix EventEngine will also not attempt to shutdown the poller
-// since it does not own it.
 std::shared_ptr<PosixEventEngine>
 PosixEventEngine::MakeTestOnlyPosixEventEngine(
     std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
         test_only_poller) {
-  // Constructor is private, can't use std::make_shared
-  return std::shared_ptr<PosixEventEngine>(
+  std::shared_ptr<PosixEventEngine> engine(
       new PosixEventEngine(std::move(test_only_poller)));
-}
-#endif  // GRPC_POSIX_SOCKET_TCP
-
-PosixEnginePollerManager::~PosixEnginePollerManager() {
-  if (poller_ != nullptr) {
-    poller_->Shutdown();
-  }
+  RegisterEventEngineForFork(engine, engine->executor_, engine->timer_manager_);
+  return engine;
 }
 
 PosixEventEngine::PosixEventEngine(std::shared_ptr<PosixEventPoller> poller)
-    : grpc_core::KeepsGrpcInitialized(
-          /*enabled=*/!grpc_core::IsPosixEeSkipGrpcInitEnabled()),
-      connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
-      timer_manager_(std::make_shared<TimerManager>(executor_)) {
-  g_timer_fork_manager->RegisterForkable(
-      timer_manager_, TimerForkCallbackMethods::Prefork,
-      TimerForkCallbackMethods::PostforkParent,
-      TimerForkCallbackMethods::PostforkChild);
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  poller_manager_ = std::make_shared<PosixEnginePollerManager>(poller);
-#endif
-}
+      poller_(std::move(poller)),
+      timer_manager_(std::make_shared<TimerManager>(executor_)) {}
 
 PosixEventEngine::PosixEventEngine()
-    : grpc_core::KeepsGrpcInitialized(
-          /*enabled=*/!grpc_core::IsPosixEeSkipGrpcInitEnabled()),
-      connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
-  g_timer_fork_manager->RegisterForkable(
-      timer_manager_, TimerForkCallbackMethods::Prefork,
-      TimerForkCallbackMethods::PostforkParent,
-      TimerForkCallbackMethods::PostforkChild);
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
-  // The threadpool must be instantiated after the poller otherwise, the
-  // process will deadlock when forking.
-  if (poller_manager_->Poller() != nullptr) {
-    executor_->Run([poller_manager = poller_manager_]() {
-      PollerWorkInternal(poller_manager);
-    });
-  }
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
+  SchedulePoller();
 }
 
-void PosixEventEngine::PollerWorkInternal(
-    std::shared_ptr<PosixEnginePollerManager> poller_manager) {
-  // TODO(vigneshbabu): The timeout specified here is arbitrary. For instance,
-  // this can be improved by setting the timeout to the next expiring timer.
-  PosixEventPoller* poller = poller_manager->Poller();
-  ThreadPool* executor = poller_manager->Executor();
-  auto result = poller->Work(24h, [executor, &poller_manager]() {
-    executor->Run([poller_manager]() mutable {
-      PollerWorkInternal(std::move(poller_manager));
-    });
-  });
-  if (result == Poller::WorkResult::kDeadlineExceeded) {
-    // The EventEngine is not shutting down but the next asynchronous
-    // PollerWorkInternal did not get scheduled. Schedule it now.
-    executor->Run([poller_manager = std::move(poller_manager)]() {
-      PollerWorkInternal(poller_manager);
-    });
-  } else if (result == Poller::WorkResult::kKicked &&
-             poller_manager->IsShuttingDown()) {
-    // The Poller Got Kicked and poller_state_ is set to
-    // PollerState::kShuttingDown. This can currently happen only from the
-    // EventEngine destructor. Sample the use_count of poller_manager. If the
-    // sampled use_count is > 1, there is one more instance of Work(...)
-    // which hasn't returned yet. Send another Kick to be safe to ensure the
-    // pending instance of Work(..) also breaks out. Its possible that the other
-    // instance of Work(..) had already broken out before this Kick is sent. In
-    // that case, the Kick is spurious but it shouldn't cause any side effects.
-    if (poller_manager.use_count() > 1) {
-      poller->Kick();
-    }
-  }
+#else  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+std::shared_ptr<PosixEventEngine>
+PosixEventEngine::MakeTestOnlyPosixEventEngine(
+    std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+        test_only_poller) {
+  grpc_core::Crash(
+      "PosixEventEngine::MakeTestOnlyPosixEventEngine not available on this "
+      "platform");
 }
 
+PosixEventEngine::PosixEventEngine()
+    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
+      timer_manager_(std::make_shared<TimerManager>(executor_)) {}
+
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
 #endif  // GRPC_POSIX_SOCKET_TCP
 
 struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
@@ -482,12 +560,10 @@ PosixEventEngine::~PosixEventEngine() {
     }
     CHECK(GPR_LIKELY(known_handles_.empty()));
   }
-  timer_manager_->Shutdown();
 #if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  if (poller_manager_ != nullptr) {
-    poller_manager_->TriggerShutdown();
-  }
+  polling_cycle_.reset();
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  timer_manager_->Shutdown();
   executor_->Quiesce();
 }
 
@@ -560,39 +636,95 @@ void PosixEventEngine::PosixDNSResolver::LookupTXT(LookupTXTCallback on_resolve,
   dns_resolver_->LookupTXT(std::move(on_resolve), name);
 }
 
+#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+
+void PosixEventEngine::RegisterAresResolverForFork(
+    GRPC_UNUSED AresResolver* resolver) {
+#if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+  grpc_core::MutexLock lock(&resolver_handles_mu_);
+  resolver_handles_.emplace_back(resolver->GetReinitHandle());
+  // Cleanup in case we have expired callbacks, prevents the list from
+  // growing indefinitely
+  auto new_end = std::remove_if(
+      resolver_handles_.begin(), resolver_handles_.end(),
+      +[](const std::weak_ptr<AresResolver::ReinitHandle>& callback) {
+        return callback.expired();
+      });
+  resolver_handles_.erase(new_end, resolver_handles_.end());
+#endif  // GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+}
+
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 PosixEventEngine::GetDNSResolver(
     GRPC_UNUSED const EventEngine::DNSResolver::ResolverOptions& options) {
-#ifndef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
-  grpc_core::Crash("Unable to get DNS resolver for this platform.");
-#else  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
   // If c-ares is supported on the platform, build according to user's
   // configuration.
-  if (ShouldUseAresDnsResolver()) {
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  if (!ShouldUseAresDnsResolver()) {
     GRPC_TRACE_LOG(event_engine_dns, INFO)
-        << "PosixEventEngine::" << this << " creating AresResolver";
-    auto ares_resolver = AresResolver::CreateAresResolver(
-        options.dns_server,
-        std::make_unique<GrpcPolledFdFactoryPosix>(poller_manager_->Poller()),
-        shared_from_this());
-    if (!ares_resolver.ok()) {
-      return ares_resolver.status();
-    }
-    return std::make_unique<PosixEventEngine::PosixDNSResolver>(
-        std::move(*ares_resolver));
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+        << "PosixEventEngine::" << this << " creating NativePosixDNSResolver";
+    return std::make_unique<NativePosixDNSResolver>(shared_from_this());
   }
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "PosixEventEngine::" << this << " creating AresResolver";
+  auto ares_resolver = AresResolver::CreateAresResolver(
+      options.dns_server,
+      std::make_unique<GrpcPolledFdFactoryPosix>(poller_.get()),
+      shared_from_this());
+  if (!ares_resolver.ok()) {
+    return ares_resolver.status();
+  }
+  RegisterAresResolverForFork(ares_resolver->get());
+  return std::make_unique<PosixEventEngine::PosixDNSResolver>(
+      std::move(*ares_resolver));
+#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  grpc_core::Crash("Can not create CAres resolver with disabled poller");
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+}
+
+#else  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+PosixEventEngine::GetDNSResolver(
+    GRPC_UNUSED const EventEngine::DNSResolver::ResolverOptions& options) {
   GRPC_TRACE_LOG(event_engine_dns, INFO)
       << "PosixEventEngine::" << this << " creating NativePosixDNSResolver";
   return std::make_unique<NativePosixDNSResolver>(shared_from_this());
-#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 }
 
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+#else   // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+PosixEventEngine::GetDNSResolver(
+    GRPC_UNUSED const EventEngine::DNSResolver::ResolverOptions& options) {
+  grpc_core::Crash("Unable to get DNS resolver for this platform.");
+}
+
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
 bool PosixEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
-bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
+std::unique_ptr<EventEngine::Endpoint> PosixEventEngine::CreateEndpointFromFd(
+    int fd, const EndpointConfig& config) {
+  auto options = TcpOptionsFromEndpointConfig(config);
+  MemoryAllocator allocator;
+  if (options.memory_allocator_factory != nullptr) {
+    return CreatePosixEndpointFromFd(
+        fd, config,
+        options.memory_allocator_factory->CreateMemoryAllocator(
+            absl::StrCat("allocator:", fd)));
+  }
+  return CreatePosixEndpointFromFd(
+      fd, config,
+      options.resource_quota->memory_quota()->CreateMemoryAllocator(
+          absl::StrCat("allocator:", fd)));
+}
+
 #if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   int connection_handle = handle.keys[0];
   if (connection_handle <= 0) {
     return false;
@@ -641,83 +773,48 @@ bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
     delete ac;
   }
   return connection_cancel_success;
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  grpc_core::Crash(
-      "EventEngine::CancelConnect is not supported on this platform");
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 EventEngine::ConnectionHandle PosixEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
     const EndpointConfig& args, MemoryAllocator memory_allocator,
     Duration timeout) {
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  CHECK_NE(poller_manager_, nullptr);
   PosixTcpOptions options = TcpOptionsFromEndpointConfig(args);
-  absl::StatusOr<PosixSocketWrapper::PosixSocketCreateResult> socket =
-      PosixSocketWrapper::CreateAndPrepareTcpClientSocket(options, addr);
+  absl::StatusOr<EventEnginePosixInterface::PosixSocketCreateResult> socket =
+      GetPollerChecked()->posix_interface().CreateAndPrepareTcpClientSocket(
+          options, addr);
   if (!socket.ok()) {
     Run([on_connect = std::move(on_connect),
          status = socket.status()]() mutable { on_connect(status); });
     return EventEngine::ConnectionHandle::kInvalid;
   }
   return CreateEndpointFromUnconnectedFdInternal(
-      (*socket).sock.Fd(), std::move(on_connect), (*socket).mapped_target_addr,
+      (*socket).sock, std::move(on_connect), (*socket).mapped_target_addr,
       options, std::move(memory_allocator), timeout);
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  grpc_core::Crash("EventEngine::Connect is not supported on this platform");
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
 EventEngine::ConnectionHandle PosixEventEngine::CreateEndpointFromUnconnectedFd(
     int fd, EventEngine::OnConnectCallback on_connect,
     const EventEngine::ResolvedAddress& addr, const EndpointConfig& config,
     MemoryAllocator memory_allocator, EventEngine::Duration timeout) {
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   return CreateEndpointFromUnconnectedFdInternal(
-      fd, std::move(on_connect), addr, TcpOptionsFromEndpointConfig(config),
-      std::move(memory_allocator), timeout);
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  grpc_core::Crash(
-      "EventEngine::CreateEndpointFromUnconnectedFd is not supported on this "
-      "platform");
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+      GetPollerChecked()->posix_interface().Adopt(fd), std::move(on_connect),
+      addr, TcpOptionsFromEndpointConfig(config), std::move(memory_allocator),
+      timeout);
 }
 
 std::unique_ptr<EventEngine::Endpoint>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   DCHECK_GT(fd, 0);
-  PosixEventPoller* poller = poller_manager_->Poller();
-  DCHECK_NE(poller, nullptr);
+  PosixEventPoller* poller = GetPollerChecked();
   EventHandle* handle =
-      poller->CreateHandle(fd, "tcp-client", poller->CanTrackErrors());
+      poller->CreateHandle(poller->posix_interface().Adopt(fd), "tcp-client",
+                           poller->CanTrackErrors());
   return CreatePosixEndpoint(handle, nullptr, shared_from_this(),
                              std::move(memory_allocator),
                              TcpOptionsFromEndpointConfig(config));
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  grpc_core::Crash(
-      "PosixEventEngine::CreatePosixEndpointFromFd is not supported on "
-      "this platform");
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-}
-
-std::unique_ptr<EventEngine::Endpoint> PosixEventEngine::CreateEndpointFromFd(
-    int fd, const EndpointConfig& config) {
-  auto options = TcpOptionsFromEndpointConfig(config);
-  MemoryAllocator allocator;
-  if (options.memory_allocator_factory != nullptr) {
-    return CreatePosixEndpointFromFd(
-        fd, config,
-        options.memory_allocator_factory->CreateMemoryAllocator(
-            absl::StrCat("allocator:", fd)));
-  }
-  return CreatePosixEndpointFromFd(
-      fd, config,
-      options.resource_quota->memory_quota()->CreateMemoryAllocator(
-          absl::StrCat("allocator:", fd)));
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
@@ -726,7 +823,6 @@ PosixEventEngine::CreateListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   PosixEventEngineWithFdSupport::PosixAcceptCallback posix_on_accept =
       [on_accept_cb = std::move(on_accept)](
           int /*listener_fd*/, std::unique_ptr<EventEngine::Endpoint> ep,
@@ -736,12 +832,7 @@ PosixEventEngine::CreateListener(
       };
   return std::make_unique<PosixEngineListener>(
       std::move(posix_on_accept), std::move(on_shutdown), config,
-      std::move(memory_allocator_factory), poller_manager_->Poller(),
-      shared_from_this());
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-  grpc_core::Crash(
-      "EventEngine::CreateListener is not supported on this platform");
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+      std::move(memory_allocator_factory), poller_.get(), shared_from_this());
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
@@ -750,15 +841,130 @@ PosixEventEngine::CreatePosixListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   return std::make_unique<PosixEngineListener>(
       std::move(on_accept), std::move(on_shutdown), config,
-      std::move(memory_allocator_factory), poller_manager_->Poller(),
-      shared_from_this());
-#else   // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+      std::move(memory_allocator_factory), poller_.get(), shared_from_this());
+}
+
+void PosixEventEngine::SchedulePoller() {
+  if (poller_ != nullptr) {
+    grpc_core::MutexLock lock(&mu_);
+    CHECK(!polling_cycle_.has_value());
+    polling_cycle_.emplace(executor_, poller_);
+  }
+}
+
+void PosixEventEngine::ResetPollCycle() {
+  grpc_core::MutexLock lock(&mu_);
+  polling_cycle_.reset();
+}
+
+#else  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
+  grpc_core::Crash(
+      "EventEngine::CancelConnect is not supported on this platform");
+}
+
+EventEngine::ConnectionHandle PosixEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& args, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  grpc_core::Crash("EventEngine::Connect is not supported on this platform");
+}
+
+EventEngine::ConnectionHandle PosixEventEngine::CreateEndpointFromUnconnectedFd(
+    int fd, EventEngine::OnConnectCallback on_connect,
+    const EventEngine::ResolvedAddress& addr, const EndpointConfig& config,
+    MemoryAllocator memory_allocator, EventEngine::Duration timeout) {
+  grpc_core::Crash(
+      "EventEngine::CreateEndpointFromUnconnectedFd is not supported on this "
+      "platform");
+}
+
+std::unique_ptr<EventEngine::Endpoint>
+PosixEventEngine::CreatePosixEndpointFromFd(int fd,
+                                            const EndpointConfig& config,
+                                            MemoryAllocator memory_allocator) {
+  grpc_core::Crash(
+      "PosixEventEngine::CreatePosixEndpointFromFd is not supported on "
+      "this platform");
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+PosixEventEngine::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(
       "EventEngine::CreateListener is not supported on this platform");
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+PosixEventEngine::CreatePosixListener(
+    PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  grpc_core::Crash(
+      "EventEngine::CreateListener is not supported on this platform");
+}
+
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+#if GRPC_POSIX_SOCKET_TCP && GRPC_ENABLE_FORK_SUPPORT && \
+    GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+void PosixEventEngine::AfterFork(OnForkRole on_fork_role) {
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  PosixEventPoller* poller = GetPollerChecked();
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  if (on_fork_role == OnForkRole::kChild) {
+    if (grpc_core::IsEventEngineForkEnabled()) {
+      AfterForkInChild();
+    } else {
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+      poller->HandleForkInChild();
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+    }
+  }
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  poller->ResetKickState();
+  SchedulePoller();
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+}
+
+void PosixEventEngine::BeforeFork() {
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  ResetPollCycle();
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+}
+
+void PosixEventEngine::AfterForkInChild() {
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  grpc_core::MutexLock lock(&resolver_handles_mu_);
+  for (const auto& cb : resolver_handles_) {
+    auto locked = cb.lock();
+    if (locked != nullptr) {
+      locked->Reset(absl::CancelledError("Reset resolver on fork"));
+    }
+  }
+#endif
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  GetPollerChecked()->HandleForkInChild();
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  for (const auto& cb : resolver_handles_) {
+    auto locked = cb.lock();
+    if (locked != nullptr) {
+      locked->Restart();
+    }
+  }
+#endif
 }
 
+#endif  // GRPC_POSIX_SOCKET_TCP && GRPC_ENABLE_FORK_SUPPORT &&
+        // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
 }  // namespace grpc_event_engine::experimental