grpc 1.78.0 → 1.80.0.pre1

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.h

@@ -77,8 +77,7 @@ class DNSServiceResolver : public EventEngine::DNSResolver {
  public:
   explicit DNSServiceResolver(std::shared_ptr<CFEventEngine> engine)
       : engine_(std::move(engine)),
-        impl_(grpc_core::MakeRefCounted<DNSServiceResolverImpl>(
-            std::move((engine_)))) {}
+        impl_(grpc_core::MakeRefCounted<DNSServiceResolverImpl>(engine_)) {}
 
   ~DNSServiceResolver() override { impl_->Shutdown(); }
 

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

@@ -12,8 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/telemetry/context_list_entry.h"
 #include "absl/strings/str_cat.h"
 
@@ -78,4 +82,9 @@ std::ostream& operator<<(std::ostream& out,
   return printout(out, handle);
 }
 
+const grpc_arg_pointer_vtable* grpc_event_engine_arg_vtable() {
+  return grpc_core::ChannelArgTypeTraits<
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>>::VTable();
+}
+
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/extensions/tcp_trace.h

@@ -24,9 +24,6 @@
 
 namespace grpc_event_engine::experimental {
 
-/** If non-zero, enable TCP tracing and stats collection. */
-#define GRPC_ARG_TCP_TRACING_ENABLED "grpc.tcp_tracing_enabled"
-
 class TcpTraceExtension {
  public:
   virtual ~TcpTraceExtension() = default;

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

@@ -590,8 +590,8 @@ Poller::WorkResult PollPoller::Work(
             pfds[pfd_count].events = head->BeginPollLocked(POLLIN, POLLOUT);
             pfd_count++;
           } else {
-            LOG(ERROR) << "Polling FD from a wrong generation: "
-                       << head->WrappedFd();
+            LOG(INFO) << "FD from fork parent still in poll list: "
+                      << head->WrappedFd();
           }
         }
       }

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

@@ -608,7 +608,7 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
             grpc_event_engine::experimental::SliceBuffer* buffer,
             grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
                 args) override {
-    return impl_->Read(std::move(on_read), buffer, std::move(args));
+    return impl_->Read(std::move(on_read), buffer, args);
   }
 
   bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,

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

@@ -403,9 +403,10 @@ void PosixEventEngine::OnConnectFinishInternal(int connection_handle) {
   }
 }
 
-std::shared_ptr<PosixEventEngine> PosixEventEngine::MakePosixEventEngine() {
+std::shared_ptr<PosixEventEngine> PosixEventEngine::MakePosixEventEngine(
+    Options options) {
   // Can't use make_shared as ctor is private
-  std::shared_ptr<PosixEventEngine> engine(new PosixEventEngine());
+  std::shared_ptr<PosixEventEngine> engine(new PosixEventEngine(options));
   RegisterEventEngineForFork(engine, engine->executor_, engine->timer_manager_);
   return engine;
 }
@@ -416,20 +417,21 @@ PosixEventEngine::MakeTestOnlyPosixEventEngine(
         test_only_poller) {
   // Calling a private PosixEventEngine constructor - can't do make_shared
   std::shared_ptr<PosixEventEngine> engine(
-      new PosixEventEngine(std::move(test_only_poller)));
+      new PosixEventEngine(Options{}, std::move(test_only_poller)));
   RegisterEventEngineForFork(engine, engine->executor_, engine->timer_manager_);
   return engine;
 }
 
-PosixEventEngine::PosixEventEngine(std::shared_ptr<PosixEventPoller> poller)
-    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+PosixEventEngine::PosixEventEngine(const Options& options,
+                                   std::shared_ptr<PosixEventPoller> poller)
+    : connection_shards_(options.connection_shards),
       poller_(std::move(poller)),
-      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
+      executor_(MakeThreadPool(options.reserve_threads)),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {}
 
-PosixEventEngine::PosixEventEngine()
-    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
-      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
+PosixEventEngine::PosixEventEngine(const Options& options)
+    : connection_shards_(options.connection_shards),
+      executor_(MakeThreadPool(options.reserve_threads)),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
   if (ShouldUsePosixPoller()) {
     poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
@@ -457,6 +459,19 @@ struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
   }
 };
 
