grpc 1.55.0 → 1.56.0.pre3

data/src/core/lib/iomgr/iocp_windows.cc

@@ -43,6 +43,7 @@ static ULONG g_iocp_kick_token;
 static OVERLAPPED g_iocp_custom_overlap;
 
 static gpr_atm g_custom_events = 0;
+static gpr_atm g_pending_socket_shutdowns = 0;
 
 static HANDLE g_iocp;
 
@@ -90,6 +91,7 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
   } else {
     abort();
   }
+  gpr_mu_lock(&socket->state_mu);
   if (socket->shutdown_called) {
     info->bytes_transferred = 0;
     info->wsa_error = WSA_OPERATION_ABORTED;
@@ -100,7 +102,11 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
     info->wsa_error = success ? 0 : WSAGetLastError();
   }
   GPR_ASSERT(overlapped == &info->overlapped);
-  grpc_socket_become_ready(socket, info);
+  bool should_destroy = grpc_socket_become_ready(socket, info);
+  gpr_mu_unlock(&socket->state_mu);
+  if (should_destroy) {
+    grpc_winsocket_finish(socket);
+  }
   return GRPC_IOCP_WORK_WORK;
 }
 
@@ -122,11 +128,13 @@ void grpc_iocp_kick(void) {
 void grpc_iocp_flush(void) {
   grpc_core::ExecCtx exec_ctx;
   grpc_iocp_work_status work_status;
-
+  // This method is called during grpc_shutdown. We make the loop
+  // spin until any pending socket shutdowns are complete.
   do {
     work_status = grpc_iocp_work(grpc_core::Timestamp::InfPast());
   } while (work_status == GRPC_IOCP_WORK_KICK ||
-           grpc_core::ExecCtx::Get()->Flush());
+           grpc_core::ExecCtx::Get()->Flush() ||
+           gpr_atm_acq_load(&g_pending_socket_shutdowns) != 0);
 }
 
 void grpc_iocp_shutdown(void) {
@@ -155,4 +163,17 @@ void grpc_iocp_add_socket(grpc_winsocket* socket) {
   GPR_ASSERT(ret == g_iocp);
 }
 
+void grpc_iocp_register_socket_shutdown_socket_locked(grpc_winsocket* socket) {
+  if (!socket->shutdown_registered) {
+    socket->shutdown_registered = true;
+    gpr_atm_full_fetch_add(&g_pending_socket_shutdowns, 1);
+  }
+}
+
+void grpc_iocp_finish_socket_shutdown(grpc_winsocket* socket) {
+  if (socket->shutdown_registered) {
+    gpr_atm_full_fetch_add(&g_pending_socket_shutdowns, -1);
+  }
+}
+
 #endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/iocp_windows.h

@@ -43,6 +43,17 @@ void grpc_iocp_flush(void);
 void grpc_iocp_shutdown(void);
 void grpc_iocp_add_socket(grpc_winsocket*);
 
+// Register that this socket has started shutting down.
+// This prevents gRPC from completing its own shutdown until this socket's
+// shutdown is finished. IOCP must continue doing work until all such sockets
+// have finished shutting down. The socket's state_mu must be locked.
+void grpc_iocp_register_socket_shutdown_socket_locked(grpc_winsocket* socket);
+
+// Mark that this socket has finished shutting down.
+// The socket's state lock does not need to be held since this function is only
+// called once the socket is ready to be destroyed.
+void grpc_iocp_finish_socket_shutdown(grpc_winsocket* socket);
+
 #endif
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_IOCP_WINDOWS_H

data/src/core/lib/iomgr/iomgr_posix_cfstream.cc

@@ -73,7 +73,7 @@ static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool apple_iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error_handle error) {
+    grpc_closure* /*closure*/, grpc_error_handle /*error*/) {
   return false;
 }
 

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -357,8 +357,10 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
           return absl::OkStatus();
         }
         if (newval != timeout) {
-          // Do not fail on failing to set TCP_USER_TIMEOUT for now.
-          gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
+          gpr_log(GPR_INFO,
+                  "Setting TCP_USER_TIMEOUT to value %d ms. Actual "
+                  "TCP_USER_TIMEOUT value is %d ms",
+                  timeout, newval);
           return absl::OkStatus();
         }
       }

data/src/core/lib/iomgr/socket_windows.cc

