grpc 1.70.1 → 1.72.0

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

@@ -20,14 +20,19 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
+#include <memory>
+#include <utility>
+
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/socket_factory_posix.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/util/ref_counted_ptr.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
 #ifndef SO_ZEROCOPY
@@ -65,11 +70,13 @@ struct PosixTcpOptions {
   bool allow_reuse_port = false;
   RefCountedPtr<ResourceQuota> resource_quota;
   struct grpc_socket_mutator* socket_mutator = nullptr;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   PosixTcpOptions() = default;
   // Move ctor
   PosixTcpOptions(PosixTcpOptions&& other) noexcept {
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    event_engine = std::move(other.event_engine);
     CopyIntegerOptions(other);
   }
   // Move assignment
@@ -79,6 +86,7 @@ struct PosixTcpOptions {
     }
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    event_engine = std::move(other.event_engine);
     CopyIntegerOptions(other);
     return *this;
   }
@@ -88,6 +96,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    event_engine = other.event_engine;
     CopyIntegerOptions(other);
   }
   // Copy assignment
@@ -103,6 +112,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    event_engine = other.event_engine;
     CopyIntegerOptions(other);
     return *this;
   }

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

@@ -147,11 +147,10 @@ static int64_t CFStreamClientConnect(
     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);
-  }
-
+#if GRPC_IOS_EVENT_ENGINE_CLIENT
+  return grpc_event_engine::experimental::event_engine_tcp_client_connect(
+      closure, ep, config, resolved_addr, deadline);
+#endif
   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,10 +197,10 @@ static int64_t CFStreamClientConnect(
 }
 
 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);
-  }
+#if GRPC_IOS_EVENT_ENGINE_CLIENT
+  return grpc_event_engine::experimental::
+      event_engine_tcp_client_cancel_connect(connection_handle);
+#endif
   return false;
 }
 

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

@@ -51,6 +51,7 @@
 #include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/status_helper.h"
 #include "src/core/util/string.h"
 
 using ::grpc_event_engine::experimental::EndpointConfig;
@@ -154,6 +155,7 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   }
 }
 
+// Deprecated. This is internal-only, no new uses permitted.
 static grpc_endpoint* grpc_tcp_client_create_from_fd(
     grpc_fd* fd, const grpc_core::PosixTcpOptions& options,
     absl::string_view addr_str) {
@@ -163,7 +165,7 @@ static grpc_endpoint* grpc_tcp_client_create_from_fd(
 grpc_endpoint* grpc_tcp_create_from_fd(
     grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view addr_str) {
-  return grpc_tcp_create(fd, TcpOptionsFromEndpointConfig(config), addr_str);
+  return grpc_tcp_create(fd, config, addr_str);
 }
 
 static void on_writable(void* acp, grpc_error_handle error) {
@@ -265,14 +267,8 @@ finish:
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
   if (!error.ok()) {
-    std::string str;
-    bool ret = grpc_error_get_str(
-        error, grpc_core::StatusStrProperty::kDescription, &str);
-    CHECK(ret);
-    std::string description =
-        absl::StrCat("Failed to connect to remote host: ", str);
-    error = grpc_error_set_str(
-        error, grpc_core::StatusStrProperty::kDescription, description);
+    error =
+        grpc_core::AddMessagePrefix("Failed to connect to remote host", error);
   }
   if (done) {
     // This is safe even outside the lock, because "done", the sentinel, is
@@ -320,7 +316,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
-    const grpc_core::PosixTcpOptions& options,
+    const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep) {
   int err;
@@ -348,7 +344,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   if (err >= 0) {
     // Connection already succeeded. Return 0 to discourage any cancellation
     // attempts.
-    *ep = grpc_tcp_client_create_from_fd(fdobj, options, *addr_uri);
+    *ep = grpc_tcp_create_from_fd(fdobj, config, *addr_uri);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
     return 0;
   }
@@ -375,7 +371,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   ac->refs = 2;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,
                     grpc_schedule_on_exec_ctx);
-  ac->options = options;
+  ac->options = TcpOptionsFromEndpointConfig(config);
 
   GRPC_TRACE_LOG(tcp, INFO) << "CLIENT_CONNECT: " << ac->addr_str
                             << ": asynchronously connecting fd " << fdobj;
@@ -405,17 +401,17 @@ static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
         closure, ep, config, addr, deadline);
   }
   grpc_resolved_address mapped_addr;
-  grpc_core::PosixTcpOptions options(TcpOptionsFromEndpointConfig(config));
   int fd = -1;
   grpc_error_handle error;
   *ep = nullptr;
-  if ((error = grpc_tcp_client_prepare_fd(options, addr, &mapped_addr, &fd)) !=
+  if ((error = grpc_tcp_client_prepare_fd(TcpOptionsFromEndpointConfig(config),
+                                          addr, &mapped_addr, &fd)) !=
       absl::OkStatus()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
   }
   return grpc_tcp_client_create_from_prepared_fd(
-      interested_parties, closure, fd, options, &mapped_addr, deadline, ep);
+      interested_parties, closure, fd, config, &mapped_addr, deadline, ep);
 }
 
 static bool tcp_cancel_connect(int64_t connection_handle) {

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

@@ -65,7 +65,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 //
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
-    const grpc_core::PosixTcpOptions& options,
+    const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep);
 

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

