grpc 1.73.0 → 1.75.0

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

@@ -22,8 +22,8 @@
 #include <stdint.h>
 
 #include <atomic>
-#include <list>
 #include <memory>
+#include <string>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
@@ -35,6 +35,7 @@
 #include "src/core/lib/event_engine/poller.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/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"
 
@@ -51,7 +52,6 @@
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix_default.h"
 #include "src/core/lib/event_engine/time_util.h"
-#include "src/core/util/fork.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
@@ -68,12 +68,11 @@ using Events = absl::InlinedVector<PollEventHandle*, 5>;
 
 class PollEventHandle : public EventHandle {
  public:
-  PollEventHandle(int fd, std::shared_ptr<PollPoller> poller)
+  PollEventHandle(FileDescriptor fd, std::shared_ptr<PollPoller> poller)
       : fd_(fd),
         pending_actions_(0),
-        fork_fd_list_(this),
         poller_handles_list_(this),
-        scheduler_(poller->GetScheduler()),
+        thread_pool_(poller->GetThreadPool()),
         poller_(std::move(poller)),
         is_orphaned_(false),
         is_shutdown_(false),
@@ -108,14 +107,14 @@ class PollEventHandle : public EventHandle {
     grpc_core::MutexLock lock(&poller_->mu_);
     poller_->PollerHandlesListRemoveHandle(this);
   }
-  int WrappedFd() override { return fd_; }
+  FileDescriptor WrappedFd() override { return fd_; }
   bool IsOrphaned() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     return is_orphaned_;
   }
   void CloseFd() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     if (!released_ && !closed_) {
       closed_ = true;
-      close(fd_);
+      poller_->posix_interface().Close(fd_);
     }
   }
   bool IsPollhup() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { return pollhup_; }
@@ -132,7 +131,7 @@ class PollEventHandle : public EventHandle {
   void SetWatched(int watch_mask) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     watch_mask_ = watch_mask;
   }
-  void OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
+  void OrphanHandle(PosixEngineClosure* on_done, FileDescriptor* release_fd,
                     absl::string_view reason) override;
   void ShutdownHandle(absl::Status why) override;
   void NotifyOnRead(PosixEngineClosure* on_read) override;
@@ -176,14 +175,13 @@ class PollEventHandle : public EventHandle {
   void Unref() {
     if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
       if (on_done_ != nullptr) {
-        scheduler_->Run(on_done_);
+        thread_pool_->Run(on_done_);
       }
       delete this;
     }
   }
   ~PollEventHandle() override = default;
   grpc_core::Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
-  PollPoller::HandlesList& ForkFdListPos() { return fork_fd_list_; }
   PollPoller::HandlesList& PollerHandlesListPos() {
     return poller_handles_list_;
   }
@@ -199,11 +197,10 @@ class PollEventHandle : public EventHandle {
   // required.
   grpc_core::Mutex mu_;
   std::atomic<int> ref_count_{1};
-  int fd_;
+  FileDescriptor fd_;
   int pending_actions_;
-  PollPoller::HandlesList fork_fd_list_;
   PollPoller::HandlesList poller_handles_list_;
-  Scheduler* scheduler_;
+  ThreadPool* thread_pool_;
   std::shared_ptr<PollPoller> poller_;
   bool is_orphaned_;
   bool is_shutdown_;
@@ -219,26 +216,6 @@ class PollEventHandle : public EventHandle {
 };
 
 namespace {
-// Only used when GRPC_ENABLE_FORK_SUPPORT=1
-std::list<PollPoller*> fork_poller_list;
-
-gpr_mu fork_fd_list_mu;
-
-void ForkPollerListAddPoller(PollPoller* poller) {
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_lock(&fork_fd_list_mu);
-    fork_poller_list.push_back(poller);
-    gpr_mu_unlock(&fork_fd_list_mu);
-  }
-}
-
-void ForkPollerListRemovePoller(PollPoller* poller) {
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_lock(&fork_fd_list_mu);
-    fork_poller_list.remove(poller);
-    gpr_mu_unlock(&fork_fd_list_mu);
-  }
-}
 
 // Returns the number of milliseconds elapsed between now and start timestamp.
 int PollElapsedTimeToMillis(grpc_core::Timestamp start) {
@@ -255,42 +232,10 @@ int PollElapsedTimeToMillis(grpc_core::Timestamp start) {
   }
 }
 
