grpc 1.73.0 → 1.75.0

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

@@ -17,7 +17,6 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 #include <limits.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 #include <cstdint>
@@ -29,16 +28,13 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_replace.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/status_helper.h"
 
-#define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
-
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 #include <errno.h>       // IWYU pragma: keep
 #include <ifaddrs.h>     // IWYU pragma: keep
@@ -59,36 +55,6 @@ using ListenerSocket = ListenerSocketsContainer::ListenerSocket;
 
 #ifdef GRPC_HAVE_IFADDRS
 
-// Bind to "::" to get a port number not used by any address.
-absl::StatusOr<int> GetUnusedPort() {
-  ResolvedAddress wild = ResolvedAddressMakeWild6(0);
-  PosixSocketWrapper::DSMode dsmode;
-  auto sock = PosixSocketWrapper::CreateDualStackSocket(nullptr, wild,
-                                                        SOCK_STREAM, 0, dsmode);
-  GRPC_RETURN_IF_ERROR(sock.status());
-  if (dsmode == PosixSocketWrapper::DSMode::DSMODE_IPV4) {
-    wild = ResolvedAddressMakeWild4(0);
-  }
-  if (bind(sock->Fd(), wild.address(), wild.size()) != 0) {
-    close(sock->Fd());
-    return absl::FailedPreconditionError(
-        absl::StrCat("bind(GetUnusedPort): ", std::strerror(errno)));
-  }
-  socklen_t len = wild.size();
-  if (getsockname(sock->Fd(), const_cast<sockaddr*>(wild.address()), &len) !=
-      0) {
-    close(sock->Fd());
-    return absl::FailedPreconditionError(
-        absl::StrCat("getsockname(GetUnusedPort): ", std::strerror(errno)));
-  }
-  close(sock->Fd());
-  int port = ResolvedAddressGetPort(wild);
-  if (port <= 0) {
-    return absl::FailedPreconditionError("Bad port");
-  }
-  return port;
-}
-
 bool SystemHasIfAddrs() { return true; }
 
 #else  // GRPC_HAVE_IFADDRS
@@ -97,108 +63,28 @@ bool SystemHasIfAddrs() { return false; }
 
 #endif  // GRPC_HAVE_IFADDRS
 
-// get max listen queue size on linux
-int InitMaxAcceptQueueSize() {
-  int n = SOMAXCONN;
-  char buf[64];
-  FILE* fp = fopen("/proc/sys/net/core/somaxconn", "r");
-  int max_accept_queue_size;
-  if (fp == nullptr) {
-    // 2.4 kernel.
-    return SOMAXCONN;
-  }
-  if (fgets(buf, sizeof buf, fp)) {
-    char* end;
-    long i = strtol(buf, &end, 10);
-    if (i > 0 && i <= INT_MAX && end && *end == '\n') {
-      n = static_cast<int>(i);
-    }
-  }
-  fclose(fp);
-  max_accept_queue_size = n;
-
-  if (max_accept_queue_size < MIN_SAFE_ACCEPT_QUEUE_SIZE) {
-    LOG(INFO) << "Suspiciously small accept queue (" << max_accept_queue_size
-              << ") will probably lead to connection drops";
-  }
-  return max_accept_queue_size;
-}
-
-int GetMaxAcceptQueueSize() {
-  static const int kMaxAcceptQueueSize = InitMaxAcceptQueueSize();
-  return kMaxAcceptQueueSize;
-}
-
 // Prepare a recently-created socket for listening.