@@ -16,20 +16,15 @@
 //
 //
 
-#include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
 #include <errno.h>
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
@@ -47,12 +42,21 @@
 #include <unistd.h>
 
 #include <algorithm>
+#include <optional>
 #include <unordered_map>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -60,7 +64,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -72,7 +75,6 @@
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
-#include "src/core/util/useful.h"
 
 #ifndef SOL_TCP
 #define SOL_TCP IPPROTO_TCP
@@ -734,13 +736,12 @@ static void finish_estimate(grpc_tcp* tcp) {
   tcp->bytes_read_this_round = 0;
 }
 
-static grpc_error_handle tcp_annotate_error(grpc_error_handle src_error,
-                                            grpc_tcp* tcp) {
-  return grpc_error_set_int(
-      grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kFd, tcp->fd),
-      // All tcp errors are marked with UNAVAILABLE so that application may
-      // choose to retry.
-      grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
+static grpc_error_handle tcp_annotate_error(grpc_error_handle src_error) {
+  return grpc_error_set_int(src_error,
+                            // All tcp errors are marked with UNAVAILABLE so
+                            // that application may choose to retry.
+                            grpc_core::StatusIntProperty::kRpcStatus,
+                            GRPC_STATUS_UNAVAILABLE);
 }
 
 static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error);
@@ -815,7 +816,7 @@ static void maybe_post_reclaimer(grpc_tcp* tcp)
     TCP_REF(tcp, "posted_reclaimer");
     tcp->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
-        [tcp](absl::optional<grpc_core::ReclamationSweep> sweep) {
+        [tcp](std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             perform_reclamation(tcp);
           }
@@ -968,12 +969,10 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
       // 0 read size ==> end of stream
       grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
       if (read_bytes == 0) {
-        *error = tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+        *error = tcp_annotate_error(absl::InternalError("Socket closed"));
       } else {
-        *error =
-            tcp_annotate_error(absl::InternalError(absl::StrCat(
-                                   "recvmsg:", grpc_core::StrError(errno))),
-                               tcp);
+        *error = tcp_annotate_error(absl::InternalError(
+            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
       }
       return true;
     }
@@ -1121,8 +1120,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
     tcp_trace_read(tcp, tcp_read_error);
   } else {
     if (!tcp->memory_owner.is_valid() && error.ok()) {
-      tcp_read_error =
-          tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+      tcp_read_error = tcp_annotate_error(absl::InternalError("Socket closed"));
     } else {
       tcp_read_error = error;
     }
@@ -1616,7 +1614,7 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
         record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
         return false;
       } else {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"), tcp);
+        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"));
         tcp_shutdown_buffer_list(tcp);
         return true;
       }
@@ -1726,7 +1724,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
         }
         return false;
       } else {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"), tcp);
+        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"));
         grpc_slice_buffer_reset_and_unref(tcp->outgoing_buffer);
         tcp_shutdown_buffer_list(tcp);
         return true;
@@ -1821,11 +1819,10 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
   DCHECK_EQ(tcp->current_zerocopy_send, nullptr);
 
   if (buf->length == 0) {
-    grpc_core::Closure::Run(
-        DEBUG_LOCATION, cb,
-        grpc_fd_is_shutdown(tcp->em_fd)
-            ? tcp_annotate_error(GRPC_ERROR_CREATE("EOF"), tcp)
-            : absl::OkStatus());
+    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
+                            grpc_fd_is_shutdown(tcp->em_fd)
+                                ? tcp_annotate_error(GRPC_ERROR_CREATE("EOF"))
+                                : absl::OkStatus());
     tcp_shutdown_buffer_list(tcp);
     return;
   }