-bool InitPollPollerPosix();
-
-// Called by the child process's post-fork handler to close open fds,
-// including the global epoll fd of each poller. This allows gRPC to shutdown
-// in the child process without interfering with connections or RPCs ongoing
-// in the parent.
-void ResetEventManagerOnFork() {
-  gpr_mu_lock(&fork_fd_list_mu);
-  // Delete all registered pollers.
-  while (!fork_poller_list.empty()) {
-    PollPoller* poller = fork_poller_list.front();
-    fork_poller_list.pop_front();
-    poller->Close();
-  }
-  gpr_mu_unlock(&fork_fd_list_mu);
-  InitPollPollerPosix();
-}
-
-// It is possible that GLIBC has epoll but the underlying kernel doesn't.
-// Create epoll_fd to make sure epoll support is available
-bool InitPollPollerPosix() {
-  if (!grpc_event_engine::experimental::SupportsWakeupFd()) {
-    return false;
-  }
-  if (grpc_core::Fork::Enabled()) {
-    if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
-            ResetEventManagerOnFork)) {
-      gpr_mu_init(&fork_fd_list_mu);
-    }
-  }
-  return true;
-}
-
 }  // namespace
 
-EventHandle* PollPoller::CreateHandle(int fd, absl::string_view /*name*/,
+EventHandle* PollPoller::CreateHandle(FileDescriptor fd,
+                                      absl::string_view /*name*/,
                                       bool track_err) {
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
@@ -302,7 +247,8 @@ EventHandle* PollPoller::CreateHandle(int fd, absl::string_view /*name*/,
   return handle;
 }
 
-void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
+void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done,
+                                   FileDescriptor* release_fd,
                                    absl::string_view /*reason*/) {
   ForceRemoveHandleFromPoller();
   {
@@ -327,7 +273,7 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
     }
     // signal read/write closed to OS so that future operations fail.
     if (!released_) {
-      shutdown(fd_, SHUT_RDWR);
+      poller_->posix_interface().Shutdown(fd_, SHUT_RDWR);
     }
     if (!IsWatched()) {
       CloseFd();
@@ -347,7 +293,7 @@ int PollEventHandle::NotifyOnLocked(PosixEngineClosure** st,
                                     PosixEngineClosure* closure) {
   if (is_shutdown_ || pollhup_) {
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
   } else if (*st == reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
     // not ready ==> switch to a waiting state by setting the closure
     *st = closure;
@@ -356,7 +302,7 @@ int PollEventHandle::NotifyOnLocked(PosixEngineClosure** st,
     // already ready ==> queue the closure to run immediately
     *st = reinterpret_cast<PosixEngineClosure*>(kClosureNotReady);
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
     return 1;
   } else {
     // upcallptr was set to a different closure.  This is an error!
@@ -381,7 +327,7 @@ int PollEventHandle::SetReadyLocked(PosixEngineClosure** st) {
     PosixEngineClosure* closure = *st;
     *st = reinterpret_cast<PosixEngineClosure*>(kClosureNotReady);
     closure->SetStatus(shutdown_error_);
-    scheduler_->Run(closure);
+    thread_pool_->Run(closure);
     return 1;
   }
 }
@@ -395,10 +341,11 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
     // only shutdown once
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      shutdown_error_ = why;
-      grpc_core::StatusSetInt(&shutdown_error_,
-                              grpc_core::StatusIntProperty::kRpcStatus,
-                              GRPC_STATUS_UNAVAILABLE);
+      shutdown_error_ = std::move(why);
+      grpc_core::StatusSetInt(
+          &shutdown_error_, grpc_core::StatusIntProperty::kRpcStatus,
+          absl::IsCancelled(shutdown_error_) ? GRPC_STATUS_CANCELLED
+                                             : GRPC_STATUS_UNAVAILABLE);
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
@@ -455,7 +402,7 @@ void PollEventHandle::NotifyOnError(PosixEngineClosure* on_error) {
   on_error->SetStatus(
       absl::Status(absl::StatusCode::kCancelled,
                    "Polling engine does not support tracking errors"));
-  scheduler_->Run(on_error);
+  thread_pool_->Run(on_error);
 }
 
 void PollEventHandle::SetReadable() {
@@ -556,30 +503,17 @@ void PollPoller::PollerHandlesListRemoveHandle(PollEventHandle* handle) {
   --num_poll_handles_;
 }
 
-PollPoller::PollPoller(Scheduler* scheduler)
-    : scheduler_(scheduler),
-      use_phony_poll_(false),
-      was_kicked_(false),
-      was_kicked_ext_(false),
-      num_poll_handles_(0),
-      poll_handles_list_head_(nullptr),
-      closed_(false) {
-  wakeup_fd_ = *CreateWakeupFd();
-  CHECK(wakeup_fd_ != nullptr);
-  ForkPollerListAddPoller(this);
-}
-
-PollPoller::PollPoller(Scheduler* scheduler, bool use_phony_poll)
-    : scheduler_(scheduler),
+PollPoller::PollPoller(std::shared_ptr<ThreadPool> thread_pool,
+                       bool use_phony_poll)
+    : thread_pool_(std::move(thread_pool)),
       use_phony_poll_(use_phony_poll),
       was_kicked_(false),
       was_kicked_ext_(false),
       num_poll_handles_(0),
       poll_handles_list_head_(nullptr),
       closed_(false) {
-  wakeup_fd_ = *CreateWakeupFd();
+  wakeup_fd_ = *CreateWakeupFd(&posix_interface());
   CHECK(wakeup_fd_ != nullptr);
-  ForkPollerListAddPoller(this);
 }
 
 PollPoller::~PollPoller() {
@@ -628,9 +562,12 @@ Poller::WorkResult PollPoller::Work(
     }
 
     pfd_count = 1;
-    pfds[0].fd = wakeup_fd_->ReadFd();
+    auto wakeup_fd = posix_interface().GetFd(wakeup_fd_->ReadFd());
+    CHECK(wakeup_fd.ok()) << wakeup_fd.StrError();
+    pfds[0].fd = *wakeup_fd;
     pfds[0].events = POLLIN;
     pfds[0].revents = 0;
+    // Event handles from before fork, need to be notified
     PollEventHandle* head = poll_handles_list_head_;
     while (head != nullptr) {
       {
@@ -640,27 +577,32 @@ Poller::WorkResult PollPoller::Work(
         // poll handle list for the poller under the poller lock.
         CHECK(!head->IsOrphaned());
         if (!head->IsPollhup()) {
-          pfds[pfd_count].fd = head->WrappedFd();
-          watchers[pfd_count] = head;
-          // BeginPollLocked takes a ref of the handle. It also marks the
-          // fd as Watched with an appropriate watch_mask. The watch_mask
-          // is 0 if the fd is shutdown or if the fd is already ready (i.e
-          // both read and write events are already available) and doesn't
-          // need to be polled again. The watch_mask is > 0 otherwise
-          // indicating the fd needs to be polled.
-          pfds[pfd_count].events = head->BeginPollLocked(POLLIN, POLLOUT);
-          pfd_count++;
+          if (auto file_descriptor = posix_interface().GetFd(head->WrappedFd());
+              file_descriptor.ok()) {
+            pfds[pfd_count].fd = *file_descriptor;
+            watchers[pfd_count] = head;
+            // BeginPollLocked takes a ref of the handle. It also marks the
+            // fd as Watched with an appropriate watch_mask. The watch_mask
+            // is 0 if the fd is shutdown or if the fd is already ready (i.e
+            // both read and write events are already available) and doesn't
+            // need to be polled again. The watch_mask is > 0 otherwise
+            // indicating the fd needs to be polled.
+            pfds[pfd_count].events = head->BeginPollLocked(POLLIN, POLLOUT);
+            pfd_count++;
+          } else {
+            LOG(ERROR) << "Polling FD from a wrong generation: "
+                       << head->WrappedFd();
+          }
         }
       }
       head = head->PollerHandlesListPos().next;
     }
     mu_.Unlock();
-
     if (!use_phony_poll_ || timeout_ms == 0 || pfd_count == 1) {
       // If use_phony_poll is true and pfd_count == 1, it implies only the
       // wakeup_fd is present. Allow the call to get blocked in this case as
       // well instead of crashing. This is because the poller::Work is called
-      // right after an event enging is constructed. Even if phony poll is
+      // right after an event engine is constructed. Even if phony poll is
       // expected to be used, we dont want to check for it until some actual
       // event handles are registered. Otherwise the EventEngine construction
       // may crash.
@@ -778,24 +720,45 @@ Poller::WorkResult PollPoller::Work(
   return was_kicked_ext ? Poller::WorkResult::kKicked : Poller::WorkResult::kOk;
 }
 
-void PollPoller::Shutdown() { ForkPollerListRemovePoller(this); }
-
-void PollPoller::PrepareFork() { Kick(); }
-// TODO(vigneshbabu): implement
-void PollPoller::PostforkParent() {}
-// TODO(vigneshbabu): implement
-void PollPoller::PostforkChild() {}
-
 void PollPoller::Close() {
   grpc_core::MutexLock lock(&mu_);
   closed_ = true;
 }
 
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
-                                           bool use_phony_poll) {
-  static bool kPollPollerSupported = InitPollPollerPosix();
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+void PollPoller::HandleForkInChild() {
+  if (grpc_core::IsEventEngineForkEnabled()) {
+    posix_interface().AdvanceGeneration();
+  }
+  PollEventHandle* handle;
+  {
+    grpc_core::MutexLock lock(&mu_);
+    handle = poll_handles_list_head_;
+  }
+  while (handle != nullptr) {
+    handle->ShutdownHandle(absl::CancelledError("Closed on fork"));
+    handle = handle->PollerHandlesListPos().next;
+  }
+}
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+void PollPoller::ResetKickState() {
+  wakeup_fd_ = *CreateWakeupFd(&posix_interface());
+  // Sometimes there's "kick" signalled on the wakeup FD. We need to redo it on
+  // new fd
+  // TODO (eostroukhov): Need to consider merging kicked/kicked_ext
+  // with the wakeup_fd so there's no duplicate state.
+  grpc_core::MutexLock lock(&mu_);
+  was_kicked_ = false;
+  was_kicked_ext_ = false;
+}
+
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> thread_pool, bool use_phony_poll) {
+  static bool kPollPollerSupported =
+      grpc_event_engine::experimental::SupportsWakeupFd();
   if (kPollPollerSupported) {
-    return std::make_shared<PollPoller>(scheduler, use_phony_poll);
+    return std::make_shared<PollPoller>(std::move(thread_pool), use_phony_poll);
   }
   return nullptr;
 }
@@ -808,15 +771,10 @@ std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
 
 namespace grpc_event_engine::experimental {
 
-PollPoller::PollPoller(Scheduler* /* engine */) {
-  grpc_core::Crash("unimplemented");
-}
-
-void PollPoller::Shutdown() { grpc_core::Crash("unimplemented"); }
-
 PollPoller::~PollPoller() { grpc_core::Crash("unimplemented"); }
 
-EventHandle* PollPoller::CreateHandle(int /*fd*/, absl::string_view /*name*/,
+EventHandle* PollPoller::CreateHandle(FileDescriptor /*fd*/,
+                                      absl::string_view /*name*/,
                                       bool /*track_err*/) {
   grpc_core::Crash("unimplemented");
 }
@@ -831,15 +789,16 @@ void PollPoller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* /*scheduler*/,
-                                           bool /* use_phony_poll */) {
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> /*thread_pool*/, bool /* use_phony_poll */) {
   return nullptr;
 }
 
-void PollPoller::PrepareFork() { grpc_core::Crash("unimplemented"); }
-void PollPoller::PostforkParent() { grpc_core::Crash("unimplemented"); }
-void PollPoller::PostforkChild() { grpc_core::Crash("unimplemented"); }
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+void PollPoller::HandleForkInChild() { grpc_core::Crash("unimplemented"); }
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
+void PollPoller::ResetKickState() { grpc_core::Crash("unimplemented"); }
 void PollPoller::Close() { grpc_core::Crash("unimplemented"); }
 
 void PollPoller::KickExternal(bool /*ext*/) {

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

@@ -27,6 +27,7 @@
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
@@ -37,27 +38,26 @@ class PollEventHandle;
 class PollPoller : public PosixEventPoller,
                    public std::enable_shared_from_this<PollPoller> {
  public:
-  explicit PollPoller(Scheduler* scheduler);
-  PollPoller(Scheduler* scheduler, bool use_phony_poll);
-  EventHandle* CreateHandle(int fd, absl::string_view name,
+  explicit PollPoller(std::shared_ptr<ThreadPool> thread_pool,
+                      bool use_phony_poll = false);
+  EventHandle* CreateHandle(FileDescriptor fd, absl::string_view name,
                             bool track_err) override;
   Poller::WorkResult Work(
       grpc_event_engine::experimental::EventEngine::Duration timeout,
       absl::FunctionRef<void()> schedule_poll_again) override;
   std::string Name() override { return "poll"; }
   void Kick() override;
-  Scheduler* GetScheduler() { return scheduler_; }
-  void Shutdown() override;
+  ThreadPool* GetThreadPool() { return thread_pool_.get(); }
   bool CanTrackErrors() const override { return false; }
   ~PollPoller() override;
 
-  // Forkable
-  void PrepareFork() override;
-  void PostforkParent() override;
-  void PostforkChild() override;
-
   void Close();
 
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  void HandleForkInChild() override;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  void ResetKickState() override;
+
  private:
   void KickExternal(bool ext);
   void PollerHandlesListAddHandle(PollEventHandle* handle)
@@ -73,7 +73,7 @@ class PollPoller : public PosixEventPoller,
     PollEventHandle* prev = nullptr;
   };
   grpc_core::Mutex mu_;
-  Scheduler* scheduler_;
+  std::shared_ptr<ThreadPool> thread_pool_;
   bool use_phony_poll_;
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
   bool was_kicked_ext_ ABSL_GUARDED_BY(mu_);
@@ -87,8 +87,8 @@ class PollPoller : public PosixEventPoller,
 // It use_phony_poll is true, it implies that the poller is declared
 // non-polling and any attempt to schedule a blocking poll will result in a
 // crash failure.
-std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
-                                           bool use_phony_poll);
+std::shared_ptr<PollPoller> MakePollPoller(
+    std::shared_ptr<ThreadPool> thread_pool, bool use_phony_poll);
 
 }  // namespace grpc_event_engine::experimental
 

data/src/core/lib/event_engine/posix_engine/event_poller.h

@@ -19,34 +19,27 @@
 
 #include <string>
 
-#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 
 namespace grpc_event_engine::experimental {
 
-class Scheduler {
- public:
-  virtual void Run(experimental::EventEngine::Closure* closure) = 0;
-  virtual void Run(absl::AnyInvocable<void()>) = 0;
-  virtual ~Scheduler() = default;
-};
-
 class PosixEventPoller;
 
 class EventHandle {
  public:
-  virtual int WrappedFd() = 0;
+  virtual FileDescriptor WrappedFd() = 0;
   // Delete the handle and optionally close the underlying file descriptor if
   // release_fd != nullptr. The on_done closure is scheduled to be invoked
   // after the operation is complete. After this operation, NotifyXXX and SetXXX
   // operations cannot be performed on the handle. In general, this method
   // should only be called after ShutdownHandle and after all existing NotifyXXX
   // closures have run and there is no waiting NotifyXXX closure.
-  virtual void OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
+  virtual void OrphanHandle(PosixEngineClosure* on_done,
+                            FileDescriptor* release_fd,
                             absl::string_view reason) = 0;
   // Shutdown a handle. If there is an attempt to call NotifyXXX operations
   // after Shutdown handle, those closures will be run immediately with the
@@ -84,24 +77,26 @@ class EventHandle {
   virtual ~EventHandle() = default;
 };
 
-class PosixEventPoller : public grpc_event_engine::experimental::Poller,
-                         public Forkable {
+class PosixEventPoller : public grpc_event_engine::experimental::Poller {
  public:
   // Return an opaque handle to perform actions on the provided file descriptor.
-  virtual EventHandle* CreateHandle(int fd, absl::string_view name,
+  virtual EventHandle* CreateHandle(FileDescriptor fd, absl::string_view name,
                                     bool track_err) = 0;
   virtual bool CanTrackErrors() const = 0;
   virtual std::string Name() = 0;
-  // Shuts down and deletes the poller. It is legal to call this function
-  // only when no other poller method is in progress. For instance, it is
-  // not safe to call this method, while a thread is blocked on Work(...).
-  // A graceful way to terminate the poller could be to:
-  // 1. First orphan all created handles.
-  // 2. Send a Kick() to the thread executing Work(...) and wait for the
-  //    thread to return.
-  // 3. Call Shutdown() on the poller.
-  virtual void Shutdown() = 0;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Handles fork in the child process. It performs cleanups like closing file
+  // descriptors, resetting lingering state to make sure the child and parent
+  // processes do not interfere with each other and that the child process
+  // remains in valid state.
+  virtual void HandleForkInChild() = 0;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  virtual void ResetKickState() = 0;
+  EventEnginePosixInterface& posix_interface() { return posix_interface_; }
   ~PosixEventPoller() override = default;
+
+ private:
+  EventEnginePosixInterface posix_interface_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -15,67 +15,55 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
-#include <string>
+#include <utility>
 
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "src/core/config/config_vars.h"
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"
 #include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/util/no_destruct.h"
 
 namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 namespace {
-// TODO(yijiem): this object is thread-unsafe, if we are creating pollers in
-// multiple threads (e.g. multiple event engines) or if we are creating pollers
-// while we are forking then we will run into issues.
-grpc_core::NoDestruct<ObjectGroupForkHandler> g_poller_fork_manager;
-
-class PollerForkCallbackMethods {
- public:
-  static void Prefork() { g_poller_fork_manager->Prefork(); }
-  static void PostforkParent() { g_poller_fork_manager->PostforkParent(); }
-  static void PostforkChild() { g_poller_fork_manager->PostforkChild(); }
-};
 
 bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
   return strategy == "all" || strategy == want;
 }
 }  // namespace
 
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> thread_pool) {
+  // Note that Make*Poller are allowed to return nullptr - e.g. MakeEpoll1Poller
+  // would return nullptr if an epoll poller is requested on unsupported
+  // platform.
   std::shared_ptr<PosixEventPoller> poller;
   auto strings =
       absl::StrSplit(grpc_core::ConfigVars::Get().PollStrategy(), ',');
   for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
        it++) {
     if (PollStrategyMatches(*it, "epoll1")) {
-      poller = MakeEpoll1Poller(scheduler);
+      poller = MakeEpoll1Poller(thread_pool);
     }
     if (poller == nullptr && PollStrategyMatches(*it, "poll")) {
       // If epoll1 fails and if poll strategy matches "poll", use Poll poller
-      poller = MakePollPoller(scheduler, /*use_phony_poll=*/false);
+      poller = MakePollPoller(thread_pool, /*use_phony_poll=*/false);
     } else if (poller == nullptr && PollStrategyMatches(*it, "none")) {
       // If epoll1 fails and if poll strategy matches "none", use phony poll
       // poller.
-      poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
+      poller = MakePollPoller(thread_pool, /*use_phony_poll=*/true);
     }
   }
-  g_poller_fork_manager->RegisterForkable(
-      poller, PollerForkCallbackMethods::Prefork,
-      PollerForkCallbackMethods::PostforkParent,
-      PollerForkCallbackMethods::PostforkChild);
   return poller;
 }
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* /*scheduler*/) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> /*thread_pool*/) {
   return nullptr;
 }
 

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.h

@@ -22,11 +22,12 @@
 namespace grpc_event_engine::experimental {
 
 class PosixEventPoller;
-class Scheduler;
+class ThreadPool;
 
 // Return an instance of an event poller which is tied to the specified
 // scheduler.
-std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler);
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(
+    std::shared_ptr<ThreadPool> thread_pool);
 
 }  // namespace grpc_event_engine::experimental