grpc 1.54.2 → 1.61.0

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

@@ -16,44 +16,65 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+#include <vector>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
-// Register fork handlers with the system, enabling fork support.
-//
-// This provides pthread-based support for fork events. Any objects that
-// implement Forkable can register themselves with this system using
-// ManageForkable, and their respective methods will be called upon fork.
-//
-// This should be called once upon grpc_initialization.
-void RegisterForkHandlers();
+extern grpc_core::TraceFlag grpc_trace_fork;
+
+#define GRPC_FORK_TRACE_LOG(format, ...)                 \
+  do {                                                   \
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fork)) {      \
+      gpr_log(GPR_DEBUG, "[fork] " format, __VA_ARGS__); \
+    }                                                    \
+  } while (0)
 
-// Global callback for pthread_atfork's *prepare argument
-void PrepareFork();
-// Global callback for pthread_atfork's *parent argument
-void PostforkParent();
-// Global callback for pthread_atfork's *child argument
-void PostforkChild();
+#define GRPC_FORK_TRACE_LOG_STRING(format) GRPC_FORK_TRACE_LOG("%s", format)
 
 // An interface to be implemented by EventEngines that wish to have managed fork
-// support.
+// support. The child class must guarantee that those methods are thread-safe.
 class Forkable {
  public:
-  Forkable();
-  virtual ~Forkable();
+  virtual ~Forkable() = default;
   virtual void PrepareFork() = 0;
   virtual void PostforkParent() = 0;
   virtual void PostforkChild() = 0;
 };
 
-// Add Forkables from the set of objects that are supported.
-// Upon fork, each forkable will have its respective fork hooks called on
-// the thread that invoked the fork.
-//
-// Relative ordering of fork callback operations is not guaranteed.
-void ManageForkable(Forkable* forkable);
-// Remove a forkable from the managed set.
-void StopManagingForkable(Forkable* forkable);
+// ObjectGroupForkHandler is meant to be used as a static object in each
+// translation unit where Forkables are created and registered with the
+// ObjectGroupForkHandler. It essentially provides storage for Forkables'
+// instances (as a vector of weak pointers) and helper methods that are meant to
+// be invoked inside the fork handlers (see pthread_atfork(3)). The idea is to
+// have different Forkables (e.g. PosixEventPoller) to store their instances
+// (e.g. a PosixEventPoller object) in a single place separated from other
+// Forkables (a sharded approach). Forkables need to register their pthread fork
+// handlers and manage the relative ordering themselves. This object is
+// thread-unsafe.
+class ObjectGroupForkHandler {
+ public:
+  // Registers a Forkable with this ObjectGroupForkHandler, the Forkable must be
+  // created as a shared pointer.
+  void RegisterForkable(std::shared_ptr<Forkable> forkable,
+                        GRPC_UNUSED void (*prepare)(void),
+                        GRPC_UNUSED void (*parent)(void),
+                        GRPC_UNUSED void (*child)(void));
+
+  void Prefork();
+  void PostforkParent();
+  void PostforkChild();
+
+ private:
+  GRPC_UNUSED bool registered_ = false;
+  bool is_forking_ = false;
+  std::vector<std::weak_ptr<Forkable> > forkables_;
+};
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -0,0 +1,92 @@
+// Copyright 2023 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+#if GRPC_ARES == 1
+
+#include <ares.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A wrapped fd that integrates with the EventEngine poller of the current
+// platform. A GrpcPolledFd knows how to create grpc platform-specific poller
+// handle from "ares_socket_t" sockets, and then sign up for
+// readability/writeability with that poller handle, and do shutdown and
+// destruction.
+class GrpcPolledFd {
+ public:
+  virtual ~GrpcPolledFd() {}
+  // Called when c-ares library is interested and there's no pending callback
+  virtual void RegisterForOnReadableLocked(
+      absl::AnyInvocable<void(absl::Status)> read_closure) = 0;
+  // Called when c-ares library is interested and there's no pending callback
+  virtual void RegisterForOnWriteableLocked(
+      absl::AnyInvocable<void(absl::Status)> write_closure) = 0;
+  // Indicates if there is data left even after just being read from
+  virtual bool IsFdStillReadableLocked() = 0;
+  // Called once and only once. Must cause cancellation of any pending
+  // read/write callbacks. Return true when the Shutdown is confirmed, false
+  // otherwise.
+  //
+  // TODO(yijiem): On Posix, ShutdownLocked will always succeed. On Windows,
+  // ShutdownLocked only succeeds when error is Cancelled. We could remove these
+  // requirements if we changed the FdNode lifetime model so that:
+  //   1. FdNodes and their underlying socket handles remain alive for
+  //      the lifetime of the resolver.
+  //   2. Orphaning the resolver triggers shutdown and subsequent cleanup for
+  //      all FdNodes and socket handles.
+  GRPC_MUST_USE_RESULT virtual bool ShutdownLocked(absl::Status error) = 0;
+  // Get the underlying ares_socket_t that this was created from
+  virtual ares_socket_t GetWrappedAresSocketLocked() = 0;
+  // A unique name, for logging
+  virtual const char* GetName() const = 0;
+};
+
+// A GrpcPolledFdFactory is 1-to-1 with and owned by a GrpcAresRequest. It knows
+// how to create GrpcPolledFd's for the current platform, and the
+// GrpcAresRequest uses it for all of its fd's.
+class GrpcPolledFdFactory {
+ public:
+  virtual ~GrpcPolledFdFactory() {}
+  // Optionally initializes the GrpcPolledFdFactory with a grpc_core::Mutex*
+  // for synchronization between the AresResolver and the GrpcPolledFds. The
+  // Windows implementation overrides this.
+  virtual void Initialize(grpc_core::Mutex* mutex,
+                          EventEngine* event_engine) = 0;
+  // Creates a new wrapped fd for the current platform
+  virtual std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
+      ares_socket_t as) = 0;
+  // Optionally configures the ares channel after creation
+  virtual void ConfigureAresChannelLocked(ares_channel channel) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_ARES == 1
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H

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