@@ -1913,9 +1910,40 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
                                             tcp_get_fd,
                                             tcp_can_track_err};
 
+grpc_endpoint* grpc_tcp_create(
+    grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
+    absl::string_view peer_string) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    // Create an EventEngine endpoint when creating the transport.
+    auto* engine =
+        reinterpret_cast<grpc_event_engine::experimental::EventEngine*>(
+            config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+    if (engine == nullptr) {
+      grpc_core::Crash("EventEngine is not set");
+    }
+    auto* engine_supports_fd = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::EventEngineSupportsFdExtension>(
+        engine);
+    if (engine_supports_fd == nullptr) {
+      grpc_core::Crash("EventEngine does not support fds");
+    }
+    int wrapped_fd;
+    grpc_fd_orphan(fd, nullptr, &wrapped_fd, "Hand fd over to EventEngine");
+    return grpc_event_engine_endpoint_create(
+        engine_supports_fd->CreateEndpointFromFd(wrapped_fd, config));
+  }
+  return grpc_tcp_create(fd, TcpOptionsFromEndpointConfig(config), peer_string);
+}
+
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_core::PosixTcpOptions& options,
                                absl::string_view peer_string) {
+  CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
+      << "This function must not be called when the pollset_alternative "
+         "experiment is enabled. This is a bug.";
+  CHECK(!grpc_core::IsEventEngineForAllOtherEndpointsEnabled())
+      << "The event_engine_for_all_other_endpoints experiment should prevent "
+         "this method from being called. This is a bug.";
   grpc_tcp* tcp = new grpc_tcp(options);
   tcp->base.vtable = &vtable;
   tcp->peer_string = std::string(peer_string);

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

@@ -29,6 +29,7 @@
 // otherwise specified.
 //
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -38,12 +39,19 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
-/// Create a tcp endpoint given a file descriptor and a read slice size.
-/// Takes ownership of \a fd. Takes ownership of the \a slice_allocator.
+/// [DEPRECATED] Create a tcp endpoint given a file descriptor and a read slice
+/// size. Takes ownership of \a fd. This is a legacy API, intended for iomgr use
+/// only, it will not support EventEngine.
 grpc_endpoint* grpc_tcp_create(grpc_fd* fd,
                                const grpc_core::PosixTcpOptions& options,
                                absl::string_view peer_string);
 
+/// Create a tcp endpoint given a file descriptor and a read slice size.
+/// Takes ownership of \a fd.
+grpc_endpoint* grpc_tcp_create(
+    grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
+    absl::string_view peer_string);
+
 /// Return the tcp endpoint's fd, or -1 if this is not available. Does not
 /// release the fd. Requires: \a ep must be a tcp endpoint.
 int grpc_tcp_fd(grpc_endpoint* ep);

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

@@ -16,6 +16,7 @@
 //
 //
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 
@@ -126,7 +127,6 @@ static grpc_error_handle CreateEventEngineListener(
         [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_pollset* read_notifier_pollset;
           grpc_tcp_server_acceptor* acceptor;
@@ -213,7 +213,6 @@ static grpc_error_handle CreateEventEngineListener(
   } else {
     EventEngine::Listener::AcceptCallback accept_cb =
         [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
           void* cb_arg;
           {
@@ -477,6 +476,7 @@ static void on_read(void* arg, grpc_error_handle err) {
     acceptor->port_index = sp->port_index;
     acceptor->fd_index = sp->fd_index;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
         grpc_tcp_create(fdobj, sp->server->options, addr_uri.value()),
@@ -636,7 +636,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
             }
             DCHECK_GT(*listen_fd, 0);
             s->listen_fd_to_index_map.insert_or_assign(
-                *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
+                *listen_fd, std::tuple(s->n_bind_ports, fd_index++));
           });
     } else {
       port = s->ee_listener->Bind(
@@ -928,7 +928,13 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->fd_index = -1;
     acceptor->external_connection = true;
     acceptor->listener_fd = listener_fd;
-    acceptor->pending_data = buf;
+    if (buf != nullptr && buf->data.raw.slice_buffer.length > 0) {
+      acceptor->pending_data = grpc_raw_byte_buffer_create(nullptr, 0);
+      grpc_slice_buffer_swap(&acceptor->pending_data->data.raw.slice_buffer,
+                             &buf->data.raw.slice_buffer);
+    } else {
+      acceptor->pending_data = nullptr;
+    }
     s_->on_accept_cb(s_->on_accept_cb_arg,
                      grpc_tcp_create(fdobj, s_->options, addr_uri.value()),
                      read_notifier_pollset, acceptor);

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

@@ -273,10 +273,7 @@ error:
   if (fd >= 0) {
     close(fd);
   }
-  grpc_error_handle ret = grpc_error_set_int(
-      GRPC_ERROR_CREATE_REFERENCING("Unable to configure socket", &err, 1),
-      grpc_core::StatusIntProperty::kFd, fd);
-  return ret;
+  return GRPC_ERROR_CREATE_REFERENCING("Unable to configure socket", &err, 1);
 }
 
 #endif  // GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON

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

@@ -70,8 +70,6 @@ using ::grpc_event_engine::experimental::MemoryAllocator;
 using ::grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
 using ::grpc_event_engine::experimental::ResolvedAddressSetPort;
 using ::grpc_event_engine::experimental::RunEventEngineClosure;
-using ::grpc_event_engine::experimental::WindowsEventEngine;
-using ::grpc_event_engine::experimental::WindowsEventEngineListener;
 }  // namespace
 
 // one listening port
@@ -129,7 +127,7 @@ struct grpc_tcp_server {
   grpc_closure* shutdown_complete;
 
   // used for the EventEngine shim
-  WindowsEventEngineListener* ee_listener;
+  std::unique_ptr<EventEngine::Listener> ee_listener;
 };
 
 // TODO(hork): This may be refactored to share with posix engine and event
@@ -179,6 +177,7 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
   s->shutdown_complete = shutdown_complete;
+  new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   *server = s;
   return absl::OkStatus();
 }
@@ -197,6 +196,7 @@ static void destroy_server(void* arg, grpc_error_handle /* error */) {
     unlink_if_unix_domain_socket(&sp->resolved_addr);
     gpr_free(sp);
   }
+  std::destroy_at(&s->ee_listener);
   gpr_mu_destroy(&s->mu);
   gpr_free(s);
 }
@@ -292,9 +292,8 @@ static grpc_error_handle prepare_socket(SOCKET sock,
 
 failure:
   CHECK(!error.ok());
-  error = grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING(
-                                 "Failed to prepare server socket", &error, 1),
-                             grpc_core::StatusIntProperty::kFd, (intptr_t)sock);
+  error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
+                                        &error, 1);
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -445,6 +444,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
     acceptor->port_index = sp->port_index;
     acceptor->fd_index = 0;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     sp->server->on_accept_cb(sp->server->on_accept_cb_arg, ep, NULL, acceptor);
   }
   // As we were notified from the IOCP of one and exactly one accept,
