grpc 1.73.0 → 1.74.0

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

@@ -27,11 +27,12 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/hash/hash.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
@@ -39,7 +40,6 @@
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
 
@@ -103,7 +103,7 @@ class PosixEnginePollerManager
   explicit PosixEnginePollerManager(
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
           poller);
-  grpc_event_engine::experimental::PosixEventPoller* Poller() {
+  grpc_event_engine::experimental::PosixEventPoller* Poller() const {
     return poller_.get();
   }
 
@@ -118,8 +118,6 @@ class PosixEnginePollerManager
   }
   void TriggerShutdown();
 
-  ~PosixEnginePollerManager() override;
-
  private:
   enum class PollerState { kExternal, kOk, kShuttingDown };
   std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
@@ -127,12 +125,12 @@ class PosixEnginePollerManager
   std::shared_ptr<ThreadPool> executor_;
   bool trigger_shutdown_called_;
 };
+
 #endif  // GRPC_POSIX_SOCKET_TCP
 
 // An iomgr-based Posix EventEngine implementation.
 // All methods require an ExecCtx to already exist on the thread's stack.
-class PosixEventEngine final : public PosixEventEngineWithFdSupport,
-                               public grpc_core::KeepsGrpcInitialized {
+class PosixEventEngine final : public PosixEventEngineWithFdSupport {
  public:
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
@@ -198,6 +196,13 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   bool Cancel(TaskHandle handle) override;
 
 #ifdef GRPC_POSIX_SOCKET_TCP
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  enum class OnForkRole { kChild, kParent };
+  void AfterFork(OnForkRole on_fork_role);
+  void BeforeFork();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
   // The posix EventEngine returned by this method would have a shared ownership
   // of the poller and would not be in-charge of driving the poller by calling
   // its Work(..) method. Instead its upto the test to drive the poller. The
@@ -209,15 +214,15 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 #endif  // GRPC_POSIX_SOCKET_TCP
 
  private:
+  friend class AresResolverTest;
   struct ClosureData;
 
   PosixEventEngine();
 
 #ifdef GRPC_POSIX_SOCKET_TCP
-  // Constructs an EventEngine which has a shared ownership of the poller. Do
-  // not call this constructor directly. Instead use the
-  // MakeTestOnlyPosixEventEngine static method. Its expected to be used only in
-  // tests.
+  // Constructs an EventEngine which has a shared ownership of the poller. Use
+  // the MakeTestOnlyPosixEventEngine static method to call this. Its expected
+  // to be used only in tests.
   explicit PosixEventEngine(
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
           poller);
@@ -234,11 +239,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
         ABSL_GUARDED_BY(&mu);
   };
 
-  static void PollerWorkInternal(
-      std::shared_ptr<PosixEnginePollerManager> poller_manager);
-
   ConnectionHandle CreateEndpointFromUnconnectedFdInternal(
-      int fd, EventEngine::OnConnectCallback on_connect,
+      const FileDescriptor& fd, EventEngine::OnConnectCallback on_connect,
       const EventEngine::ResolvedAddress& addr, const PosixTcpOptions& options,
       MemoryAllocator memory_allocator, EventEngine::Duration timeout);
 
@@ -249,14 +251,55 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 
 #endif  // GRPC_POSIX_SOCKET_TCP
 
+#if GRPC_ENABLE_FORK_SUPPORT
+  void AfterForkInChild();
+#endif
+
   grpc_core::Mutex mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
+#if GRPC_ENABLE_FORK_SUPPORT && GRPC_ARES == 1 && \
+    defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  // A separate mutex to avoid deadlocks.
+  grpc_core::Mutex resolver_handles_mu_;
+  absl::InlinedVector<std::weak_ptr<AresResolver::ReinitHandle>, 16>
+      resolver_handles_ ABSL_GUARDED_BY(resolver_handles_mu_);
+#endif  // defined(GRPC_ENABLE_FORK_SUPPORT) && GRPC_ARES == 1 &&
+        // defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
   std::shared_ptr<ThreadPool> executor_;
+
+#if defined(GRPC_POSIX_SOCKET_TCP) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+
+  // RAII wrapper for a polling cycle. Starts a new one in ctor and stops
+  // in dtor.
+  class PollingCycle {
+   public:
+    explicit PollingCycle(PosixEnginePollerManager* poller_manager);
+    ~PollingCycle();
+
+   private:
+    void PollerWorkInternal();
+
+    PosixEnginePollerManager* poller_manager_;
+    grpc_core::Mutex mu_;
+    std::atomic_bool done_{false};
+    int is_scheduled_ ABSL_GUARDED_BY(&mu_) = 0;
+    grpc_core::CondVar cond_;
+  };
+
+  void SchedulePoller();
+  void ResetPollCycle();
+
+  PosixEnginePollerManager poller_manager_;
+
+  // Ensures there's ever only one of these.
+  std::optional<PollingCycle> polling_cycle_ ABSL_GUARDED_BY(&mu_);
+
+#endif  // defined(GRPC_POSIX_SOCKET_TCP) &&
+        // !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+
   std::shared_ptr<TimerManager> timer_manager_;
-#ifdef GRPC_POSIX_SOCKET_TCP
-  std::shared_ptr<PosixEnginePollerManager> poller_manager_;
-#endif  // GRPC_POSIX_SOCKET_TCP
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -30,7 +30,6 @@
 #include <optional>
 #include <string>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -42,6 +41,7 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_listener.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/socket_mutator.h"
@@ -80,16 +80,15 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
   CHECK(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
   UnlinkIfUnixDomainSocket(addr);
 
+  EventEnginePosixInterface& posix_interface = poller_->posix_interface();
+
   /// Check if this is a wildcard port, and if so, try to keep the port the same
   /// as some previously created listener socket.
   for (auto it = acceptors_.begin();
        requested_port == 0 && it != acceptors_.end(); it++) {
-    EventEngine::ResolvedAddress sockname_temp;
-    socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-    if (0 == getsockname((*it)->Socket().sock.Fd(),
-                         const_cast<sockaddr*>(sockname_temp.address()),
-                         &len)) {
-      int used_port = ResolvedAddressGetPort(sockname_temp);
+    auto sockname_temp = posix_interface.LocalAddress((*it)->Fd());
+    if (sockname_temp.ok()) {
+      int used_port = ResolvedAddressGetPort(*sockname_temp);
       if (used_port > 0) {
         requested_port = used_port;
         ResolvedAddressSetPort(res_addr, requested_port);
@@ -97,21 +96,21 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
       }
     }
   }
-
   auto used_port = MaybeGetWildcardPortFromAddress(res_addr);
   // Update the callback. Any subsequent new sockets created and added to
   // acceptors_ in this function will invoke the new callback.
   acceptors_.UpdateOnAppendCallback(std::move(on_bind_new_fd));
   if (used_port.has_value()) {
     requested_port = *used_port;
-    return ListenerContainerAddWildcardAddresses(acceptors_, options_,
-                                                 requested_port);
+    return ListenerContainerAddWildcardAddresses(&posix_interface, acceptors_,
+                                                 options_, requested_port);
   }
   if (ResolvedAddressToV4Mapped(res_addr, &addr6_v4mapped)) {
     res_addr = addr6_v4mapped;
   }
 
-  auto result = CreateAndPrepareListenerSocket(options_, res_addr);
+  auto result =
+      CreateAndPrepareListenerSocket(&posix_interface, options_, res_addr);
   GRPC_RETURN_IF_ERROR(result.status());
   acceptors_.Append(*result);
   return result->port;
@@ -136,22 +135,31 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
   for (;;) {
     EventEngine::ResolvedAddress addr;
     memset(const_cast<sockaddr*>(addr.address()), 0, addr.size());
+    auto& posix_interface = handle_->Poller()->posix_interface();
     // Note: If we ever decide to return this address to the user, remember to
     // strip off the ::ffff:0.0.0.0/96 prefix first.
-    int fd = Accept4(handle_->WrappedFd(), addr, 1, 1);
-    if (fd < 0) {
-      switch (errno) {
+    auto fd = posix_interface.Accept4(handle_->WrappedFd(), addr, 1, 1);
+    if (fd.IsWrongGenerationError()) {
+      LOG(ERROR) << "Closing acceptor. accept4 was called with fd from a wrong "
+                    "generation";
+      // Shutting down the acceptor. Unref the ref grabbed in
+      // AsyncConnectionAcceptor::Start().
+      Unref();
+      return;
+    }
+    if (fd.IsPosixError()) {
+      switch (*fd.errno_value()) {
         case EINTR:
           continue;
         case EMFILE:
-          // When the process runs out of fds, accept4() returns EMFILE. When
-          // this happens, the connection is left in the accept queue until
-          // either a read event triggers the on_read callback, or time has
-          // passed and the accept should be re-tried regardless. This callback
-          // is not cancelled, so a spurious wakeup may occur even when there's
-          // nothing to accept. This is not a performant code path, but if an fd
-          // limit has been reached, the system is likely in an unhappy state
-          // regardless.
+          // When the process runs out of posix_interface, accept4() returns
+          // EMFILE. When this happens, the connection is left in the accept
+          // queue until either a read event triggers the on_read callback, or
+          // time has passed and the accept should be re-tried regardless. This
+          // callback is not cancelled, so a spurious wakeup may occur even when
+          // there's nothing to accept. This is not a performant code path, but
+          // if an fd limit has been reached, the system is likely in an unhappy
+          // state regardless.
           LOG_EVERY_N_SEC(ERROR, 1)
               << "File descriptor limit reached. Retrying.";
           handle_->NotifyOnRead(notify_on_accept_);
@@ -186,8 +194,8 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     // For UNIX sockets, the accept call might not fill up the member
     // sun_path of sockaddr_un, so explicitly call getpeername to get it.
     if (addr.address()->sa_family == AF_UNIX) {
-      socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
-      if (getpeername(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
+      auto peer_address = posix_interface.PeerAddress(fd.value());
+      if (!peer_address.ok()) {
         auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
         LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno)
                    << ". Dropping the connection, and continuing "
@@ -195,17 +203,16 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
                    << (listener_addr_uri.ok() ? *listener_addr_uri
                                               : "<unknown>")
                    << ":" << socket_.port;
-        close(fd);
+        posix_interface.Close(fd.value());
         handle_->NotifyOnRead(notify_on_accept_);
         return;
       }
-      addr = EventEngine::ResolvedAddress(addr.address(), len);
+      addr = std::move(peer_address).value();
     }
 
-    PosixSocketWrapper sock(fd);
-    (void)sock.SetSocketNoSigpipeIfPossible();
-    auto result = sock.ApplySocketMutatorInOptions(
-        GRPC_FD_SERVER_CONNECTION_USAGE, listener_->options_);
+    (void)posix_interface.SetSocketNoSigpipeIfPossible(fd.value());
+    auto result = posix_interface.ApplySocketMutatorInOptions(
+        fd.value(), GRPC_FD_SERVER_CONNECTION_USAGE, listener_->options_);
     if (!result.ok()) {
       LOG(ERROR) << "Closing acceptor. Failed to apply socket mutator: "
                  << result;
@@ -226,7 +233,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     }
     auto endpoint = CreatePosixEndpoint(
         /*handle=*/listener_->poller_->CreateHandle(
-            fd, *peer_name, listener_->poller_->CanTrackErrors()),
+            fd.value(), *peer_name, listener_->poller_->CanTrackErrors()),
         /*on_shutdown=*/nullptr, /*engine=*/listener_->engine_,
         // allocator=
         listener_->memory_allocator_factory_->CreateMemoryAllocator(
@@ -238,7 +245,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       // Call on_accept_ and then resume accepting new connections
       // by continuing the parent for-loop.
       listener_->on_accept_(
-          /*listener_fd=*/handle_->WrappedFd(),
+          /*listener_fd=*/handle_->WrappedFd().fd(),
           /*endpoint=*/std::move(endpoint),
           /*is_external=*/false,
           /*memory_allocator=*/
@@ -260,18 +267,19 @@ absl::Status PosixEngineListenerImpl::HandleExternalConnection(
     return absl::UnknownError(
         absl::StrCat("HandleExternalConnection: Invalid peer socket: ", fd));
   }
-  PosixSocketWrapper sock(fd);
-  (void)sock.SetSocketNoSigpipeIfPossible();
-  auto peer_name = sock.PeerAddressString();
+  auto& posix_interface = poller_->posix_interface();
+  FileDescriptor wrapped = posix_interface.Adopt(fd);
+  (void)posix_interface.SetSocketNoSigpipeIfPossible(wrapped);
+  auto peer_name = posix_interface.PeerAddressString(wrapped);
   if (!peer_name.ok()) {
     return absl::UnknownError(
         absl::StrCat("HandleExternalConnection: peer not connected: ",
                      peer_name.status().ToString()));
   }
   grpc_core::EnsureRunInExecCtx([this, peer_name = std::move(*peer_name),
-                                 pending_data, listener_fd, fd]() mutable {
+                                 pending_data, listener_fd, wrapped]() mutable {
     auto endpoint = CreatePosixEndpoint(
-        /*handle=*/poller_->CreateHandle(fd, peer_name,
+        /*handle=*/poller_->CreateHandle(wrapped, peer_name,
                                          poller_->CanTrackErrors()),
         /*on_shutdown=*/nullptr, /*engine=*/engine_,
         /*allocator=*/

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

@@ -24,7 +24,6 @@
 #include <atomic>
 #include <list>
 #include <memory>
-#include <string>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -32,6 +31,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/sync.h"
 
@@ -85,7 +85,7 @@ class PosixEngineListenerImpl
           listener_(std::move(listener)),
           socket_(socket),
           handle_(listener_->poller_->CreateHandle(
-              socket_.sock.Fd(),
+              socket_.sock,
               *grpc_event_engine::experimental::
                   ResolvedAddressToNormalizedString(socket_.addr),
               listener_->poller_->CanTrackErrors())),
@@ -105,8 +105,10 @@ class PosixEngineListenerImpl
       }
     }
     ListenerSocketsContainer::ListenerSocket& Socket() { return socket_; }
+    FileDescriptor Fd() { return handle_->WrappedFd(); }
     ~AsyncConnectionAcceptor() {
-      auto address = socket_.sock.LocalAddress();
+      auto address = handle_->Poller()->posix_interface().LocalAddress(
+          handle_->WrappedFd());
       if (address.ok()) {
         // If uds socket, unlink it so that the corresponding file is deleted.
         UnlinkIfUnixDomainSocket(*address);
@@ -140,7 +142,7 @@ class PosixEngineListenerImpl
       acceptors_.push_back(new AsyncConnectionAcceptor(
           listener_->engine_, listener_->shared_from_this(), socket));
       if (on_append_) {
-        on_append_(socket.sock.Fd());
+        on_append_(socket.sock.fd());
       }
     }
 

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);