@@ -49,10 +49,6 @@ using ConnectionHandleSet = absl::flat_hash_set<
     EventEngine::ConnectionHandle,
     TaskHandleComparator<EventEngine::ConnectionHandle>::Hash>;
 
-using LookupTaskHandleSet = absl::flat_hash_set<
-    EventEngine::DNSResolver::LookupTaskHandle,
-    TaskHandleComparator<EventEngine::DNSResolver::LookupTaskHandle>::Hash>;
-
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -0,0 +1,102 @@
+// Copyright 2023 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_NAMESER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_NAMESER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_HAVE_ARPA_NAMESER
+
+#include <arpa/nameser.h>  // IWYU pragma: keep
+
+#else  // GRPC_HAVE_ARPA_NAMESER
+
+typedef enum __ns_class {
+  ns_c_invalid = 0,  // Cookie.
+  ns_c_in = 1,       // Internet.
+  ns_c_2 = 2,        // unallocated/unsupported.
+  ns_c_chaos = 3,    // MIT Chaos-net.
+  ns_c_hs = 4,       // MIT Hesiod.
+  // Query class values which do not appear in resource records
+  ns_c_none = 254,  // for prereq. sections in update requests
+  ns_c_any = 255,   // Wildcard match.
+  ns_c_max = 65536
+} ns_class;
+
+typedef enum __ns_type {
+  ns_t_invalid = 0,    // Cookie.
+  ns_t_a = 1,          // Host address.
+  ns_t_ns = 2,         // Authoritative server.
+  ns_t_md = 3,         // Mail destination.
+  ns_t_mf = 4,         // Mail forwarder.
+  ns_t_cname = 5,      // Canonical name.
+  ns_t_soa = 6,        // Start of authority zone.
+  ns_t_mb = 7,         // Mailbox domain name.
+  ns_t_mg = 8,         // Mail group member.
+  ns_t_mr = 9,         // Mail rename name.
+  ns_t_null = 10,      // Null resource record.
+  ns_t_wks = 11,       // Well known service.
+  ns_t_ptr = 12,       // Domain name pointer.
+  ns_t_hinfo = 13,     // Host information.
+  ns_t_minfo = 14,     // Mailbox information.
+  ns_t_mx = 15,        // Mail routing information.
+  ns_t_txt = 16,       // Text strings.
+  ns_t_rp = 17,        // Responsible person.
+  ns_t_afsdb = 18,     // AFS cell database.
+  ns_t_x25 = 19,       // X_25 calling address.
+  ns_t_isdn = 20,      // ISDN calling address.
+  ns_t_rt = 21,        // Router.
+  ns_t_nsap = 22,      // NSAP address.
+  ns_t_nsap_ptr = 23,  // Reverse NSAP lookup (deprecated).
+  ns_t_sig = 24,       // Security signature.
+  ns_t_key = 25,       // Security key.
+  ns_t_px = 26,        // X.400 mail mapping.
+  ns_t_gpos = 27,      // Geographical position (withdrawn).
+  ns_t_aaaa = 28,      // Ip6 Address.
+  ns_t_loc = 29,       // Location Information.
+  ns_t_nxt = 30,       // Next domain (security).
+  ns_t_eid = 31,       // Endpoint identifier.
+  ns_t_nimloc = 32,    // Nimrod Locator.
+  ns_t_srv = 33,       // Server Selection.
+  ns_t_atma = 34,      // ATM Address
+  ns_t_naptr = 35,     // Naming Authority PoinTeR
+  ns_t_kx = 36,        // Key Exchange
+  ns_t_cert = 37,      // Certification record
+  ns_t_a6 = 38,        // IPv6 address (deprecates AAAA)
+  ns_t_dname = 39,     // Non-terminal DNAME (for IPv6)
+  ns_t_sink = 40,      // Kitchen sink (experimentatl)
+  ns_t_opt = 41,       // EDNS0 option (meta-RR)
+  ns_t_apl = 42,       // Address prefix list (RFC3123)
+  ns_t_ds = 43,        // Delegation Signer (RFC4034)
+  ns_t_sshfp = 44,     // SSH Key Fingerprint (RFC4255)
+  ns_t_rrsig = 46,     // Resource Record Signature (RFC4034)
+  ns_t_nsec = 47,      // Next Secure (RFC4034)
+  ns_t_dnskey = 48,    // DNS Public Key (RFC4034)
+  ns_t_tkey = 249,     // Transaction key
+  ns_t_tsig = 250,     // Transaction signature.
+  ns_t_ixfr = 251,     // Incremental zone transfer.
+  ns_t_axfr = 252,     // Transfer zone of authority.
+  ns_t_mailb = 253,    // Transfer mailbox records.
+  ns_t_maila = 254,    // Transfer mail agent records.
+  ns_t_any = 255,      // Wildcard match.
+  ns_t_zxfr = 256,     // BIND-specific, nonstandard.
+  ns_t_max = 65536
+} ns_type;
+
+#endif  // GRPC_HAVE_ARPA_NAMESER
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_NAMESER_H

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

