grpc 1.73.0 → 1.74.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,10 +68,9 @@ 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()),
         poller_(std::move(poller)),
@@ -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;
@@ -183,7 +182,6 @@ class PollEventHandle : public EventHandle {
   }
   ~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,9 +197,8 @@ 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_;
   std::shared_ptr<PollPoller> poller_;
@@ -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();
@@ -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_);
     }
@@ -556,19 +503,6 @@ 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),
       use_phony_poll_(use_phony_poll),
@@ -577,9 +511,8 @@ PollPoller::PollPoller(Scheduler* scheduler, bool use_phony_poll)
       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 +561,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 +576,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,22 +719,43 @@ 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;
 }
 
+#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(Scheduler* scheduler,
                                            bool use_phony_poll) {
-  static bool kPollPollerSupported = InitPollPollerPosix();
+  static bool kPollPollerSupported =
+      grpc_event_engine::experimental::SupportsWakeupFd();
   if (kPollPollerSupported) {
     return std::make_shared<PollPoller>(scheduler, use_phony_poll);
   }
@@ -808,15 +770,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");
 }
@@ -836,10 +793,11 @@ std::shared_ptr<PollPoller> MakePollPoller(Scheduler* /*scheduler*/,
   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

@@ -37,9 +37,8 @@ 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(Scheduler* scheduler, 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,
@@ -47,17 +46,16 @@ class PollPoller : public PosixEventPoller,
   std::string Name() override { return "poll"; }
   void Kick() override;
   Scheduler* GetScheduler() { return scheduler_; }
-  void Shutdown() override;
   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)

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

@@ -22,9 +22,9 @@
 #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 {
 
@@ -39,14 +39,15 @@ 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 +85,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,33 +15,19 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
-#include <string>
 
 #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;
@@ -66,10 +52,6 @@ std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
       poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
     }
   }
-  g_poller_fork_manager->RegisterForkable(
-      poller, PollerForkCallbackMethods::Prefork,
-      PollerForkCallbackMethods::PostforkParent,
-      PollerForkCallbackMethods::PostforkChild);
   return poller;
 }
 

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

@@ -0,0 +1,124 @@
+// Copyright 2025 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/lib/event_engine/posix_engine/file_descriptor_collection.h"
+
+#include "absl/strings/substitute.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/util/crash.h"  // IWYU pragma: keep
+#include "src/core/util/strerror.h"
+
+namespace grpc_event_engine::experimental {
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+namespace {
+
+bool IsForkEnabled() { return grpc_core::IsEventEngineForkEnabled(); }
+
+}  // namespace
+
+FileDescriptorCollection::FileDescriptorCollection(int generation) noexcept
+    : generation_(generation) {}
+
+FileDescriptorCollection::FileDescriptorCollection(
+    FileDescriptorCollection&& other) noexcept
+    : generation_(other.generation_) {
+  grpc_core::MutexLock lock(&other.mu_);
+  file_descriptors_ = std::move(other.file_descriptors_);
+  other.generation_ = -1;
+  other.file_descriptors_.clear();
+}
+
+FileDescriptorCollection& FileDescriptorCollection::operator=(
+    FileDescriptorCollection&& other) noexcept {
+  generation_ = other.generation_;
+  grpc_core::MutexLock self_lock(&mu_);
+  grpc_core::MutexLock other_lock(&other.mu_);
+  file_descriptors_ = std::move(other.file_descriptors_);
+  other.generation_ = -1;
+  other.file_descriptors_.clear();
+  return *this;
+}
+
+FileDescriptor FileDescriptorCollection::Add(int fd) {
+  if (IsForkEnabled()) {
+    grpc_core::MutexLock lock(&mu_);
+    file_descriptors_.emplace(fd);
+  }
+  return FileDescriptor(fd, generation_);
+}
+
+bool FileDescriptorCollection::Remove(const FileDescriptor& fd) {
+  if (!IsForkEnabled()) {
+    return true;
+  }
+  if (fd.generation() == generation_) {
+    grpc_core::MutexLock lock(&mu_);
+    return file_descriptors_.erase(fd.fd()) == 1;
+  }
+  return false;
+}
+
+absl::flat_hash_set<int>
+FileDescriptorCollection::ClearAndReturnRawDescriptors() {
+  if (!IsForkEnabled()) {
+    return {};
+  }
+  grpc_core::MutexLock lock(&mu_);
+  absl::flat_hash_set<int> file_descriptors = std::move(file_descriptors_);
+  // Should not be necessary, but standard is not clear if move would empty
+  // the collection
+  file_descriptors_.clear();
+  return file_descriptors;
+}
+
+#else  // GRPC_ENABLE_FORK_SUPPORT
+
+FileDescriptorCollection::FileDescriptorCollection(
+    int /* generation */) noexcept {}
+
+FileDescriptorCollection::FileDescriptorCollection(
+    FileDescriptorCollection&& other) noexcept = default;
+
+FileDescriptorCollection& FileDescriptorCollection::operator=(
+    FileDescriptorCollection&& other) noexcept = default;
+
+FileDescriptor FileDescriptorCollection::Add(int fd) {
+  return FileDescriptor(fd, 0);
+}
+
+bool FileDescriptorCollection::Remove(const FileDescriptor& /* fd */) {
+  return true;
+}
+
+absl::flat_hash_set<int>
+FileDescriptorCollection::ClearAndReturnRawDescriptors() {
+  return {};
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+std::string PosixError::StrError() const {
+  if (ok()) {
+    return "ok";
+  }
+  if (IsWrongGenerationError()) {
+    return "file descriptor was created pre fork";
+  }
+  int value = *errno_value();
+  return absl::Substitute("$0 ($1)", grpc_core::StrError(value), value);
+}
+
+}  // namespace grpc_event_engine::experimental