@@ -76,6 +76,51 @@ void grpc_winsocket_shutdown(grpc_winsocket* winsocket) {
     return;
   }
   winsocket->shutdown_called = true;
+  bool register_shutdown = false;
+  // If there is already a scheduled read closure, run it immediately. This
+  // follows the same semantics applied to posix endpoint which also runs any
+  // already registered closure immediately in the event of a shutdown.
+  if (winsocket->read_info.closure && !winsocket->read_info.has_pending_iocp) {
+    winsocket->read_info.bytes_transferred = 0;
+    winsocket->read_info.wsa_error = WSA_OPERATION_ABORTED;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, winsocket->read_info.closure,
+                            absl::OkStatus());
+    // Note that while the read_info.closure closure is run, it is not set to
+    // NULL here. This ensures that the socket cannot get deleted yet until any
+    // pending I/O operations are flushed by the thread executing
+    // grpc_iocp_work. We set read_info.closure_already_executed_at_shutdown to
+    // true so that when the pending read I/O operations are flushed, the
+    // associated closure is not executed in the grpc_socket_became_ready
+    // function.
+    winsocket->read_info.closure_already_executed_at_shutdown = true;
+    register_shutdown = true;
+  }
+
+  // If there is already a scheduled write closure, run it immediately. This
+  // follows the same semantics applied to posix endpoint which also runs any
+  // already registered closure immediately in the event of a shutdown.
+  if (winsocket->write_info.closure &&
+      !winsocket->write_info.has_pending_iocp) {
+    winsocket->write_info.bytes_transferred = 0;
+    winsocket->write_info.wsa_error = WSA_OPERATION_ABORTED;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, winsocket->write_info.closure,
+                            absl::OkStatus());
+    // Note that while the write_info.closure closure is run, it is not set to
+    // NULL here. This ensures that the socket cannot get deleted yet until any
+    // pending I/O operations are flushed by the thread executing
+    // grpc_iocp_work. We set
+    // write_info.closure.closure_already_executed_at_shutdown to true so that
+    // when the pending write I/O operations are flushed, the associated closure
+    // is not executed in the grpc_socket_became_ready function.
+    winsocket->write_info.closure_already_executed_at_shutdown = true;
+    register_shutdown = true;
+  }
+
+  if (register_shutdown) {
+    // Instruct gRPC to avoid completing any shutdowns until this socket is
+    // cleaned up.
+    grpc_iocp_register_socket_shutdown_socket_locked(winsocket);
+  }
   gpr_mu_unlock(&winsocket->state_mu);
 
   status = WSAIoctl(winsocket->socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
@@ -90,6 +135,8 @@ void grpc_winsocket_shutdown(grpc_winsocket* winsocket) {
             utf8_message);
     gpr_free(utf8_message);
   }
+  // Calling closesocket triggers invocation of any pending I/O operations with
+  // ABORTED status.
   closesocket(winsocket->socket);
 }
 
@@ -105,13 +152,20 @@ static bool check_destroyable(grpc_winsocket* winsocket) {
          winsocket->read_info.closure == NULL;
 }
 
+void grpc_winsocket_finish(grpc_winsocket* winsocket) {
+  grpc_iocp_finish_socket_shutdown(winsocket);
+  destroy(winsocket);
+}
+
 void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
   gpr_mu_lock(&winsocket->state_mu);
   GPR_ASSERT(!winsocket->destroy_called);
   winsocket->destroy_called = true;
   bool should_destroy = check_destroyable(winsocket);
   gpr_mu_unlock(&winsocket->state_mu);
-  if (should_destroy) destroy(winsocket);
+  if (should_destroy) {
+    grpc_winsocket_finish(winsocket);
+  }
 }
 
 // Calling notify_on_read or write means either of two things:
@@ -140,19 +194,19 @@ void grpc_socket_notify_on_read(grpc_winsocket* socket, grpc_closure* closure) {
   socket_notify_on_iocp(socket, closure, &socket->read_info);
 }
 
