grpc 1.71.0 → 1.75.0

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

@@ -16,21 +16,15 @@
 //
 //
 
-#include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
-#include <optional>
-
-#include "absl/base/thread_annotations.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.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>
@@ -48,20 +42,27 @@
 #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"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
-#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"
@@ -73,7 +74,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
@@ -557,7 +557,8 @@ struct grpc_tcp {
 
 struct backup_poller {
   gpr_mu* pollset_mu;
-  grpc_closure run_poller;
+  grpc_closure done_poller;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine;
 };
 
 void LogCommonIOErrors(absl::string_view prefix, int error_no) {
@@ -618,11 +619,11 @@ static void done_poller(void* bp, grpc_error_handle /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
   GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " destroy";
   grpc_pollset_destroy(BACKUP_POLLER_POLLSET(p));
+  p->engine.reset();
   gpr_free(p);
 }
 
-static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
-  backup_poller* p = static_cast<backup_poller*>(bp);
+static void run_poller(backup_poller* p) {
   GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " run";
   gpr_mu_lock(p->pollset_mu);
   grpc_core::Timestamp deadline =
@@ -640,14 +641,15 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " shutdown";
     grpc_pollset_shutdown(BACKUP_POLLER_POLLSET(p),
-                          GRPC_CLOSURE_INIT(&p->run_poller, done_poller, p,
+                          GRPC_CLOSURE_INIT(&p->done_poller, done_poller, p,
                                             grpc_schedule_on_exec_ctx));
   } else {
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " reschedule";
-    grpc_core::Executor::Run(&p->run_poller, absl::OkStatus(),
-                             grpc_core::ExecutorType::DEFAULT,
-                             grpc_core::ExecutorJobType::LONG);
+    p->engine->Run([p]() {
+      grpc_core::ExecCtx exec_ctx;
+      run_poller(p);
+    });
   }
 }
 
@@ -678,14 +680,15 @@ static void cover_self(grpc_tcp* tcp) {
     g_uncovered_notifications_pending = 2;
     p = static_cast<backup_poller*>(
         gpr_zalloc(sizeof(*p) + grpc_pollset_size()));
+    p->engine = grpc_event_engine::experimental::GetDefaultEventEngine();
     g_backup_poller = p;
     grpc_pollset_init(BACKUP_POLLER_POLLSET(p), &p->pollset_mu);
     g_backup_poller_mu->Unlock();
     GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " create";
-    grpc_core::Executor::Run(
-        GRPC_CLOSURE_INIT(&p->run_poller, run_poller, p, nullptr),
-        absl::OkStatus(), grpc_core::ExecutorType::DEFAULT,
-        grpc_core::ExecutorJobType::LONG);
+    p->engine->Run([p]() {
+      grpc_core::ExecCtx exec_ctx;
+      run_poller(p);
+    });
   } else {
     old_count = g_uncovered_notifications_pending++;
     p = g_backup_poller;
@@ -735,13 +738,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);
@@ -892,7 +894,7 @@ static void update_rcvlowat(grpc_tcp* tcp)
 #define MAX_READ_IOVEC 64
 static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
-  GRPC_LATENT_SEE_INNER_SCOPE("tcp_do_read");
+  GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("tcp_do_read");
   GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " do_read";
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];
@@ -969,12 +971,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;
     }
@@ -1122,8 +1122,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;
     }
@@ -1185,7 +1184,7 @@ static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
 // of bytes sent.
 ssize_t tcp_send(int fd, const struct msghdr* msg, int* saved_errno,
                  int additional_flags = 0) {
-  GRPC_LATENT_SEE_INNER_SCOPE("tcp_send");
+  GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("tcp_send");
   ssize_t sent_length;
   do {
     // TODO(klempner): Cork if this is a partial write
@@ -1376,7 +1375,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
 /// messages from the queue.
 ///
 static bool process_errors(grpc_tcp* tcp) {
-  GRPC_LATENT_SEE_INNER_SCOPE("process_errors");
+  GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("process_errors");
   bool processed_err = false;
   struct iovec iov;
   iov.iov_base = nullptr;
@@ -1617,7 +1616,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;
       }
@@ -1727,7 +1726,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;
@@ -1796,8 +1795,9 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
   }
 }
 
-static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
-                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
+static void tcp_write(
+    grpc_endpoint* ep, grpc_slice_buffer* buf, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   grpc_error_handle error;
   TcpZerocopySendRecord* zerocopy_send_record = nullptr;
@@ -1822,11 +1822,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;
   }
@@ -1837,8 +1836,9 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     tcp->outgoing_buffer = buf;
     tcp->outgoing_byte_idx = 0;
   }
-  tcp->outgoing_buffer_arg = arg;
-  if (arg) {
+  tcp->outgoing_buffer_arg =
+      args.TakeDeprecatedAndDiscouragedGoogleSpecificPointer();
+  if (tcp->outgoing_buffer_arg) {
     CHECK(grpc_event_engine_can_track_errors());
   }
 
@@ -1914,9 +1914,44 @@ 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() &&
+      !grpc_event_engine::experimental::
+          EventEngineExperimentDisabledForPython()) {
+    // 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() ||
+      grpc_event_engine::experimental::EventEngineExperimentDisabledForPython())
+      << "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>
 