@@ -43,12 +43,12 @@ class Poller {
   //  * Poller::WorkResult::kKicked if it was Kicked. A poller that was Kicked
   //  may still process some events and if so, it may have run the
   //  schedule_poll_again callback function synchronously. When the poller
-  //  returns Poller::WorkResult::kKicked tts upto the user to determine
+  //  returns Poller::WorkResult::kKicked it's up to the user to determine
   //  if the schedule_poll_again callback has run or not.
   //  * Poller::WorkResult::kDeadlineExceeded if timeout occurred. The
   //  schedule_poll_again callback is not run in this case.
   //  * Poller::WorkResult::kOk, otherwise indicating that the
-  //  schedule_poll_again callback function was run synchonously before some
+  //  schedule_poll_again callback function was run synchronously before some
   //  events were processed.
   virtual WorkResult Work(EventEngine::Duration timeout,
                           absl::FunctionRef<void()> schedule_poll_again) = 0;

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

@@ -37,6 +37,10 @@ class PosixEndpointWithFdSupport : public EventEngine::Endpoint {
   /// Returns the file descriptor associated with the posix endpoint.
   virtual int GetWrappedFd() = 0;
 
+  /// Returns if the Endpoint supports tracking events from errmsg queues on
+  /// posix systems.
+  virtual bool CanTrackErrors() = 0;
+
   /// Shutdown the endpoint. This function call should trigger execution of
   /// any pending endpoint Read/Write callbacks with appropriate error
   /// absl::Status. After this function call any subsequent endpoint

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

@@ -18,7 +18,6 @@
 #include <stdint.h>
 
 #include <atomic>
-#include <initializer_list>
 #include <memory>
 
 #include "absl/status/status.h"
@@ -255,10 +254,6 @@ void ResetEventManagerOnFork() {
     poller->Close();
   }
   gpr_mu_unlock(&fork_fd_list_mu);
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_destroy(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
-  }
   InitEpoll1PollerLinux();
 }
 
@@ -273,8 +268,10 @@ bool InitEpoll1PollerLinux() {
     return false;
   }
   if (grpc_core::Fork::Enabled()) {
-    gpr_mu_init(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(ResetEventManagerOnFork);
+    if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+            ResetEventManagerOnFork)) {
+      gpr_mu_init(&fork_fd_list_mu);
+    }
   }
   close(fd);
   return true;