-void grpc_socket_become_ready(grpc_winsocket* socket,
+bool grpc_socket_become_ready(grpc_winsocket* socket,
                               grpc_winsocket_callback_info* info) {
   GPR_ASSERT(!info->has_pending_iocp);
-  gpr_mu_lock(&socket->state_mu);
   if (info->closure) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, info->closure, absl::OkStatus());
+    // Only run the closure once at shutdown.
+    if (!info->closure_already_executed_at_shutdown) {
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, info->closure, absl::OkStatus());
+    }
     info->closure = NULL;
   } else {
     info->has_pending_iocp = 1;
   }
-  bool should_destroy = check_destroyable(socket);
-  gpr_mu_unlock(&socket->state_mu);
-  if (should_destroy) destroy(socket);
+  return check_destroyable(socket);
 }
 
 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;

data/src/core/lib/iomgr/socket_windows.h

@@ -61,6 +61,9 @@ typedef struct grpc_winsocket_callback_info {
   // The results of the overlapped operation.
   DWORD bytes_transferred;
   int wsa_error;
+  // Tracks whether the final closure has already been run when the socket is
+  // shut down. This allows closures to be run immediately upon socket shutdown.
+  bool closure_already_executed_at_shutdown = false;
 } grpc_winsocket_callback_info;
 
 // This is a wrapper to a Windows socket. A socket can have one outstanding
