grpc 1.71.0 → 1.74.0

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

@@ -17,6 +17,7 @@
 #include <utility>
 
 #include "absl/strings/str_cat.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"  // IWYU pragma: keep
 
@@ -37,59 +38,58 @@ namespace grpc_event_engine::experimental {
 #ifdef GRPC_LINUX_EVENTFD
 
 absl::Status EventFdWakeupFd::Init() {
-  int read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
-  int write_fd = -1;
-  if (read_fd < 0) {
+  auto read_fd = posix_interface_->EventFd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+  if (!read_fd.ok()) {
     return absl::Status(absl::StatusCode::kInternal,
                         absl::StrCat("eventfd: ", grpc_core::StrError(errno)));
   }
-  SetWakeupFds(read_fd, write_fd);
+  SetWakeupFds(read_fd.value(), FileDescriptor::Invalid());
   return absl::OkStatus();
 }
 
 absl::Status EventFdWakeupFd::ConsumeWakeup() {
-  eventfd_t value;
-  int err;
+  PosixError err;
   do {
-    err = eventfd_read(ReadFd(), &value);
-  } while (err < 0 && errno == EINTR);
-  if (err < 0 && errno != EAGAIN) {
-    return absl::Status(
-        absl::StatusCode::kInternal,
-        absl::StrCat("eventfd_read: ", grpc_core::StrError(errno)));
+    err = posix_interface_->EventFdRead(ReadFd());
+  } while (err.IsPosixError(EINTR));
+  if (!err.ok() && !err.IsPosixError(EAGAIN)) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("eventfd_read: ", err.StrError()));
   }
   return absl::OkStatus();
 }
 
 absl::Status EventFdWakeupFd::Wakeup() {
-  int err;
+  PosixError err;
   do {
-    err = eventfd_write(ReadFd(), 1);
-  } while (err < 0 && errno == EINTR);
-  if (err < 0) {
-    return absl::Status(
-        absl::StatusCode::kInternal,
-        absl::StrCat("eventfd_write: ", grpc_core::StrError(errno)));
+    err = posix_interface_->EventFdWrite(ReadFd());
+  } while (err.IsPosixError(EINTR));
+  if (!err.ok()) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("eventfd_write: ", err.StrError()));
   }
   return absl::OkStatus();
 }
 
 EventFdWakeupFd::~EventFdWakeupFd() {
-  if (ReadFd() != 0) {
-    close(ReadFd());
+  if (ReadFd().ready()) {
+    posix_interface_->Close(ReadFd());
   }
 }
 
 bool EventFdWakeupFd::IsSupported() {
-  EventFdWakeupFd event_fd_wakeup_fd;
+  EventEnginePosixInterface posix_interface;
+  EventFdWakeupFd event_fd_wakeup_fd(&posix_interface);
   return event_fd_wakeup_fd.Init().ok();
 }
 
 absl::StatusOr<std::unique_ptr<WakeupFd>>
-EventFdWakeupFd::CreateEventFdWakeupFd() {
+EventFdWakeupFd::CreateEventFdWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   static bool kIsEventFdWakeupFdSupported = EventFdWakeupFd::IsSupported();
   if (kIsEventFdWakeupFdSupported) {
-    auto event_fd_wakeup_fd = std::make_unique<EventFdWakeupFd>();
+    auto event_fd_wakeup_fd =
+        std::make_unique<EventFdWakeupFd>(posix_interface);
     auto status = event_fd_wakeup_fd->Init();
     if (status.ok()) {
       return std::unique_ptr<WakeupFd>(std::move(event_fd_wakeup_fd));
@@ -114,7 +114,8 @@ absl::Status EventFdWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 bool EventFdWakeupFd::IsSupported() { return false; }
 
 absl::StatusOr<std::unique_ptr<WakeupFd>>
-EventFdWakeupFd::CreateEventFdWakeupFd() {
+EventFdWakeupFd::CreateEventFdWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   return absl::NotFoundError("Eventfd wakeup fd is not supported");
 }
 

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

@@ -20,21 +20,25 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine::experimental {
 
 class EventFdWakeupFd : public WakeupFd {
  public:
-  EventFdWakeupFd() : WakeupFd() {}
+  explicit EventFdWakeupFd(EventEnginePosixInterface* posix_interface)
+      : WakeupFd(), posix_interface_(posix_interface) {}
   ~EventFdWakeupFd() override;
   absl::Status ConsumeWakeup() override;
   absl::Status Wakeup() override;
-  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreateEventFdWakeupFd();
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreateEventFdWakeupFd(
+      EventEnginePosixInterface* posix_interface);
   static bool IsSupported();
 
  private:
   absl::Status Init();
+  EventEnginePosixInterface* posix_interface_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "absl/strings/str_cat.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"  // IWYU pragma: keep
 
@@ -36,86 +37,66 @@ namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
-namespace {
-
-absl::Status SetSocketNonBlocking(int fd) {
-  int oldflags = fcntl(fd, F_GETFL, 0);
-  if (oldflags < 0) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
-  }
-
-  oldflags |= O_NONBLOCK;
-
-  if (fcntl(fd, F_SETFL, oldflags) != 0) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
-  }
-
-  return absl::OkStatus();
-}
-}  // namespace
-
 absl::Status PipeWakeupFd::Init() {
-  int pipefd[2];
-  int r = pipe(pipefd);
-  if (0 != r) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("pipe: ", grpc_core::StrError(errno)));
-  }
-  auto status = SetSocketNonBlocking(pipefd[0]);
-  if (!status.ok()) return status;
-  status = SetSocketNonBlocking(pipefd[1]);
-  if (!status.ok()) return status;
-  SetWakeupFds(pipefd[0], pipefd[1]);
+  auto pipe_ends = posix_interface_->Pipe();
+  if (!pipe_ends.ok()) return std::move(pipe_ends).status();
+  SetWakeupFds(pipe_ends->first, pipe_ends->second);
   return absl::OkStatus();
 }
 
 absl::Status PipeWakeupFd::ConsumeWakeup() {
-  char buf[128];
-  ssize_t r;
-
+  std::array<char, 128> buf;
   for (;;) {
-    r = read(ReadFd(), buf, sizeof(buf));
-    if (r > 0) continue;
-    if (r == 0) return absl::OkStatus();
-    switch (errno) {
-      case EAGAIN:
-        return absl::OkStatus();
-      case EINTR:
-        continue;
-      default:
-        return absl::Status(absl::StatusCode::kInternal,
-                            absl::StrCat("read: ", grpc_core::StrError(errno)));
+    auto r = posix_interface_->Read(ReadFd(), absl::Span<char>(buf));
+    if (r.ok()) {
+      if (*r > 0) continue;
+      if (*r == 0) return absl::OkStatus();
+    } else if (r.IsWrongGenerationError()) {
+      return absl::Status(absl::StatusCode::kInternal,
+                          absl::StrCat("read: wrong fd generation"));
+    } else {
+      switch (*r.errno_value()) {
+        case EAGAIN:
+          return absl::OkStatus();
+        case EINTR:
+          continue;
+        default:
+          return absl::Status(
+              absl::StatusCode::kInternal,
+              absl::StrCat("read: ", grpc_core::StrError(errno)));
+      }
     }
   }
 }
 
 absl::Status PipeWakeupFd::Wakeup() {
   char c = 0;
-  while (write(WriteFd(), &c, 1) != 1 && errno == EINTR) {
+  while (posix_interface_->Write(WriteFd(), absl::Span<char>(&c, 1))
+             .IsPosixError(EINTR)) {
   }
   return absl::OkStatus();
 }
 
 PipeWakeupFd::~PipeWakeupFd() {
-  if (ReadFd() != 0) {
-    close(ReadFd());
+  if (ReadFd().ready()) {
+    posix_interface_->Close(ReadFd());
   }
-  if (WriteFd() != 0) {
-    close(WriteFd());
+  if (WriteFd().ready()) {
+    posix_interface_->Close(WriteFd());
   }
 }
 
 bool PipeWakeupFd::IsSupported() {
-  PipeWakeupFd pipe_wakeup_fd;
+  EventEnginePosixInterface posix_interface;
+  PipeWakeupFd pipe_wakeup_fd(&posix_interface);
   return pipe_wakeup_fd.Init().ok();
 }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   static bool kIsPipeWakeupFdSupported = PipeWakeupFd::IsSupported();
   if (kIsPipeWakeupFdSupported) {
-    auto pipe_wakeup_fd = std::make_unique<PipeWakeupFd>();
+    auto pipe_wakeup_fd = std::make_unique<PipeWakeupFd>(posix_interface);
     auto status = pipe_wakeup_fd->Init();
     if (status.ok()) {
       return std::unique_ptr<WakeupFd>(std::move(pipe_wakeup_fd));
@@ -137,7 +118,8 @@ absl::Status PipeWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 
 bool PipeWakeupFd::IsSupported() { return false; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   return absl::NotFoundError("Pipe wakeup fd is not supported");
 }
 

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

@@ -20,21 +20,25 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine::experimental {
 
 class PipeWakeupFd : public WakeupFd {
  public:
-  PipeWakeupFd() : WakeupFd() {}
+  explicit PipeWakeupFd(EventEnginePosixInterface* posix_interface)
+      : WakeupFd(), posix_interface_(posix_interface) {}
   ~PipeWakeupFd() override;
   absl::Status ConsumeWakeup() override;
   absl::Status Wakeup() override;
-  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreatePipeWakeupFd();
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreatePipeWakeupFd(
+      EventEnginePosixInterface* posix_interface);
   static bool IsSupported();
 
  private:
   absl::Status Init();
+  EventEnginePosixInterface* posix_interface_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -45,6 +45,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/status/status.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -54,19 +55,19 @@ class WakeupFd {
   virtual absl::Status Wakeup() = 0;
   virtual ~WakeupFd() = default;
 
-  int ReadFd() { return read_fd_; }
-  int WriteFd() { return write_fd_; }
+  FileDescriptor ReadFd() { return read_fd_; }
+  FileDescriptor WriteFd() { return write_fd_; }
 
  protected:
-  WakeupFd() : read_fd_(0), write_fd_(0) {}
-  void SetWakeupFds(int read_fd, int write_fd) {
+  WakeupFd() {}
+  void SetWakeupFds(FileDescriptor read_fd, FileDescriptor write_fd) {
     read_fd_ = read_fd;
     write_fd_ = write_fd;
   }
 
  private:
-  int read_fd_;
-  int write_fd_;
+  FileDescriptor read_fd_;
+  FileDescriptor write_fd_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -17,6 +17,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
@@ -26,13 +27,16 @@ namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> NotSupported() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> NotSupported(
+    EventEnginePosixInterface* /* unused */) {
   return absl::NotFoundError("Wakeup-fd is not supported on this system");
 }
 
 namespace {
-absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)() =
-    []() -> absl::StatusOr<std::unique_ptr<WakeupFd>> (*)() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)(
+    EventEnginePosixInterface* posix_interface) =
+    []() -> absl::StatusOr<std::unique_ptr<WakeupFd>> (*)(
+             EventEnginePosixInterface* posix_interface) {
 #ifndef GRPC_POSIX_NO_SPECIAL_WAKEUP_FD
   if (EventFdWakeupFd::IsSupported()) {
     return &EventFdWakeupFd::CreateEventFdWakeupFd;
@@ -47,15 +51,17 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)() =
 
 bool SupportsWakeupFd() { return g_wakeup_fd_fn != NotSupported; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
-  return g_wakeup_fd_fn();
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
+  return g_wakeup_fd_fn(posix_interface);
 }
 
 #else  // GRPC_POSIX_WAKEUP_FD
 
 bool SupportsWakeupFd() { return false; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* /* unused */) {
   return absl::NotFoundError("Wakeup-fd is not supported on this system");
 }
 

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

@@ -19,6 +19,7 @@
 #include <memory>
 
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -28,7 +29,8 @@ class WakeupFd;
 bool SupportsWakeupFd();
 
 // Create and return an initialized WakeupFd instance if supported.
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd();
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* posix_interface);
 
 }  // namespace grpc_event_engine::experimental
 

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

@@ -17,6 +17,8 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
+
 #include "absl/strings/string_view.h"
 
 namespace grpc_event_engine::experimental {
@@ -56,27 +58,14 @@ class ExtendedType : public EEClass, public Exports... {
 };
 
 /// A helper method which returns a valid pointer if the extension is
-/// supported by the endpoint.
-template <typename T>
-T* QueryExtension(EventEngine::Endpoint* endpoint) {
-  if (endpoint == nullptr) return nullptr;
-  return static_cast<T*>(endpoint->QueryExtension(T::EndpointExtensionName()));
-}
-
-/// A helper method which returns a valid pointer if the extension is
-/// supported by the listener.
-template <typename T>
-T* QueryExtension(EventEngine::Listener* listener) {
-  if (listener == nullptr) return nullptr;
-  return static_cast<T*>(listener->QueryExtension(T::EndpointExtensionName()));
-}
-
-/// A helper method which returns a valid pointer if the extension is
-/// supported by the EventEngine.
-template <typename T>
-T* QueryExtension(EventEngine* engine) {
-  if (engine == nullptr) return nullptr;
-  return static_cast<T*>(engine->QueryExtension(T::EndpointExtensionName()));
+/// supported by the extending object. Returns nullptr if the extension is not
+/// supported.
+template <typename Extension, class ExtensibleClass>
+std::enable_if_t<std::is_base_of_v<Extensible, ExtensibleClass>, Extension*>
+QueryExtension(ExtensibleClass* extending_obj) {
+  if (extending_obj == nullptr) return nullptr;
+  return static_cast<Extension*>(
+      extending_obj->QueryExtension(Extension::EndpointExtensionName()));
 }
 
 }  // namespace grpc_event_engine::experimental

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

@@ -22,26 +22,28 @@
 namespace grpc_event_engine::experimental {
 
 bool UseEventEngineClient() {
-// TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
-// available for other platforms.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return grpc_core::IsEventEngineClientEnabled();
-#elif defined(GPR_WINDOWS) && !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return grpc_core::IsEventEngineClientEnabled();
-#elif GRPC_IOS_EVENT_ENGINE_CLIENT
-  return true;
-#else
+#if defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return false;
 #endif
+  return grpc_core::IsEventEngineClientEnabled();
 }
 
 bool UseEventEngineListener() {
-// TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
-// available for other platforms.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+#if defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+  return false;
+#endif
   return grpc_core::IsEventEngineListenerEnabled();
+}
+
+bool UsePollsetAlternative() {
+  return UseEventEngineClient() && UseEventEngineListener() &&
+         grpc_core::IsPollsetAlternativeEnabled();
+}
+
+// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+bool EventEngineExperimentDisabledForPython() {
+#ifdef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
+  return true;
 #else
   return false;
 #endif

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

@@ -20,10 +20,24 @@
 
 namespace grpc_event_engine::experimental {
 
+// Returns true if the EventEngine client shim should be used.
+// This is based on the experiment state, and compile-time configurations that
+// may disable the poller in some builds.
 bool UseEventEngineClient();
 
+// Returns true if the EventEngine listener shim should be used.
+// This is based on the experiment state, and compile-time configurations that
+// may disable the poller in some builds.
 bool UseEventEngineListener();
 
+// Returns true if the pollset alternative experiment should be used.
+// This is based on the experiment state, and compile-time configurations that
+// may disable the poller in some builds.
+bool UsePollsetAlternative();
+
+// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+bool EventEngineExperimentDisabledForPython();
+
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_SHIM_H

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

@@ -133,9 +133,10 @@ absl::StatusOr<std::string> ResolvedAddrToUriUnixIfPossible(
     path_string = std::move(*path);
   }
 
-  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
-      std::move(scheme), /*authority=*/"", std::move(path_string),
-      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri =
+      grpc_core::URI::Create(std::move(scheme), /*user_info=*/"",
+                             /*host_port=*/"", std::move(path_string),
+                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -161,9 +162,9 @@ absl::StatusOr<std::string> ResolvedAddrToVsockPathIfPossible(
 absl::StatusOr<std::string> ResolvedAddrToUriVsockIfPossible(
     const EventEngine::ResolvedAddress* resolved_addr) {
   auto path = ResolvedAddrToVsockPathIfPossible(resolved_addr);
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create("vsock", /*authority=*/"", std::move(*path),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      "vsock", /*user_info=*/"", /*host_port=*/"", std::move(*path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -425,9 +426,9 @@ absl::StatusOr<std::string> ResolvedAddressToURI(
   }
   auto path = ResolvedAddressToString(addr);
   GRPC_RETURN_IF_ERROR(path.status());
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create(*scheme, /*authority=*/"", std::move(path.value()),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      *scheme, /*user_info=*/"", /*host_port=*/"", std::move(path.value()),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }

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

@@ -20,21 +20,25 @@
 #include <memory>
 
 #include "absl/functional/any_invocable.h"
-#include "src/core/lib/event_engine/forkable.h"
 
 namespace grpc_event_engine::experimental {
 
 // Interface for all EventEngine ThreadPool implementations
-class ThreadPool : public Forkable {
+class ThreadPool {
  public:
   // Asserts Quiesce was called.
-  ~ThreadPool() override = default;
+  virtual ~ThreadPool() = default;
   // Shut down the pool, and wait for all threads to exit.
   // This method is safe to call from within a ThreadPool thread.
   virtual void Quiesce() = 0;
   // Run must not be called after Quiesce completes
   virtual void Run(absl::AnyInvocable<void()> callback) = 0;
   virtual void Run(EventEngine::Closure* closure) = 0;
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  virtual void PrepareFork() = 0;
+  virtual void PostFork() = 0;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 };
 
 // Creates a default thread pool.

data/src/core/lib/event_engine/thread_pool/thread_pool_factory.cc

@@ -16,30 +16,13 @@
 
 #include <memory>
 
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
-#include "src/core/util/no_destruct.h"
 
 namespace grpc_event_engine::experimental {
 
-namespace {
-grpc_core::NoDestruct<ObjectGroupForkHandler> g_thread_pool_fork_manager;
-
-class ThreadPoolForkCallbackMethods {
- public:
-  static void Prefork() { g_thread_pool_fork_manager->Prefork(); }
-  static void PostforkParent() { g_thread_pool_fork_manager->PostforkParent(); }
-  static void PostforkChild() { g_thread_pool_fork_manager->PostforkChild(); }
-};
-}  // namespace
-
 std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
   auto thread_pool = std::make_shared<WorkStealingThreadPool>(reserve_threads);
-  g_thread_pool_fork_manager->RegisterForkable(
-      thread_pool, ThreadPoolForkCallbackMethods::Prefork,
-      ThreadPoolForkCallbackMethods::PostforkParent,
-      ThreadPoolForkCallbackMethods::PostforkChild);
   return thread_pool;
 }