@@ -349,7 +346,7 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
       }
     }
     write_closure_->SetShutdown(why);
-    write_closure_->SetShutdown(why);
+    error_closure_->SetShutdown(why);
   }
 }
 
@@ -370,10 +367,7 @@ Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
   ForkPollerListAddPoller(this);
 }
 
-void Epoll1Poller::Shutdown() {
-  ForkPollerListRemovePoller(this);
-  delete this;
-}
+void Epoll1Poller::Shutdown() { ForkPollerListRemovePoller(this); }
 
 void Epoll1Poller::Close() {
   grpc_core::MutexLock lock(&mu_);
@@ -567,10 +561,10 @@ void Epoll1Poller::Kick() {
   GPR_ASSERT(wakeup_fd_->Wakeup().ok());
 }
 
-Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler) {
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler) {
   static bool kEpoll1PollerSupported = InitEpoll1PollerLinux();
   if (kEpoll1PollerSupported) {
-    return new Epoll1Poller(scheduler);
+    return std::make_shared<Epoll1Poller>(scheduler);
   }
   return nullptr;
 }
@@ -627,7 +621,9 @@ void Epoll1Poller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-Epoll1Poller* MakeEpoll1Poller(Scheduler* /*scheduler*/) { return nullptr; }
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* /*scheduler*/) {
+  return nullptr;
+}
 
 void Epoll1Poller::PrepareFork() {}
 

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

@@ -27,7 +27,6 @@
 
 #include <grpc/event_engine/event_engine.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/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