@@ -81,6 +84,7 @@ typedef struct grpc_winsocket {
 
   gpr_mu state_mu;
   bool shutdown_called;
+  bool shutdown_registered;
 
   // You can't add the same socket twice to the same IO Completion Port.
   // This prevents that.
@@ -109,8 +113,8 @@ void grpc_socket_notify_on_write(grpc_winsocket* winsocket,
 void grpc_socket_notify_on_read(grpc_winsocket* winsocket,
                                 grpc_closure* closure);
 
-void grpc_socket_become_ready(grpc_winsocket* winsocket,
-                              grpc_winsocket_callback_info* ci);
+bool grpc_socket_become_ready(grpc_winsocket* socket,
+                              grpc_winsocket_callback_info* info);
 
 // Returns true if this system can create AF_INET6 sockets bound to ::1.
 // The value is probed once, and cached for the life of the process.
@@ -120,6 +124,9 @@ void grpc_wsa_socket_flags_init();
 
 DWORD grpc_get_default_wsa_socket_flags();
 
+// Final cleanup operations on the socket prior to deletion.
+void grpc_winsocket_finish(grpc_winsocket*);
+
 #endif
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H

data/src/core/lib/iomgr/tcp_client_cfstream.cc

@@ -33,6 +33,7 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
@@ -40,6 +41,7 @@
 #include "src/core/lib/iomgr/endpoint_cfstream.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
+#include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/timer.h"
 
@@ -149,9 +151,14 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
 
 static int64_t CFStreamClientConnect(
     grpc_closure* closure, grpc_endpoint** ep,
-    grpc_pollset_set* interested_parties,
-    const grpc_event_engine::experimental::EndpointConfig& /*config*/,
+    grpc_pollset_set* /*interested_parties*/,
+    const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* resolved_addr, grpc_core::Timestamp deadline) {
+  if (grpc_event_engine::experimental::UseEventEngineClient()) {
+    return grpc_event_engine::experimental::event_engine_tcp_client_connect(
+        closure, ep, config, resolved_addr, deadline);
+  }
+
   auto addr_uri = grpc_sockaddr_to_uri(resolved_addr);
   if (!addr_uri.ok()) {
     grpc_error_handle error = GRPC_ERROR_CREATE(addr_uri.status().ToString());
@@ -198,7 +205,11 @@ static int64_t CFStreamClientConnect(
   return 0;
 }
 
-static bool CFStreamClientCancelConnect(int64_t /*connection_handle*/) {
+static bool CFStreamClientCancelConnect(int64_t connection_handle) {
+  if (grpc_event_engine::experimental::UseEventEngineClient()) {
+    return grpc_event_engine::experimental::
+        event_engine_tcp_client_cancel_connect(connection_handle);
+  }
   return false;
 }
 

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -16,13 +16,16 @@
 //
 //
 
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/atm.h>
+
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
+#include <grpc/event_engine/event_engine.h>
 #endif
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER
@@ -86,99 +89,118 @@ using ::grpc_event_engine::experimental::SliceBuffer;
 static grpc_error_handle CreateEventEngineListener(
     grpc_tcp_server* s, grpc_closure* shutdown_complete,
     const EndpointConfig& config, grpc_tcp_server** server) {
-  PosixEventEngineWithFdSupport::PosixAcceptCallback accept_cb =
-      [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
-          bool is_external, MemoryAllocator /*allocator*/,
-          SliceBuffer* pending_data) {
-        grpc_core::ApplicationCallbackExecCtx app_ctx;
-        grpc_core::ExecCtx exec_ctx;
-        grpc_tcp_server_acceptor* acceptor =
-            static_cast<grpc_tcp_server_acceptor*>(
-                gpr_malloc(sizeof(*acceptor)));
-        acceptor->from_server = s;
-        acceptor->port_index = -1;
-        acceptor->fd_index = -1;
-        if (!is_external) {
-          auto it = s->listen_fd_to_index_map.find(listener_fd);
-          if (it != s->listen_fd_to_index_map.end()) {
-            acceptor->port_index = std::get<0>(it->second);
-            acceptor->fd_index = std::get<1>(it->second);
+  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener;
+  if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+    PosixEventEngineWithFdSupport::PosixAcceptCallback accept_cb =
+        [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
+            bool is_external, MemoryAllocator /*allocator*/,
+            SliceBuffer* pending_data) {
+          grpc_core::ApplicationCallbackExecCtx app_ctx;
+          grpc_core::ExecCtx exec_ctx;
+          grpc_tcp_server_acceptor* acceptor =
+              static_cast<grpc_tcp_server_acceptor*>(
+                  gpr_malloc(sizeof(*acceptor)));
+          acceptor->from_server = s;
+          acceptor->port_index = -1;
+          acceptor->fd_index = -1;
+          if (!is_external) {
+            auto it = s->listen_fd_to_index_map.find(listener_fd);
+            if (it != s->listen_fd_to_index_map.end()) {
+              acceptor->port_index = std::get<0>(it->second);
+              acceptor->fd_index = std::get<1>(it->second);
+            }
+          } else {
+            // External connection handling.
+            grpc_resolved_address addr;
+            memset(&addr, 0, sizeof(addr));
+            addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
+            // Get the fd of the socket connected to peer.
+            int fd = reinterpret_cast<grpc_event_engine::experimental::
+                                          PosixEndpointWithFdSupport*>(ep.get())
+                         ->GetWrappedFd();
+            if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
+                            &(addr.len)) < 0) {
+              gpr_log(GPR_ERROR, "Failed getpeername: %s",
+                      grpc_core::StrError(errno).c_str());
+              close(fd);
+              return;
+            }
+            (void)grpc_set_socket_no_sigpipe_if_possible(fd);
+            auto addr_uri = grpc_sockaddr_to_uri(&addr);
+            if (!addr_uri.ok()) {
+              gpr_log(GPR_ERROR, "Invalid address: %s",
+                      addr_uri.status().ToString().c_str());
+              return;
+            }
+            if (grpc_tcp_trace.enabled()) {
+              gpr_log(GPR_INFO,
+                      "SERVER_CONNECT: incoming external connection: %s",
+                      addr_uri->c_str());
+            }
           }
-        } else {
-          // External connection handling.
-          grpc_resolved_address addr;
-          memset(&addr, 0, sizeof(addr));
-          addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-          // Get the fd of the socket connected to peer.
-          int fd =
-              reinterpret_cast<
-                  grpc_event_engine::experimental::PosixEndpointWithFdSupport*>(
-                  ep.get())
-                  ->GetWrappedFd();
-          if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
-                          &(addr.len)) < 0) {
-            gpr_log(GPR_ERROR, "Failed getpeername: %s",
-                    grpc_core::StrError(errno).c_str());
-            close(fd);
-            return;
-          }
-          (void)grpc_set_socket_no_sigpipe_if_possible(fd);
-          auto addr_uri = grpc_sockaddr_to_uri(&addr);
-          if (!addr_uri.ok()) {
-            gpr_log(GPR_ERROR, "Invalid address: %s",
-                    addr_uri.status().ToString().c_str());
-            return;
+          grpc_pollset* read_notifier_pollset =
+              (*(s->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
+                                   &s->next_pollset_to_assign, 1)) %
+                               s->pollsets->size()];
+          acceptor->external_connection = is_external;
+          acceptor->listener_fd = listener_fd;
+          grpc_byte_buffer* buf = nullptr;
+          if (pending_data != nullptr && pending_data->Length() > 0) {
+            buf = grpc_raw_byte_buffer_create(nullptr, 0);
+            grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
+                                   pending_data->c_slice_buffer());
+            pending_data->Clear();
           }
-          if (grpc_tcp_trace.enabled()) {
-            gpr_log(GPR_INFO,
-                    "SERVER_CONNECT: incoming external connection: %s",
-                    addr_uri->c_str());
-          }
-        }
-        grpc_pollset* read_notifier_pollset =
-            (*(s->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
-                                 &s->next_pollset_to_assign, 1)) %
-                             s->pollsets->size()];
-        acceptor->external_connection = is_external;
-        acceptor->listener_fd = listener_fd;
-        grpc_byte_buffer* buf = nullptr;
-        if (pending_data != nullptr && pending_data->Length() > 0) {
-          buf = grpc_raw_byte_buffer_create(nullptr, 0);
-          grpc_slice_buffer_swap(&buf->data.raw.slice_buffer,
-                                 pending_data->c_slice_buffer());
-          pending_data->Clear();
-        }
-        acceptor->pending_data = buf;
-        s->on_accept_cb(
-            s->on_accept_cb_arg,
-            grpc_event_engine::experimental::grpc_event_engine_endpoint_create(
-                std::move(ep)),
-            read_notifier_pollset, acceptor);
-      };
-  auto on_shutdown_complete_cb =
-      grpc_event_engine::experimental::GrpcClosureToStatusCallback(
-          shutdown_complete);
-  PosixEventEngineWithFdSupport* engine_ptr =
-      reinterpret_cast<PosixEventEngineWithFdSupport*>(
-          config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
-  // Keeps the engine alive for some tests that have not otherwise instantiated
-  // an EventEngine
-  std::shared_ptr<EventEngine> keeper;
-  if (engine_ptr == nullptr) {
-    keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
-    engine_ptr = reinterpret_cast<PosixEventEngineWithFdSupport*>(keeper.get());
-  }
-  auto listener = engine_ptr->CreatePosixListener(
-      std::move(accept_cb),
-      [s, shutdown_complete](absl::Status status) {
-        grpc_event_engine::experimental::RunEventEngineClosure(
-            shutdown_complete, absl_status_to_grpc_error(status));
-        delete s->fd_handler;
-        delete s;
-      },
-      config,
-      std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
-          s->memory_quota));
+          acceptor->pending_data = buf;
+          s->on_accept_cb(s->on_accept_cb_arg,
+                          grpc_event_engine::experimental::
+                              grpc_event_engine_endpoint_create(std::move(ep)),
+                          read_notifier_pollset, acceptor);
+        };
+    PosixEventEngineWithFdSupport* engine_ptr =
+        reinterpret_cast<PosixEventEngineWithFdSupport*>(
+            config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+    // Keeps the engine alive for some tests that have not otherwise
+    // instantiated an EventEngine
+    std::shared_ptr<EventEngine> keeper;
+    if (engine_ptr == nullptr) {
+      keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
+      engine_ptr =
+          reinterpret_cast<PosixEventEngineWithFdSupport*>(keeper.get());
+    }
+    listener = engine_ptr->CreatePosixListener(
+        std::move(accept_cb),
+        [s, shutdown_complete](absl::Status status) {
+          grpc_event_engine::experimental::RunEventEngineClosure(
+              shutdown_complete, absl_status_to_grpc_error(status));
+          delete s->fd_handler;
+          delete s;
+        },
+        config,
+        std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+            s->memory_quota));
+  } else {
+    EventEngine::Listener::AcceptCallback accept_cb =
+        [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
+          s->on_accept_cb(s->on_accept_cb_arg,
+                          grpc_event_engine::experimental::
+                              grpc_event_engine_endpoint_create(std::move(ep)),
+                          nullptr, nullptr);
+        };
+    auto ee = grpc_event_engine::experimental::GetDefaultEventEngine();
+    listener = ee->CreateListener(
+        std::move(accept_cb),
+        [s, ee, shutdown_complete](absl::Status status) {
+          GPR_ASSERT(gpr_atm_no_barrier_load(&s->refs.count) == 0);
+          grpc_event_engine::experimental::RunEventEngineClosure(
+              shutdown_complete, absl_status_to_grpc_error(status));
+          delete s->fd_handler;
+          delete s;
+        },
+        config,
+        std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+            s->memory_quota));
+  }
   if (!listener.ok()) {
     delete s;
     *server = nullptr;
@@ -565,16 +587,27 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
       return absl::UnknownError("Server already shutdown");
     }
     int fd_index = 0;