@@ -475,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()),
@@ -926,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
@@ -147,15 +145,27 @@ void unlink_if_unix_domain_socket(const grpc_resolved_address* resolved_addr) {
   if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
     return;
   }
+  // Convert UTF-8 path to Unicode.
+  std::wstring wide_path;
+  int needed = MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, NULL, 0);
+  if (needed <= 0) {
+    return;
+  }
+  wide_path.resize(needed, L'\0');
+  if (MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, wide_path.data(),
+                          needed) == 0) {
+    // Failed to convert UTF-8 path to wide char.
+    return;
+  }
   // For windows we need to remove the file instead of unlink.
-  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  DWORD attr = ::GetFileAttributesW(wide_path.data());
   if (attr == INVALID_FILE_ATTRIBUTES) {
     return;
   }
   if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
     return;
   }
-  ::DeleteFileA(un->sun_path);
+  ::DeleteFileW(wide_path.data());
 #else
   (void)resolved_addr;
 #endif
@@ -179,6 +189,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 +208,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 +304,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 +456,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,11 +653,8 @@ 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,
@@ -657,6 +666,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);
@@ -673,11 +683,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 */,
@@ -733,7 +750,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) {
@@ -743,7 +766,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/tcp_windows.cc

@@ -323,8 +323,9 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 // Initiates a write.
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* /* arg */,
-                      int /* max_frame_size */) {
+                      grpc_closure* cb,
+                      grpc_event_engine::experimental::EventEngine::Endpoint::
+                          WriteArgs /*args*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;

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

data/src/core/lib/promise/activity.h

@@ -122,6 +122,7 @@ class Waker {
   }
 
   std::string DebugString() const {
+    if (is_unwakeable()) return "<unwakeable>";
     return absl::StrFormat("Waker{%p, %d}", wakeable_and_arg_.wakeable,
                            wakeable_and_arg_.wakeup_mask);
   }
@@ -564,7 +565,7 @@ class PromiseActivity final
   }
 
   void WakeupAsync(WakeupMask) final {
-    GRPC_LATENT_SEE_INNER_SCOPE("PromiseActivity::WakeupAsync");
+    GRPC_LATENT_SEE_SCOPE("PromiseActivity::WakeupAsync");
     wakeup_flow_.Begin(GRPC_LATENT_SEE_METADATA("Activity::Wakeup"));
     if (!wakeup_scheduled_.exchange(true, std::memory_order_acq_rel)) {
       // Can't safely run, so ask to run later.
@@ -589,7 +590,7 @@ class PromiseActivity final
   // In response to Wakeup, run the Promise state machine again until it
   // settles. Then check for completion, and if we have completed, call on_done.
   void Step() ABSL_LOCKS_EXCLUDED(mu()) {
-    GRPC_LATENT_SEE_PARENT_SCOPE("PromiseActivity::Step");
+    GRPC_LATENT_SEE_SCOPE("PromiseActivity::Step");
     wakeup_flow_.End();
     // Poll the promise until things settle out under a lock.
     mu()->Lock();

data/src/core/lib/promise/all_ok.h

@@ -30,6 +30,37 @@
 #include "src/core/lib/promise/status_flag.h"
 
 namespace grpc_core {
+// AllOk promise combinator.
+//
+// Input:
+// 1. Two or more promises.
+// 2. All promises MUST return either a Poll<StatusFlag> or Poll<absl::Status>.
+//
+// Return:
+// 1. The return type of AllOk<Result, Promises...> is Poll<Result>, where
+// Result is either StatusFlag or absl::Status.
+// 2. If Result is StatusFlag, then all the promises MUST return
+// Poll<StatusFlag>.
+// 3. If Result is absl::Status, then the promises may return either
+// Poll<StatusFlag> or Poll<absl::Status>.
+// For further understanding of points 2 and 3, refer the WithMixedTypes* tests
+// in all_ok_test.cc.
+//
+// Polling the AllOk combinator works in the following way :
+// Polling this AllOk combinator will make the pending promises run
+// serially, in order and on the same thread.
+// Each promise being executed either returns a status (StatusFlag or
+// absl::Status) or Pending{}. Each subsequent execution of the AllOk will only
+// execute the input promises which are still pending. This mechanism ensures
+// that no promise is executed after it resolves, which is an essential
+// requirement. If all the promises have finished running successfully, the
+// AllOk combinator will return a success status. If there is at least one
+// promise that has returned Pending{}, the AllOk combinator will return
+// Pending{}.
+//
+// The execution of promises in the AllOk combinator will stop if any one
+// promise returns a failure status. This failure status is returned by the
+// AllOk combinator.
 
 namespace promise_detail {