@@ -641,16 +641,12 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
                                              grpc_tcp_server_cb on_accept_cb,
                                              void* on_accept_cb_arg,
                                              grpc_tcp_server** server) {
-  // On Windows, the event_engine_listener experiment only supports the
-  // default engine
-  WindowsEventEngine* engine_ptr = reinterpret_cast<WindowsEventEngine*>(
-      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
+  new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
-    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)));
@@ -658,6 +654,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
     acceptor->port_index = -1;
     acceptor->fd_index = -1;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     on_accept_cb(on_accept_cb_arg,
                  grpc_event_engine_endpoint_create(std::move(endpoint)),
                  nullptr, acceptor);
@@ -674,11 +671,18 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   }
   gpr_ref_init(&s->refs, 1);
   gpr_mu_init(&s->mu);
-  s->ee_listener = new WindowsEventEngineListener(
-      engine_ptr->poller(), std::move(accept_cb), std::move(on_shutdown),
+  EventEngine* engine = reinterpret_cast<EventEngine*>(
+      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+  CHECK_NE(engine, nullptr);
+  auto listener = engine->CreateListener(
+      std::move(accept_cb), std::move(on_shutdown), config,
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
-          resource_quota->memory_quota()),
-      engine_ptr->shared_from_this(), engine_ptr->thread_pool(), config);
+          resource_quota->memory_quota()));
+  GRPC_RETURN_IF_ERROR(listener.status());
+  CHECK_NE(listener->get(), nullptr);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::" << engine << ": created Listener::" << listener->get();
+  s->ee_listener = std::move(*listener);
   s->active_ports = -1;
   s->on_accept_cb = [](void* /* arg */, grpc_endpoint* /* ep */,
                        grpc_pollset* /* accepting_pollset */,
@@ -734,7 +738,13 @@ static grpc_tcp_server* event_engine_ref(grpc_tcp_server* s) {
 }
 
 static void event_engine_shutdown_listeners(grpc_tcp_server* s) {
-  s->ee_listener->ShutdownListeners();
+  auto* iomgr_compatible_listener =
+      grpc_event_engine::experimental::QueryExtension<
+          grpc_event_engine::experimental::IomgrCompatibleListener>(
+          s->ee_listener.get());
+  if (iomgr_compatible_listener != nullptr) {
+    iomgr_compatible_listener->Shutdown();
+  }
 }
 
 static void event_engine_unref(grpc_tcp_server* s) {
@@ -744,7 +754,7 @@ static void event_engine_unref(grpc_tcp_server* s) {
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
     gpr_mu_unlock(&s->mu);
     gpr_mu_destroy(&s->mu);
-    delete s->ee_listener;
+    std::destroy_at(&s->ee_listener);
     gpr_free(s);
   }
 }

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

@@ -97,14 +97,6 @@ void grpc_timer_manager_tick() {
 }
 
 static void run_some_timers() {
-  // In the case of timers, the ExecCtx for the thread is declared
-  // in the timer thread itself, but this is the point where we
-  // could start seeing application-level callbacks. No need to
-  // create a new ExecCtx, though, since there already is one and it is
-  // flushed (but not destructed) in this function itself
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx(
-      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
-
   // if there's something to execute...
   gpr_mu_lock(&g_mu);
   // remove a waiter from the pool, and start another thread if necessary
@@ -241,7 +233,7 @@ static void timer_main_loop() {
         GRPC_TRACE_LOG(timer_check, INFO)
             << "timers not checked: expect another thread to";
         next = grpc_core::Timestamp::InfFuture();
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
         if (!wait_until(next)) {
           return;

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

@@ -43,9 +43,17 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (!err.ok()) return err;
+  if (!err.ok()) {
+    close(pipefd[0]);
+    close(pipefd[1]);
+    return err;
+  }
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (!err.ok()) return err;
+  if (!err.ok()) {
+    close(pipefd[0]);
+    close(pipefd[1]);
+    return err;
+  }
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return absl::OkStatus();