+void PosixEventEngine::CancelAllPendingTimers() {
+  {
+    grpc_core::MutexLock lock(&mu_);
+    auto pending_handles = known_handles_;
+    for (auto handle : pending_handles) {
+      CancelInternal(handle);
+    }
+    GRPC_CHECK(known_handles_.empty());
+    // Prevent new timers from being scheduled on this EventEngine.
+    disallow_new_timers_ = true;
+  }
+}
+
 PosixEventEngine::~PosixEventEngine() {
   {
     grpc_core::MutexLock lock(&mu_);
@@ -478,6 +493,10 @@ PosixEventEngine::~PosixEventEngine() {
 
 bool PosixEventEngine::Cancel(EventEngine::TaskHandle handle) {
   grpc_core::MutexLock lock(&mu_);
+  return CancelInternal(handle);
+}
+
+bool PosixEventEngine::CancelInternal(EventEngine::TaskHandle handle) {
   if (!known_handles_.contains(handle)) return false;
   auto* cd = reinterpret_cast<ClosureData*>(handle.keys[0]);
   bool r = timer_manager_->TimerCancel(&cd->timer);
@@ -517,6 +536,12 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
   EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
                                  aba_token_.fetch_add(1)};
   grpc_core::MutexLock lock(&mu_);
+  if (disallow_new_timers_) {
+    delete cd;
+    // Return handle and don't schedule the callback. The caller will see a
+    // valid handle but it cannot be cancelled since it was not scheduled.
+    return handle;
+  }
   known_handles_.insert(handle);
   cd->handle = handle;
   GRPC_TRACE_LOG(event_engine, INFO)

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

@@ -16,8 +16,10 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/support/cpu.h>
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
 #include <atomic>
 #include <cstdint>
 #include <memory>
@@ -35,6 +37,7 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
+#include "src/core/util/useful.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/inlined_vector.h"
@@ -100,6 +103,17 @@ class AsyncConnect {
 // All methods require an ExecCtx to already exist on the thread's stack.
 class PosixEventEngine final : public PosixEventEngineWithFdSupport {
  public:
+  struct Options {
+    // Number of connection shards to use.
+    int connection_shards;
+    // Number of threads to reserve for the thread pool.
+    int reserve_threads;
+    // Options struct is expected to grow to include more fields to
+    // configure the thread pool, poller etc.
+    Options()
+        : connection_shards(std::max(2 * gpr_cpu_num_cores(), 1u)),
+          reserve_threads(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u)) {}
+  };
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
     explicit PosixDNSResolver(
@@ -116,7 +130,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
     grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver_;
   };
 
-  static std::shared_ptr<PosixEventEngine> MakePosixEventEngine();
+  static std::shared_ptr<PosixEventEngine> MakePosixEventEngine(
+      Options options = Options{});
 
   ~PosixEventEngine() override;
 
@@ -162,6 +177,9 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
   TaskHandle RunAfter(Duration when,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
+  // Cancels all pending timers and prevents any more timers from being
+  // scheduled. This method should be only called prior to EventEngine shutdown.
+  void CancelAllPendingTimers();
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
@@ -185,13 +203,16 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
   friend class AresResolverTest;
   struct ClosureData;
 
-  PosixEventEngine();
+  explicit PosixEventEngine(const Options& options);
+
+  bool CancelInternal(TaskHandle handle) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
 #ifdef GRPC_POSIX_SOCKET_TCP
   // 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(
+      const Options& options,
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
           poller);
 
@@ -249,6 +270,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
 #endif
 
   grpc_core::Mutex mu_;
+  bool disallow_new_timers_ ABSL_GUARDED_BY(mu_) = false;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
 #if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)

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

@@ -273,9 +273,7 @@ absl::Status PosixEngineListenerImpl::HandleExternalConnection(
   (void)posix_interface.SetSocketNoSigpipeIfPossible(wrapped);
   auto peer_name = posix_interface.PeerAddressString(wrapped);
   if (!peer_name.ok()) {
-    if (grpc_core::IsGracefulExternalConnectionFailureEnabled()) {
-      posix_interface.Close(wrapped);
-    }
+    posix_interface.Close(wrapped);
     return absl::UnknownError(
         absl::StrCat("HandleExternalConnection: peer not connected: ",
                      peer_name.status().ToString()));

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

@@ -26,6 +26,7 @@
 #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/experiments/experiments.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/grpc_check.h"
@@ -63,10 +64,10 @@ bool SystemHasIfAddrs() { return false; }
 
 #endif  // GRPC_HAVE_IFADDRS
 
-// Prepare a recently-created socket for listening.
-absl::Status PrepareSocket(EventEnginePosixInterface* posix_interface,
-                           const PosixTcpOptions& options,
-                           ListenerSocket& socket) {
+// Prepare socket options for a recently-created socket for listening.
+absl::Status PrepareListenerSocketOptions(
+    EventEnginePosixInterface* posix_interface, const PosixTcpOptions& options,
+    ListenerSocket& socket) {
   FileDescriptor fd = socket.sock;
   GRPC_CHECK(fd.ready());
   bool close_fd = true;
@@ -77,24 +78,119 @@ absl::Status PrepareSocket(EventEnginePosixInterface* posix_interface,
           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();
+  auto status = posix_interface->PrepareListenerSocketOptions(
+      socket.sock, options, socket.addr);
+  if (!status.ok()) {
+    return status;
   }
-  socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-  socket.port =
-      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();
 }
 
+absl::StatusOr<int> NewListenerContainerAddWildcardAddresses(
+    EventEnginePosixInterface* posix_interface,
+    ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
+    int requested_port,
+    absl::AnyInvocable<bool(const ListenerSocket&)> socket_filter) {
+  bool should_expand_wildcard_addrs =
+      SystemHasIfAddrs() && options.expand_wildcard_addrs;
+  if (should_expand_wildcard_addrs && socket_filter == nullptr) {
+    // If there is no socket filter, we can just expand all local addresses.
+    return ListenerContainerAddAllLocalAddresses(
+        posix_interface, listener_sockets, options, requested_port);
+  }
+
+  ResolvedAddress wild4 = ResolvedAddressMakeWild4(requested_port);
+  ResolvedAddress wild6 = ResolvedAddressMakeWild6(requested_port);
+  absl::StatusOr<ListenerSocket> v6_sock = absl::InternalError("init");
+  absl::StatusOr<ListenerSocket> v4_sock = absl::InternalError("init");
+  bool add_v4_sock = true;
+
+  // Try creating IPv6 socket first.
+  v6_sock = CreateListenerSocketWithoutBinding(posix_interface, options, wild6);
+  if (v6_sock.ok()) {
+    if (v6_sock->dsmode == EventEnginePosixInterface::DSMODE_DUALSTACK ||
+        v6_sock->dsmode == EventEnginePosixInterface::DSMODE_IPV4) {
+      add_v4_sock = false;
+    }
+  }
+  if (add_v4_sock) {
+    // If we got a v6-only socket or nothing, try creating IPv4 socket.
+    v4_sock =
+        CreateListenerSocketWithoutBinding(posix_interface, options, wild4);
+  }
+
+  // If there is a socket filter, we only expand the wildcard addresses if
+  // the socket filter returns true for either socket.
+  if (should_expand_wildcard_addrs &&
+      ((v6_sock.ok() && socket_filter(*v6_sock)) ||
+       (v4_sock.ok() && socket_filter(*v4_sock)))) {
+    // Close the wildcard sockets and expand all local addresses.
+    if (v6_sock.ok()) {
+      posix_interface->Close(v6_sock->sock);
+    }
+    if (v4_sock.ok()) {
+      posix_interface->Close(v4_sock->sock);
+    }
+    return ListenerContainerAddAllLocalAddresses(
+        posix_interface, listener_sockets, options, requested_port);
+  }
+
+  if (!v6_sock.ok() && !v4_sock.ok()) {
+    return absl::FailedPreconditionError(absl::StrCat(
+        "Failed to add any wildcard listeners: ", v6_sock.status().message(),
+        v4_sock.status().message()));
+  }
+
+  // If we are not expanding wildcard addresses, we now bind to each wildcard
+  // socket and add them to the listener sockets container.
+  int assigned_port = 0;
+  if (v6_sock.ok()) {
+    auto bind_status =
+        BindListenerSocket(posix_interface, v6_sock->addr, *v6_sock);
+    if (bind_status.ok()) {
+      assigned_port = v6_sock->port;
+      listener_sockets.Append(*v6_sock);
+    } else {
+      v6_sock = bind_status;
+    }
+  }
+  if (v4_sock.ok()) {
+    if (assigned_port != 0) {
+      ResolvedAddressSetPort(v4_sock->addr, assigned_port);
+    }
+    auto bind_status =
+        BindListenerSocket(posix_interface, v4_sock->addr, *v4_sock);
+    if (bind_status.ok()) {
+      assigned_port = v4_sock->port;
+      listener_sockets.Append(*v4_sock);
+    } else {
+      v4_sock = bind_status;
+    }
+  }
+  if (assigned_port > 0) return assigned_port;
+  return absl::FailedPreconditionError(absl::StrCat(
+      "Failed to add any wildcard listeners: ", v6_sock.status().message(),
+      v4_sock.status().message()));
+}
+
 }  // namespace
 
 absl::StatusOr<ListenerSocket> CreateAndPrepareListenerSocket(
     EventEnginePosixInterface* posix_interface, const PosixTcpOptions& options,
     const ResolvedAddress& addr) {
+  auto result =
+      CreateListenerSocketWithoutBinding(posix_interface, options, addr);
+  GRPC_RETURN_IF_ERROR(result.status());
+  GRPC_RETURN_IF_ERROR(
+      BindListenerSocket(posix_interface, result->addr, *result));
+  return result;
+}
+
+absl::StatusOr<ListenerSocket> CreateListenerSocketWithoutBinding(
+    EventEnginePosixInterface* posix_interface, const PosixTcpOptions& options,
+    const ResolvedAddress& addr) {
   ResolvedAddress addr4_copy;
   ListenerSocket socket;
   auto result = posix_interface->CreateDualStackSocket(
@@ -109,11 +205,36 @@ absl::StatusOr<ListenerSocket> CreateAndPrepareListenerSocket(
   } else {
     socket.addr = addr;
   }
-  GRPC_RETURN_IF_ERROR(PrepareSocket(posix_interface, options, socket));
-  GRPC_CHECK_GT(socket.port, 0);
+  GRPC_RETURN_IF_ERROR(
+      PrepareListenerSocketOptions(posix_interface, options, socket));
   return socket;
 }
 
+absl::Status BindListenerSocket(EventEnginePosixInterface* posix_interface,
+                                const ResolvedAddress& addr,
+                                ListenerSocket& socket) {
+  FileDescriptor fd = socket.sock;
+  GRPC_CHECK(fd.ready());
+  bool close_fd = true;
+  socket.port = 0;
+  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->BindListenerSocket(socket.sock, addr);
+  if (!listen_address.ok()) {
+    return std::move(listen_address).status();
+  }
+  socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
+  socket.port =
+      ResolvedAddressGetPort(ResolvedAddress(listen_address->address(), len));
+  close_fd = false;
+  GRPC_CHECK_GT(socket.port, 0);
+  return absl::OkStatus();
+}
+
 bool IsSockAddrLinkLocal(const EventEngine::ResolvedAddress* resolved_addr) {
   const sockaddr* addr = resolved_addr->address();
   if (addr->sa_family == AF_INET) {
@@ -226,7 +347,13 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
 absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
     EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
-    int requested_port) {
+    int requested_port,
+    absl::AnyInvocable<bool(const ListenerSocket&)> socket_filter) {
+  if (grpc_core::IsWildcardIpExpansionRestrictionEnabled()) {
+    return NewListenerContainerAddWildcardAddresses(
+        posix_interface, listener_sockets, options, requested_port,
+        std::move(socket_filter));
+  }
   ResolvedAddress wild4 = ResolvedAddressMakeWild4(requested_port);
   ResolvedAddress wild6 = ResolvedAddressMakeWild6(requested_port);
   absl::StatusOr<ListenerSocket> v6_sock;

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

@@ -51,6 +51,20 @@ class ListenerSocketsContainer {
   virtual ~ListenerSocketsContainer() = default;
 };
 
+// Creates a listener socket, and prepares it with specified options, but
+// does not bind or listen on it.
+absl::StatusOr<ListenerSocketsContainer::ListenerSocket>
+CreateListenerSocketWithoutBinding(EventEnginePosixInterface* posix_interface,
+                                   const PosixTcpOptions& options,
+                                   const EventEngine::ResolvedAddress& addr);
+
+// Binds and listens on a listener socket. The socket must have been created
+// with `CreateListenerSocketWithoutBinding`.
+absl::Status BindListenerSocket(
+    EventEnginePosixInterface* posix_interface,
+    const EventEngine::ResolvedAddress& addr,
+    ListenerSocketsContainer::ListenerSocket& socket);
+
 // Creates and configures a socket to be used by the EventEngine Listener. The
 // type of the socket to create is determined by the by the passed address. The
 // socket configuration is specified by passed tcp options. If successful, it
@@ -66,11 +80,14 @@ CreateAndPrepareListenerSocket(
 // server. The newly created socket is configured according to the passed
 // options and added to the passed ListenerSocketsContainer object. The function
 // returns the port at which the created socket listens for incoming
-// connections.
+// connections. The optional socket_filter is used to provide additional
+// constraints on whether the wildcard address should be expanded.
 absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
     EventEnginePosixInterface* posix_interface,
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
-    int requested_port);
+    int requested_port,
+    absl::AnyInvocable<bool(const ListenerSocketsContainer::ListenerSocket&)>
+        socket_filter = nullptr);
 
 // Get all addresses assigned to network interfaces on the machine and create
 // and add a socket for each local address. Each newly created socket is

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

@@ -161,6 +161,13 @@ class EventEnginePosixInterface {
       const FileDescriptor& fd);
   // Retrieves the peer address of a connected socket as a string.
   absl::StatusOr<std::string> PeerAddressString(const FileDescriptor& fd);
+  // Prepares listener socket options, but does not bind or listen.
+  absl::Status PrepareListenerSocketOptions(
+      const FileDescriptor& fd, const PosixTcpOptions& options,
+      const EventEngine::ResolvedAddress& address);
+  // Bind and listen on a listener socket.
+  absl::StatusOr<EventEngine::ResolvedAddress> BindListenerSocket(
+      const FileDescriptor& fd, const EventEngine::ResolvedAddress& address);
   // Prepares a listener socket with specified options and address binding.
   absl::StatusOr<EventEngine::ResolvedAddress> PrepareListenerSocket(
       const FileDescriptor& fd, const PosixTcpOptions& options,

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

@@ -804,12 +804,12 @@ absl::StatusOr<std::string> EventEnginePosixInterface::PeerAddressString(
   return ResolvedAddressToNormalizedString((*status));
 }
 
-absl::StatusOr<EventEngine::ResolvedAddress>
-EventEnginePosixInterface::PrepareListenerSocket(
+absl::Status EventEnginePosixInterface::PrepareListenerSocketOptions(
     const FileDescriptor& fd, const PosixTcpOptions& options,
     const EventEngine::ResolvedAddress& address) {
   if (!IsCorrectGeneration(fd)) {
-    return absl::InternalError("PrepareListenerSocket: wrong generation");
+    return absl::InternalError(
+        "PrepareListenerSocketOptions: wrong generation");
   }
   int f = fd.fd();
   if (IsSocketReusePortSupported() && options.allow_reuse_port &&
@@ -837,6 +837,16 @@ EventEnginePosixInterface::PrepareListenerSocket(
     // it's not fatal, so just log it.
     VLOG(2) << "Node does not support SO_ZEROCOPY, continuing.";
   }
+  return absl::OkStatus();
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::BindListenerSocket(
+    const FileDescriptor& fd, const EventEngine::ResolvedAddress& address) {
+  if (!IsCorrectGeneration(fd)) {
+    return absl::InternalError("BindListenerSocket: wrong generation");
+  }
+  int f = fd.fd();
   if (bind(f, address.address(), address.size()) < 0) {
     auto sockaddr_str = ResolvedAddressToString(address);
     if (!sockaddr_str.ok()) {
@@ -863,6 +873,14 @@ EventEnginePosixInterface::PrepareListenerSocket(
   return sockname_temp;
 }
 
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::PrepareListenerSocket(
+    const FileDescriptor& fd, const PosixTcpOptions& options,
+    const EventEngine::ResolvedAddress& address) {
+  GRPC_RETURN_IF_ERROR(PrepareListenerSocketOptions(fd, options, address));
+  return BindListenerSocket(fd, address);
+}
+
 // Set a socket using a grpc_socket_mutator
 absl::Status EventEnginePosixInterface::SetSocketMutator(
     const FileDescriptor& fd, grpc_fd_usage usage,

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

@@ -126,6 +126,22 @@ absl::Status EventEnginePosixInterface::PrepareTcpClientSocket(
       "EventEnginePosixInterface::PrepareTcpClientSocket");
 }
 
+absl::Status EventEnginePosixInterface::PrepareListenerSocketOptions(
+    const FileDescriptor& fd, const PosixTcpOptions& options,
+    const EventEngine::ResolvedAddress& address) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::PrepareListenerSocketOptions");
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::BindListenerSocket(
+    const FileDescriptor& fd, const EventEngine::ResolvedAddress& address) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::BindListenerSocket");
+}
+
 absl::StatusOr<EventEngine::ResolvedAddress>
 EventEnginePosixInterface::PrepareListenerSocket(
     const FileDescriptor& fd, const PosixTcpOptions& options,