-absl::Status PrepareSocket(const PosixTcpOptions& options,
+absl::Status PrepareSocket(EventEnginePosixInterface* posix_interface,
+                           const PosixTcpOptions& options,
                            ListenerSocket& socket) {
-  ResolvedAddress sockname_temp;
-  int fd = socket.sock.Fd();
-  CHECK_GE(fd, 0);
+  FileDescriptor fd = socket.sock;
+  CHECK(fd.ready());
   bool close_fd = true;
-  socket.zero_copy_enabled = false;
   socket.port = 0;
-  auto sock_cleanup = absl::MakeCleanup([&close_fd, fd]() -> void {
-    if (close_fd && fd >= 0) {
-      close(fd);
-    }
-  });
-  if (PosixSocketWrapper::IsSocketReusePortSupported() &&
-      options.allow_reuse_port && socket.addr.address()->sa_family != AF_UNIX &&
-      !ResolvedAddressIsVSock(socket.addr)) {
-    GRPC_RETURN_IF_ERROR(socket.sock.SetSocketReusePort(1));
-  }
-
-#ifdef GRPC_LINUX_ERRQUEUE
-  if (!socket.sock.SetSocketZeroCopy().ok()) {
-    // it's not fatal, so just log it.
-    VLOG(2) << "Node does not support SO_ZEROCOPY, continuing.";
-  } else {
-    socket.zero_copy_enabled = true;
-  }
-#endif
-
-  GRPC_RETURN_IF_ERROR(socket.sock.SetSocketNonBlocking(1));
-  GRPC_RETURN_IF_ERROR(socket.sock.SetSocketCloexec(1));
-
-  if (socket.addr.address()->sa_family != AF_UNIX &&
-      !ResolvedAddressIsVSock(socket.addr)) {
-    GRPC_RETURN_IF_ERROR(socket.sock.SetSocketLowLatency(1));
-    GRPC_RETURN_IF_ERROR(socket.sock.SetSocketReuseAddr(1));
-    GRPC_RETURN_IF_ERROR(socket.sock.SetSocketDscp(options.dscp));
-    socket.sock.TrySetSocketTcpUserTimeout(options, false);
-  }
-  GRPC_RETURN_IF_ERROR(socket.sock.SetSocketNoSigpipeIfPossible());
-  GRPC_RETURN_IF_ERROR(socket.sock.ApplySocketMutatorInOptions(
-      GRPC_FD_SERVER_LISTENER_USAGE, options));
-
-  if (bind(fd, socket.addr.address(), socket.addr.size()) < 0) {
-    auto sockaddr_str = ResolvedAddressToString(socket.addr);
-    if (!sockaddr_str.ok()) {
-      LOG(ERROR) << "Could not convert sockaddr to string: "
-                 << sockaddr_str.status();
-      sockaddr_str = "<unparsable>";
-    }
-    sockaddr_str = absl::StrReplaceAll(*sockaddr_str, {{"\0", "@"}});
-    return absl::FailedPreconditionError(
-        absl::StrCat("Error in bind for address '", *sockaddr_str,
-                     "': ", std::strerror(errno)));
-  }
-
-  if (listen(fd, GetMaxAcceptQueueSize()) < 0) {
-    return absl::FailedPreconditionError(
-        absl::StrCat("Error in listen: ", std::strerror(errno)));
+  auto sock_cleanup =
+      absl::MakeCleanup([&close_fd, fd, posix_interface]() -> void {
+        if (close_fd && fd.ready()) {
+          posix_interface->Close(fd);
+        }
+      });
+  auto listen_address =
+      posix_interface->PrepareListenerSocket(socket.sock, options, socket.addr);
+  if (!listen_address.ok()) {
+    return std::move(listen_address).status();
   }
   socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-
-  if (getsockname(fd, const_cast<sockaddr*>(sockname_temp.address()), &len) <
-      0) {
-    return absl::FailedPreconditionError(
-        absl::StrCat("Error in getsockname: ", std::strerror(errno)));
-  }
-
   socket.port =
-      ResolvedAddressGetPort(ResolvedAddress(sockname_temp.address(), len));
+      ResolvedAddressGetPort(ResolvedAddress(listen_address->address(), len));
   // No errors. Set close_fd to false to ensure the socket is not closed.
   close_fd = false;
   return absl::OkStatus();
@@ -207,22 +93,23 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
 }  // namespace
 
 absl::StatusOr<ListenerSocket> CreateAndPrepareListenerSocket(
-    const PosixTcpOptions& options, const ResolvedAddress& addr) {
+    EventEnginePosixInterface* posix_interface, const PosixTcpOptions& options,
+    const ResolvedAddress& addr) {
   ResolvedAddress addr4_copy;
   ListenerSocket socket;
-  auto result = PosixSocketWrapper::CreateDualStackSocket(
+  auto result = posix_interface->CreateDualStackSocket(
       nullptr, addr, SOCK_STREAM, 0, socket.dsmode);
   if (!result.ok()) {
     return result.status();
   }
   socket.sock = *result;
-  if (socket.dsmode == PosixSocketWrapper::DSMODE_IPV4 &&
+  if (socket.dsmode == EventEnginePosixInterface::DSMODE_IPV4 &&
       ResolvedAddressIsV4Mapped(addr, &addr4_copy)) {
     socket.addr = addr4_copy;
   } else {
     socket.addr = addr;
   }
-  GRPC_RETURN_IF_ERROR(PrepareSocket(options, socket));
+  GRPC_RETURN_IF_ERROR(PrepareSocket(posix_interface, options, socket));
   CHECK_GT(socket.port, 0);
   return socket;
 }
@@ -249,6 +136,7 @@ bool IsSockAddrLinkLocal(const EventEngine::ResolvedAddress* resolved_addr) {
 }
 
 absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
+    EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port) {
 #ifdef GRPC_HAVE_IFADDRS
@@ -258,7 +146,7 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
   bool no_local_addresses = true;
   int assigned_port = 0;
   if (requested_port == 0) {
-    auto result = GetUnusedPort();
+    auto result = posix_interface->GetUnusedPort();
     GRPC_RETURN_IF_ERROR(result.status());
     requested_port = *result;
     VLOG(2) << "Picked unused port " << requested_port;
@@ -307,7 +195,8 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
               << ifa_name;
       continue;
     }
-    auto result = CreateAndPrepareListenerSocket(options, addr);
+    auto result =
+        CreateAndPrepareListenerSocket(posix_interface, options, addr);
     if (!result.ok()) {
       op_status = absl::FailedPreconditionError(
           absl::StrCat("Failed to add listener: ", addr_str,
@@ -335,6 +224,7 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
 }
 
 absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
+    EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port) {
   ResolvedAddress wild4 = ResolvedAddressMakeWild4(requested_port);
@@ -344,24 +234,24 @@ absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
   int assigned_port = 0;
 
   if (SystemHasIfAddrs() && options.expand_wildcard_addrs) {
-    return ListenerContainerAddAllLocalAddresses(listener_sockets, options,
-                                                 requested_port);
+    return ListenerContainerAddAllLocalAddresses(
+        posix_interface, listener_sockets, options, requested_port);
   }
 
   // Try listening on IPv6 first.
-  v6_sock = CreateAndPrepareListenerSocket(options, wild6);
+  v6_sock = CreateAndPrepareListenerSocket(posix_interface, options, wild6);
   if (v6_sock.ok()) {
     listener_sockets.Append(*v6_sock);
     requested_port = v6_sock->port;
     assigned_port = v6_sock->port;
-    if (v6_sock->dsmode == PosixSocketWrapper::DSMODE_DUALSTACK ||
-        v6_sock->dsmode == PosixSocketWrapper::DSMODE_IPV4) {
+    if (v6_sock->dsmode == EventEnginePosixInterface::DSMODE_DUALSTACK ||
+        v6_sock->dsmode == EventEnginePosixInterface::DSMODE_IPV4) {
       return v6_sock->port;
     }
   }
   // If we got a v6-only socket or nothing, try adding 0.0.0.0.
   ResolvedAddressSetPort(wild4, requested_port);
-  v4_sock = CreateAndPrepareListenerSocket(options, wild4);
+  v4_sock = CreateAndPrepareListenerSocket(posix_interface, options, wild4);
   if (v4_sock.ok()) {
     assigned_port = v4_sock->port;
     listener_sockets.Append(*v4_sock);

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

@@ -18,6 +18,7 @@
 #include <grpc/support/port_platform.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/tcp_socket_utils.h"
 
 namespace grpc_event_engine::experimental {
@@ -30,15 +31,13 @@ class ListenerSocketsContainer {
  public:
   struct ListenerSocket {
     // Listener socket fd
-    PosixSocketWrapper sock;
+    FileDescriptor sock;
     // Assigned/chosen listening port
     int port;
-    // Socket configuration
-    bool zero_copy_enabled;
     // Address at which the socket is listening for connections
     grpc_event_engine::experimental::EventEngine::ResolvedAddress addr;
     // Dual stack mode.
-    PosixSocketWrapper::DSMode dsmode;
+    EventEnginePosixInterface::DSMode dsmode;
   };
   // Adds a socket to the internal db of sockets associated with a listener.
   virtual void Append(ListenerSocket socket) = 0;
@@ -59,7 +58,7 @@ class ListenerSocketsContainer {
 // socket fd and its dsmode. If unsuccessful, it returns a Not-OK status.
 absl::StatusOr<ListenerSocketsContainer::ListenerSocket>
 CreateAndPrepareListenerSocket(
-    const PosixTcpOptions& options,
+    EventEnginePosixInterface* posix_interface, const PosixTcpOptions& options,
     const grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr);
 
 // Instead of creating and adding a socket bound to specific address, this
@@ -69,6 +68,7 @@ CreateAndPrepareListenerSocket(
 // returns the port at which the created socket listens for incoming
 // connections.
 absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
+    EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port);
 
@@ -79,6 +79,7 @@ absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
 // every socket. If set to 0, a random port will be used for every socket.
 // The function returns the chosen port number for all created sockets.
 absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
+    EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port);
 

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

@@ -0,0 +1,211 @@
+// 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_INTERFACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_INTERFACE_H
+
+#include <grpc/event_engine/event_engine.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "src/core/lib/event_engine/posix_engine/file_descriptor_collection.h"
+#include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+
+namespace grpc_event_engine::experimental {
+
+class EventEnginePosixInterface {
+ public:
+  // An enum to keep track of IPv4/IPv6 socket modes.
+  //
+  // Currently, this information is only used when a socket is first created,
+  // but in the future we may wish to store it alongside the fd.  This would let
+  // calls like sendto() know which family to use without asking the kernel
+  // first.
+  enum DSMode {
+    // Uninitialized, or a non-IP socket.
+    DSMODE_NONE,
+    // AF_INET only.
+    DSMODE_IPV4,
+    // AF_INET6 only, because IPV6_V6ONLY could not be cleared.
+    DSMODE_IPV6,
+    // AF_INET6, which also supports ::ffff-mapped IPv4 addresses.
+    DSMODE_DUALSTACK
+  };
+
+  EventEnginePosixInterface() : descriptors_(1) {}
+  EventEnginePosixInterface(const EventEnginePosixInterface& other) = delete;
+  EventEnginePosixInterface(EventEnginePosixInterface&& other) = delete;
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // ---- Fork generation management ----
+  // Advances the internal generation counter, potentially invalidating old
+  // descriptors.
+  void AdvanceGeneration();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  int generation() const { return descriptors_.generation(); }
+
+  // ---- File Descriptor Management ----
+  // Adopts an existing POSIX file descriptor, returning a managed
+  // FileDescriptor object.
+  FileDescriptor Adopt(int fd);
+  void Close(const FileDescriptor& fd);
+  // Retrieves the raw POSIX file descriptor, if valid for the current
+  // generation.
+  PosixErrorOr<int> GetFd(const FileDescriptor& fd);
+
+  // ---- Socket/FD Creation Factories ----
+  struct PosixSocketCreateResult {
+    FileDescriptor sock;
+    EventEngine::ResolvedAddress mapped_target_addr;
+  };
+  // Return a PosixSocketCreateResult which manages a configured, unbound,
+  // unconnected TCP client fd.
+  //  options: may contain custom tcp settings for the fd.
+  //  target_addr: the destination address.
+  //
+  // Returns: Not-OK status on error. Otherwise it returns a
+  // PosixSocketWrapper::PosixSocketCreateResult type which includes a sock
+  // of type PosixSocketWrapper and a mapped_target_addr which is
+  // target_addr mapped to an address appropriate to the type of socket FD
+  // created. For example, if target_addr is IPv4 and dual stack sockets are
+  // available, mapped_target_addr will be an IPv4-mapped IPv6 address.
+  //
+  absl::StatusOr<PosixSocketCreateResult> CreateAndPrepareTcpClientSocket(
+      const PosixTcpOptions& options,
+      const EventEngine::ResolvedAddress& target_addr);
+  // Creates a new socket for connecting to (or listening on) an address.
+  //
+  // If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,
+  // and addr is within ::ffff:0.0.0.0/96, then it automatically falls back
+  // to an IPv4 socket.
+  //
+  // If addr is AF_INET, AF_UNIX, or anything else, then this is similar to
+  // calling socket() directly.
+  //
+  // Returns a FileDescriptor on success, otherwise returns a not-OK
+  // absl::Status
+  //
+  // The dsmode output indicates which address family was actually created.
+  absl::StatusOr<FileDescriptor> CreateDualStackSocket(
+      std::function<int(int, int, int)> socket_factory,
+      const experimental::EventEngine::ResolvedAddress& addr, int type,
+      int protocol, DSMode& dsmode);
+  PosixErrorOr<FileDescriptor> EpollCreateAndCloexec();
+  PosixErrorOr<FileDescriptor> EventFd(int initval, int flags);
+  absl::StatusOr<std::pair<FileDescriptor, FileDescriptor>> Pipe();
+  PosixErrorOr<FileDescriptor> Socket(int domain, int type, int protocol);
+
+  // ---- Socket Operations (General POSIX) ----
+  PosixErrorOr<FileDescriptor> Accept(const FileDescriptor& sockfd,
+                                      struct sockaddr* addr,
+                                      socklen_t* addrlen);
+  PosixErrorOr<FileDescriptor> Accept4(const FileDescriptor& sockfd,
+                                       EventEngine::ResolvedAddress& addr,
+                                       int nonblock, int cloexec);
+  PosixError Connect(const FileDescriptor& sockfd, const struct sockaddr* addr,
+                     socklen_t addrlen);
+  PosixErrorOr<int64_t> Read(const FileDescriptor& fd, absl::Span<char> buffer);
+  PosixErrorOr<int64_t> RecvMsg(const FileDescriptor& fd,
+                                struct msghdr* message, int flags);
+  PosixErrorOr<int64_t> SendMsg(const FileDescriptor& fd,
+                                const struct msghdr* message, int flags);
+  PosixError Shutdown(const FileDescriptor& fd, int how);
+  PosixErrorOr<int64_t> Write(const FileDescriptor& fd,
+                              absl::Span<char> buffer);
+
+  // ---- Socket Configuration & Querying ----
+  // Applies socket mutator options defined within PosixTcpOptions to a file
+  // descriptor.
+  absl::Status ApplySocketMutatorInOptions(const FileDescriptor& fd,
+                                           grpc_fd_usage usage,
+                                           const PosixTcpOptions& options);
+  // Configures the default TCP_USER_TIMEOUT socket option for future sockets
+  // (static).
+  static void ConfigureDefaultTcpUserTimeout(bool enable, int timeout,
+                                             bool is_client);
+  // Applies standard configuration to a socket based on its type. Returns zero
+  // to indicate a success or a negative value to indicate an error
+  int ConfigureSocket(const FileDescriptor& fd, int type);
+  // Gets a socket option value (getsockopt wrapper).
+  PosixError GetSockOpt(const FileDescriptor& fd, int level, int optname,
+                        void* optval, void* optlen);
+  // Finds and returns an unused network port.
+  absl::StatusOr<int> GetUnusedPort();
+  // Performs an ioctl operation on a file descriptor.
+  PosixError Ioctl(const FileDescriptor& fd, int op, void* arg);
+  // Retrieves the local address of a socket as an EventEngine::ResolvedAddress.
+  absl::StatusOr<EventEngine::ResolvedAddress> LocalAddress(
+      const FileDescriptor& fd);
+  // Retrieves the local address of a socket as a string.
+  absl::StatusOr<std::string> LocalAddressString(const FileDescriptor& fd);
+  // Retrieves the peer address of a connected socket as an
+  // EventEngine::ResolvedAddress.
+  absl::StatusOr<EventEngine::ResolvedAddress> PeerAddress(
+      const FileDescriptor& fd);
+  // Retrieves the peer address of a connected socket as a string.
+  absl::StatusOr<std::string> PeerAddressString(const FileDescriptor& fd);
+  // Prepares a listener socket with specified options and address binding.
+  absl::StatusOr<EventEngine::ResolvedAddress> PrepareListenerSocket(
+      const FileDescriptor& fd, const PosixTcpOptions& options,
+      const EventEngine::ResolvedAddress& address);
+  // Applies a grpc_socket_mutator function to configure a socket.
+  absl::Status SetSocketMutator(const FileDescriptor& fd, grpc_fd_usage usage,
+                                grpc_socket_mutator* mutator);
+  // Tries to set the SO_NOSIGPIPE option on a socket if the platform supports
+  // it.
+  absl::Status SetSocketNoSigpipeIfPossible(const FileDescriptor& fd);
+  // Sets a socket option value (setsockopt wrapper).
+  PosixErrorOr<int64_t> SetSockOpt(const FileDescriptor& fd, int level,
+                                   int optname, uint32_t optval);
+
+  // Epoll
+#ifdef GRPC_LINUX_EPOLL
+  PosixError EpollCtlAdd(const FileDescriptor& epfd, bool writable,
+                         const FileDescriptor& fd, void* data);
+  PosixError EpollCtlDel(const FileDescriptor& epfd, const FileDescriptor& fd);
+#endif  // GRPC_LINUX_EPOLL
+
+  PosixError EventFdRead(const FileDescriptor& fd);
+  PosixError EventFdWrite(const FileDescriptor& fd);
+
+ private:
+  static bool IsEventEngineForkEnabled() {
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+    return grpc_core::IsEventEngineForkEnabled();
+#else   // GRPC_ENABLE_FORK_SUPPORT
+    return false;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  }
+
+  absl::Status PrepareTcpClientSocket(int fd,
+                                      const EventEngine::ResolvedAddress& addr,
+                                      const PosixTcpOptions& options);
+  PosixError PosixResultWrap(
+      const FileDescriptor& wrapped,
+      const absl::AnyInvocable<int(int) const>& fn) const;
+  bool IsCorrectGeneration(const FileDescriptor& fd) const;
+  PosixErrorOr<FileDescriptor> RegisterPosixResult(int result);
+
+  FileDescriptorCollection descriptors_;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_INTERFACE_H