@@ -47,7 +46,7 @@ namespace experimental {
 class Epoll1EventHandle;
 
 // Definition of epoll1 based poller.
-class Epoll1Poller : public PosixEventPoller, public Forkable {
+class Epoll1Poller : public PosixEventPoller {
  public:
   explicit Epoll1Poller(Scheduler* scheduler);
   EventHandle* CreateHandle(int fd, absl::string_view name,
@@ -131,7 +130,7 @@ class Epoll1Poller : public PosixEventPoller, public Forkable {
 
 // Return an instance of a epoll1 based poller tied to the specified event
 // engine.
-Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler);
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -19,7 +19,6 @@
 #include <stdint.h>
 
 #include <atomic>
-#include <initializer_list>
 #include <list>
 #include <memory>
 #include <utility>
@@ -74,13 +73,13 @@ using Events = absl::InlinedVector<PollEventHandle*, 5>;
 
 class PollEventHandle : public EventHandle {
  public:
-  PollEventHandle(int fd, PollPoller* poller)
+  PollEventHandle(int fd, std::shared_ptr<PollPoller> poller)
       : fd_(fd),
         pending_actions_(0),
         fork_fd_list_(this),
         poller_handles_list_(this),
-        poller_(poller),
         scheduler_(poller->GetScheduler()),
+        poller_(std::move(poller)),
         is_orphaned_(false),
         is_shutdown_(false),
         closed_(false),
@@ -93,11 +92,10 @@ class PollEventHandle : public EventHandle {
         read_closure_(reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)),
         write_closure_(
             reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
-    poller_->Ref();
     grpc_core::MutexLock lock(&poller_->mu_);
     poller_->PollerHandlesListAddHandle(this);
   }
-  PollPoller* Poller() override { return poller_; }
+  PollPoller* Poller() override { return poller_.get(); }
   bool SetPendingActions(bool pending_read, bool pending_write) {
     pending_actions_ |= pending_read;
     if (pending_write) {
@@ -185,7 +183,6 @@ class PollEventHandle : public EventHandle {
       if (on_done_ != nullptr) {
         scheduler_->Run(on_done_);
       }
-      poller_->Unref();
       delete this;
     }
   }
@@ -211,8 +208,8 @@ class PollEventHandle : public EventHandle {
   int pending_actions_;
   PollPoller::HandlesList fork_fd_list_;
   PollPoller::HandlesList poller_handles_list_;
-  PollPoller* poller_;
   Scheduler* scheduler_;
+  std::shared_ptr<PollPoller> poller_;
   bool is_orphaned_;
   bool is_shutdown_;
   bool closed_;
@@ -316,13 +313,9 @@ void ResetEventManagerOnFork() {
   while (!fork_poller_list.empty()) {
     PollPoller* poller = fork_poller_list.front();
     fork_poller_list.pop_front();
-    delete poller;
+    poller->Close();
   }
   gpr_mu_unlock(&fork_fd_list_mu);
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_destroy(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
-  }
   InitPollPollerPosix();
 }
 
@@ -333,8 +326,10 @@ bool InitPollPollerPosix() {
     return false;
   }
   if (grpc_core::Fork::Enabled()) {
-    gpr_mu_init(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(ResetEventManagerOnFork);
+    if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+            ResetEventManagerOnFork)) {
+      gpr_mu_init(&fork_fd_list_mu);
+    }
   }
   return true;
 }
@@ -346,7 +341,7 @@ EventHandle* PollPoller::CreateHandle(int fd, absl::string_view /*name*/,
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
   GPR_DEBUG_ASSERT(track_err == false);
-  PollEventHandle* handle = new PollEventHandle(fd, this);
+  PollEventHandle* handle = new PollEventHandle(fd, shared_from_this());
   ForkFdListAddHandle(handle);
   // We need to send a kick to the thread executing Work(..) so that it can
   // add this new Fd into the list of Fds to poll.
@@ -568,6 +563,9 @@ bool PollEventHandle::EndPollLocked(bool got_read, bool got_write) {
 
 void PollPoller::KickExternal(bool ext) {
   grpc_core::MutexLock lock(&mu_);
+  if (closed_) {
+    return;
+  }
   if (was_kicked_) {
     if (ext) {
       was_kicked_ext_ = true;
@@ -612,7 +610,8 @@ PollPoller::PollPoller(Scheduler* scheduler)
       was_kicked_(false),
       was_kicked_ext_(false),
       num_poll_handles_(0),
-      poll_handles_list_head_(nullptr) {
+      poll_handles_list_head_(nullptr),
+      closed_(false) {
   wakeup_fd_ = *CreateWakeupFd();
   GPR_ASSERT(wakeup_fd_ != nullptr);
   ForkPollerListAddPoller(this);
@@ -624,7 +623,8 @@ PollPoller::PollPoller(Scheduler* scheduler, bool use_phony_poll)
       was_kicked_(false),
       was_kicked_ext_(false),
       num_poll_handles_(0),
-      poll_handles_list_head_(nullptr) {
+      poll_handles_list_head_(nullptr),
+      closed_(false) {
   wakeup_fd_ = *CreateWakeupFd();
   GPR_ASSERT(wakeup_fd_ != nullptr);
   ForkPollerListAddPoller(this);
@@ -826,15 +826,24 @@ Poller::WorkResult PollPoller::Work(
   return was_kicked_ext ? Poller::WorkResult::kKicked : Poller::WorkResult::kOk;
 }
 
-void PollPoller::Shutdown() {
-  ForkPollerListRemovePoller(this);
-  Unref();
+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;
 }
 
-PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll) {
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
+                                           bool use_phony_poll) {
   static bool kPollPollerSupported = InitPollPollerPosix();
   if (kPollPollerSupported) {
-    return new PollPoller(scheduler, use_phony_poll);
+    return std::make_shared<PollPoller>(scheduler, use_phony_poll);
   }
   return nullptr;
 }
@@ -872,11 +881,17 @@ void PollPoller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-PollPoller* MakePollPoller(Scheduler* /*scheduler*/,
-                           bool /* use_phony_poll */) {
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* /*scheduler*/,
+                                           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"); }
+
+void PollPoller::Close() { grpc_core::Crash("unimplemented"); }
+
 void PollPoller::KickExternal(bool /*ext*/) {
   grpc_core::Crash("unimplemented");
 }

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

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
 #include <memory>
 #include <string>
 
@@ -38,7 +37,8 @@ namespace experimental {
 class PollEventHandle;
 
 // Definition of poll based poller.
-class PollPoller : public PosixEventPoller {
+class PollPoller : public PosixEventPoller,
+                   public std::enable_shared_from_this<PollPoller> {
  public:
   explicit PollPoller(Scheduler* scheduler);
   PollPoller(Scheduler* scheduler, bool use_phony_poll);
@@ -54,13 +54,14 @@ class PollPoller : public PosixEventPoller {
   bool CanTrackErrors() const override { return false; }
   ~PollPoller() override;
 
+  // Forkable
+  void PrepareFork() override;
+  void PostforkParent() override;
+  void PostforkChild() override;
+
+  void Close();
+
  private:
-  void Ref() { ref_count_.fetch_add(1, std::memory_order_relaxed); }
-  void Unref() {
-    if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-      delete this;
-    }
-  }
   void KickExternal(bool ext);
   void PollerHandlesListAddHandle(PollEventHandle* handle)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -76,20 +77,21 @@ class PollPoller : public PosixEventPoller {
   };
   grpc_core::Mutex mu_;
   Scheduler* scheduler_;
-  std::atomic<int> ref_count_{1};
   bool use_phony_poll_;
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
   bool was_kicked_ext_ ABSL_GUARDED_BY(mu_);
   int num_poll_handles_ ABSL_GUARDED_BY(mu_);
   PollEventHandle* poll_handles_list_head_ ABSL_GUARDED_BY(mu_) = nullptr;
   std::unique_ptr<WakeupFd> wakeup_fd_;
+  bool closed_ ABSL_GUARDED_BY(mu_);
 };
 
 // Return an instance of a poll based poller tied to the specified scheduler.
 // 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.
-PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll);
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
+                                           bool use_phony_poll);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -24,6 +24,7 @@
 
 #include <grpc/event_engine/event_engine.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"
 
@@ -86,7 +87,8 @@ class EventHandle {
   virtual ~EventHandle() = default;
 };
 
-class PosixEventPoller : public grpc_event_engine::experimental::Poller {
+class PosixEventPoller : public grpc_event_engine::experimental::Poller,
+                         public Forkable {
  public:
   // Return an opaque handle to perform actions on the provided file descriptor.
   virtual EventHandle* CreateHandle(int fd, absl::string_view name,