-    auto port = s->ee_listener->BindWithFd(
-        grpc_event_engine::experimental::CreateResolvedAddress(*addr),
-        [s, &fd_index](absl::StatusOr<int> listen_fd) {
-          if (!listen_fd.ok()) {
-            return;
-          }
-          GPR_DEBUG_ASSERT(*listen_fd > 0);
-          s->listen_fd_to_index_map.insert_or_assign(
-              *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
-        });
+    absl::StatusOr<int> port;
+    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+      port =
+          static_cast<
+              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+              s->ee_listener.get())
+              ->BindWithFd(
+                  grpc_event_engine::experimental::CreateResolvedAddress(*addr),
+                  [s, &fd_index](absl::StatusOr<int> listen_fd) {
+                    if (!listen_fd.ok()) {
+                      return;
+                    }
+                    GPR_DEBUG_ASSERT(*listen_fd > 0);
+                    s->listen_fd_to_index_map.insert_or_assign(
+                        *listen_fd,
+                        std::make_tuple(s->n_bind_ports, fd_index++));
+                  });
+    } else {
+      port = s->ee_listener->Bind(
+          grpc_event_engine::experimental::CreateResolvedAddress(*addr));
+    }
     if (port.ok()) {
       s->n_bind_ports++;
       *out_port = *port;
@@ -774,7 +807,11 @@ static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
   s->shutdown_listeners = true;
   if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    s->ee_listener->ShutdownListeningFds();
+    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+      static_cast<grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+          s->ee_listener.get())
+          ->ShutdownListeningFds();
+    }
   }
   /* shutdown all fd's */
   if (s->active_ports) {
@@ -804,15 +841,19 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
   // TODO(yangg) resolve duplicate code with on_read
   void Handle(int listener_fd, int fd, grpc_byte_buffer* buf) override {
     if (grpc_event_engine::experimental::UseEventEngineListener()) {
+      GPR_ASSERT(grpc_event_engine::experimental::EventEngineSupportsFd());
       grpc_event_engine::experimental::SliceBuffer pending_data;
       if (buf != nullptr) {
         pending_data =
             grpc_event_engine::experimental::SliceBuffer::TakeCSliceBuffer(
                 buf->data.raw.slice_buffer);
       }
-      GPR_ASSERT(GRPC_LOG_IF_ERROR("listener_handle_external_connection",
-                                   s_->ee_listener->HandleExternalConnection(
-                                       listener_fd, fd, &pending_data)));
+      GPR_ASSERT(GRPC_LOG_IF_ERROR(
+          "listener_handle_external_connection",
+          static_cast<
+              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
+              s_->ee_listener.get())
+              ->HandleExternalConnection(listener_fd, fd, &pending_data)));
       return;
     }
     grpc_pollset* read_notifier_pollset;

data/src/core/lib/iomgr/tcp_server_utils_posix.h

@@ -107,7 +107,7 @@ struct grpc_tcp_server {
   /* used when event engine based servers are enabled */
   int n_bind_ports = 0;
   absl::flat_hash_map<int, std::tuple<int, int>> listen_fd_to_index_map;
-  std::unique_ptr<grpc_event_engine::experimental::PosixListenerWithFdSupport>
+  std::unique_ptr<grpc_event_engine::experimental::EventEngine::Listener>
       ee_listener = nullptr;
   /* used to store a pre-allocated FD assigned to a socket */
   int pre_allocated_fd;

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -634,7 +634,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
       engine_ptr->poller(), std::move(accept_cb), std::move(on_shutdown),
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
           resource_quota->memory_quota()),
-      engine_ptr->shared_from_this(), engine_ptr->executor(), config);
+      engine_ptr->shared_from_this(), engine_ptr->thread_pool(), config);
   s->active_ports = -1;
   s->on_accept_cb = [](void* /* arg */, grpc_endpoint* /* ep */,
                        grpc_pollset* /* accepting_pollset */,