grpc 1.52.2 → 1.53.0.pre2

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

@@ -18,6 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_CLIENT
@@ -35,9 +36,12 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/ev_posix.h"
+#include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -400,6 +404,10 @@ static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                            const EndpointConfig& config,
                            const grpc_resolved_address* addr,
                            grpc_core::Timestamp deadline) {
+  if (grpc_event_engine::experimental::UseEventEngineClient()) {
+    return grpc_event_engine::experimental::event_engine_tcp_client_connect(
+        closure, ep, config, addr, deadline);
+  }
   grpc_resolved_address mapped_addr;
   grpc_core::PosixTcpOptions options(TcpOptionsFromEndpointConfig(config));
   int fd = -1;
@@ -415,6 +423,10 @@ static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
 }
 
 static bool tcp_cancel_connect(int64_t connection_handle) {
+  if (grpc_event_engine::experimental::UseEventEngineClient()) {
+    return grpc_event_engine::experimental::
+        event_engine_tcp_client_cancel_connect(connection_handle);
+  }
   if (connection_handle <= 0) {
     return false;
   }

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
-#define GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
+#define GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
 
 #include <grpc/support/port_platform.h>
 
@@ -69,4 +69,4 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep);
 
-#endif  // GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H

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

@@ -31,7 +31,9 @@
 #include <grpc/support/log_windows.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/iomgr/event_engine_shims/tcp_client.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
@@ -126,6 +128,10 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
                            const EndpointConfig& config,
                            const grpc_resolved_address* addr,
                            grpc_core::Timestamp deadline) {
+  if (grpc_event_engine::experimental::UseEventEngineClient()) {
+    return grpc_event_engine::experimental::event_engine_tcp_client_connect(
+        on_done, endpoint, config, addr, deadline);
+  }
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
   int status;
@@ -232,7 +238,13 @@ failure:
   return 0;
 }
 
-static bool tcp_cancel_connect(int64_t /*connection_handle*/) { return false; }
+static bool tcp_cancel_connect(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;
+}
 
 grpc_tcp_client_vtable grpc_windows_tcp_client_vtable = {tcp_connect,
                                                          tcp_cancel_connect};

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

@@ -61,6 +61,7 @@
 #include "src/core/lib/gprpp/sync.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"
@@ -835,17 +836,18 @@ static void update_rcvlowat(grpc_tcp* tcp)
 
   int remaining = std::min(static_cast<int>(tcp->incoming_buffer->length),
                            tcp->min_progress_size);
+
   remaining = std::min(remaining, kRcvLowatMax);
 
   // Setting SO_RCVLOWAT for small quantities does not save on CPU.
-  if (remaining < kRcvLowatThreshold) {
+  if (remaining < 2 * kRcvLowatThreshold) {
     remaining = 0;
   }
 
-  // If zerocopy is off, wake shortly before the full RPC is here. More can
-  // show up partway through recvmsg() since it takes a while to copy data.
-  // So an early wakeup aids latency.
-  if (!tcp->tcp_zerocopy_send_ctx.enabled() && remaining > 0) {
+  // Decrement remaining by kRcvLowatThreshold. This would have the effect of
+  // waking up a little early. It would help with latency because some bytes
+  // may arrive while we execute the recvmsg syscall after waking up.
+  if (remaining > 0) {
     remaining -= kRcvLowatThreshold;
   }
 
@@ -1044,66 +1046,38 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
 
 static void maybe_make_read_slices(grpc_tcp* tcp)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
-  if (grpc_core::IsTcpReadChunksEnabled()) {
-    static const int kBigAlloc = 64 * 1024;
-    static const int kSmallAlloc = 8 * 1024;
-    if (tcp->incoming_buffer->length <
-        static_cast<size_t>(tcp->min_progress_size)) {
-      size_t allocate_length = tcp->min_progress_size;
-      const size_t target_length = static_cast<size_t>(tcp->target_length);
-      // If memory pressure is low and we think there will be more than
-      // min_progress_size bytes to read, allocate a bit more.
-      const bool low_memory_pressure =
-          tcp->memory_owner.GetPressureInfo().pressure_control_value < 0.8;
-      if (low_memory_pressure && target_length > allocate_length) {
-        allocate_length = target_length;
-      }
-      int extra_wanted =
-          allocate_length - static_cast<int>(tcp->incoming_buffer->length);
-      if (extra_wanted >=
-          (low_memory_pressure ? kSmallAlloc * 3 / 2 : kBigAlloc)) {
-        while (extra_wanted > 0) {
-          extra_wanted -= kBigAlloc;
-          grpc_slice_buffer_add_indexed(tcp->incoming_buffer,
-                                        tcp->memory_owner.MakeSlice(kBigAlloc));
-          grpc_core::global_stats().IncrementTcpReadAlloc64k();
-        }
-      } else {
-        while (extra_wanted > 0) {
-          extra_wanted -= kSmallAlloc;
-          grpc_slice_buffer_add_indexed(
-              tcp->incoming_buffer, tcp->memory_owner.MakeSlice(kSmallAlloc));
-          grpc_core::global_stats().IncrementTcpReadAlloc8k();
-        }
-      }
-      maybe_post_reclaimer(tcp);
+  static const int kBigAlloc = 64 * 1024;
+  static const int kSmallAlloc = 8 * 1024;
+  if (tcp->incoming_buffer->length <
+      static_cast<size_t>(tcp->min_progress_size)) {
+    size_t allocate_length = tcp->min_progress_size;
+    const size_t target_length = static_cast<size_t>(tcp->target_length);
+    // If memory pressure is low and we think there will be more than
+    // min_progress_size bytes to read, allocate a bit more.
+    const bool low_memory_pressure =
+        tcp->memory_owner.GetPressureInfo().pressure_control_value < 0.8;
+    if (low_memory_pressure && target_length > allocate_length) {
+      allocate_length = target_length;
     }
-  } else {
-    if (tcp->incoming_buffer->length <
-            static_cast<size_t>(tcp->min_progress_size) &&
-        tcp->incoming_buffer->count < MAX_READ_IOVEC) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-        gpr_log(GPR_INFO,
-                "TCP:%p alloc_slices; min_chunk=%d max_chunk=%d target=%lf "
-                "buf_len=%" PRIdPTR,
-                tcp, tcp->min_read_chunk_size, tcp->max_read_chunk_size,
-                tcp->target_length, tcp->incoming_buffer->length);
+    int extra_wanted =
+        allocate_length - static_cast<int>(tcp->incoming_buffer->length);
+    if (extra_wanted >=
+        (low_memory_pressure ? kSmallAlloc * 3 / 2 : kBigAlloc)) {
+      while (extra_wanted > 0) {
+        extra_wanted -= kBigAlloc;
+        grpc_slice_buffer_add_indexed(tcp->incoming_buffer,
+                                      tcp->memory_owner.MakeSlice(kBigAlloc));
+        grpc_core::global_stats().IncrementTcpReadAlloc64k();
+      }
+    } else {
+      while (extra_wanted > 0) {
+        extra_wanted -= kSmallAlloc;
+        grpc_slice_buffer_add_indexed(tcp->incoming_buffer,
+                                      tcp->memory_owner.MakeSlice(kSmallAlloc));
+        grpc_core::global_stats().IncrementTcpReadAlloc8k();
       }
-      int target_length = std::max(static_cast<int>(tcp->target_length),
-                                   tcp->min_progress_size);
-      int extra_wanted =
-          target_length - static_cast<int>(tcp->incoming_buffer->length);
-      int min_read_chunk_size =
-          std::max(tcp->min_read_chunk_size, tcp->min_progress_size);
-      int max_read_chunk_size =
-          std::max(tcp->max_read_chunk_size, tcp->min_progress_size);
-      grpc_slice slice = tcp->memory_owner.MakeSlice(grpc_core::MemoryRequest(
-          min_read_chunk_size,
-          grpc_core::Clamp(extra_wanted, min_read_chunk_size,
-                           max_read_chunk_size)));
-      grpc_slice_buffer_add_indexed(tcp->incoming_buffer, slice);
-      maybe_post_reclaimer(tcp);
     }
+    maybe_post_reclaimer(tcp);
   }
 }
 
@@ -1118,9 +1092,11 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   if (GPR_LIKELY(error.ok())) {
     maybe_make_read_slices(tcp);
     if (!tcp_do_read(tcp, &tcp_read_error)) {
-      // We've consumed the edge, request a new one
+      // Maybe update rcv lowat value based on the number of bytes read in this
+      // round.
       update_rcvlowat(tcp);
       tcp->read_mu.Unlock();
+      // We've consumed the edge, request a new one
       notify_on_read(tcp);
       return;
     }
@@ -1130,6 +1106,12 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
     grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
     grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   }
+  // Update rcv lowat needs to be called at the end of the current read
+  // operation to ensure the right SO_RCVLOWAT value is set for the next read.
+  // Otherwise the next endpoint read operation may get stuck indefinitely
+  // because the previously set rcv lowat value will persist and the socket may
+  // erroneously considered to not be ready for read.
+  update_rcvlowat(tcp);
   grpc_closure* cb = tcp->read_cb;
   tcp->read_cb = nullptr;
   tcp->incoming_buffer = nullptr;
@@ -1152,14 +1134,12 @@ static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
   grpc_slice_buffer_swap(incoming_buffer, &tcp->last_read_buffer);
   TCP_REF(tcp, "read");
   if (tcp->is_first_read) {
-    update_rcvlowat(tcp);
     tcp->read_mu.Unlock();
     // Endpoint read called for the very first time. Register read callback with
     // the polling engine
     tcp->is_first_read = false;
     notify_on_read(tcp);
   } else if (!urgent && tcp->inq == 0) {
-    update_rcvlowat(tcp);
     tcp->read_mu.Unlock();
     // Upper layer asked to read more but we know there is no pending data
     // to read from previous reads. So, wait for POLLIN.
@@ -2037,6 +2017,10 @@ int grpc_tcp_fd(grpc_endpoint* ep) {
 
 void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
                                      grpc_closure* done) {
+  if (grpc_event_engine::experimental::grpc_is_event_engine_endpoint(ep)) {
+    return grpc_event_engine::experimental::
+        grpc_event_engine_endpoint_destroy_and_release_fd(ep, fd, done);
+  }
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   GPR_ASSERT(ep->vtable == &vtable);
   tcp->release_fd = fd;

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_TCP_POSIX_H
-#define GRPC_CORE_LIB_IOMGR_TCP_POSIX_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_POSIX_H
+#define GRPC_SRC_CORE_LIB_IOMGR_TCP_POSIX_H
 //
 // Low level TCP "bottom half" implementation, for use by transports built on
 // top of a TCP connection.
@@ -64,4 +64,4 @@ void grpc_tcp_posix_shutdown();
 
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-#endif  // GRPC_CORE_LIB_IOMGR_TCP_POSIX_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_POSIX_H

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_TCP_SERVER_H
-#define GRPC_CORE_LIB_IOMGR_TCP_SERVER_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_H
+#define GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -153,4 +153,4 @@ void grpc_tcp_server_global_init();
 
 void grpc_set_tcp_server_impl(grpc_tcp_server_vtable* impl);
 
-#endif  // GRPC_CORE_LIB_IOMGR_TCP_SERVER_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_H

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

@@ -43,6 +43,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
+#include <grpc/byte_buffer.h>
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -50,10 +51,16 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/shim.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/strerror.h"
+#include "src/core/lib/iomgr/event_engine_shims/closure.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -64,10 +71,133 @@
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/transport/error_utils.h"
 
 static std::atomic<int64_t> num_dropped_connections{0};
 
 using ::grpc_event_engine::experimental::EndpointConfig;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::MemoryAllocator;
+using ::grpc_event_engine::experimental::PosixEventEngineWithFdSupport;
+using ::grpc_event_engine::experimental::SliceBuffer;
+
+class MemoryAllocatorFactoryWrapper
+    : public grpc_event_engine::experimental::MemoryAllocatorFactory {
+ public:
+  explicit MemoryAllocatorFactoryWrapper(
+      grpc_core::MemoryQuotaRefPtr memory_quota)
+      : memory_quota_(std::move(memory_quota)) {}
+
+  MemoryAllocator CreateMemoryAllocator(absl::string_view name) override {
+    return memory_quota_->CreateMemoryAllocator(name);
+  }
+
+ private:
+  grpc_core::MemoryQuotaRefPtr memory_quota_;
+};
+
+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);
+          }
+        } 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());
+          }
+        }
+        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<MemoryAllocatorFactoryWrapper>(s->memory_quota));
+  if (!listener.ok()) {
+    delete s;
+    *server = nullptr;
+    return listener.status();
+  }
+  s->ee_listener = std::move(*listener);
+  return absl::OkStatus();
+}
 
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
                                            const EndpointConfig& config,
@@ -92,7 +222,11 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->shutdown = false;
   s->shutdown_starting.head = nullptr;
   s->shutdown_starting.tail = nullptr;
-  s->shutdown_complete = shutdown_complete;
+  if (!grpc_event_engine::experimental::UseEventEngineListener()) {
+    s->shutdown_complete = shutdown_complete;
+  } else {
+    s->shutdown_complete = nullptr;
+  }
   s->on_accept_cb = on_accept_cb;
   s->on_accept_cb_arg = on_accept_cb_arg;
   s->head = nullptr;
@@ -105,7 +239,13 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->memory_quota = s->options.resource_quota->memory_quota();
   s->pre_allocated_fd = -1;
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
+  s->n_bind_ports = 0;
+  new (&s->listen_fd_to_index_map)
+      absl::flat_hash_map<int, std::tuple<int, int>>();
   *server = s;
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    return CreateEventEngineListener(s, shutdown_complete, config, server);
+  }
   return absl::OkStatus();
 }
 
@@ -123,8 +263,14 @@ static void finish_shutdown(grpc_tcp_server* s) {
     s->head = sp->next;
     gpr_free(sp);
   }
-  delete s->fd_handler;
-  delete s;
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    // This will trigger asynchronous execution of the on_shutdown_complete
+    // callback when appropriate. That callback will delete the server
+    s->ee_listener.reset();
+  } else {
+    delete s->fd_handler;
+    delete s;
+  }
 }
 
 static void destroyed_port(void* server, grpc_error_handle /*error*/) {
@@ -423,6 +569,30 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
 static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
                                              const grpc_resolved_address* addr,
                                              int* out_port) {
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    gpr_mu_lock(&s->mu);
+    if (s->shutdown_listeners) {
+      gpr_mu_unlock(&s->mu);
+      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++));
+        });
+    if (port.ok()) {
+      s->n_bind_ports++;
+      *out_port = *port;
+    }
+    gpr_mu_unlock(&s->mu);
+    return port.status();
+  }
   GPR_ASSERT(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
   grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
@@ -500,6 +670,17 @@ static grpc_tcp_listener* get_port_index(grpc_tcp_server* s,
 unsigned tcp_server_port_fd_count(grpc_tcp_server* s, unsigned port_index) {
   unsigned num_fds = 0;
   gpr_mu_lock(&s->mu);
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    // This doesn't need to be very fast. Used in tests.
+    for (auto it = s->listen_fd_to_index_map.begin();
+         it != s->listen_fd_to_index_map.end(); it++) {
+      if (std::get<0>(it->second) == static_cast<int>(port_index)) {
+        num_fds++;
+      }
+    }
+    gpr_mu_unlock(&s->mu);
+    return num_fds;
+  }
   grpc_tcp_listener* sp = get_port_index(s, port_index);
   for (; sp; sp = sp->sibling) {
     ++num_fds;
@@ -511,6 +692,19 @@ unsigned tcp_server_port_fd_count(grpc_tcp_server* s, unsigned port_index) {
 static int tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
                               unsigned fd_index) {
   gpr_mu_lock(&s->mu);
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    // This doesn't need to be very fast. Used in tests.
+    for (auto it = s->listen_fd_to_index_map.begin();
+         it != s->listen_fd_to_index_map.end(); it++) {
+      if (std::get<0>(it->second) == static_cast<int>(port_index) &&
+          std::get<1>(it->second) == static_cast<int>(fd_index)) {
+        gpr_mu_unlock(&s->mu);
+        return it->first;
+      }
+    }
+    gpr_mu_unlock(&s->mu);
+    return -1;
+  }
   grpc_tcp_listener* sp = get_port_index(s, port_index);
   for (; sp; sp = sp->sibling, --fd_index) {
     if (fd_index == 0) {
@@ -530,6 +724,12 @@ static void tcp_server_start(grpc_tcp_server* s,
   GPR_ASSERT(s->on_accept_cb);
   GPR_ASSERT(s->active_ports == 0);
   s->pollsets = pollsets;
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    GPR_ASSERT(!s->shutdown_listeners);
+    GPR_ASSERT(GRPC_LOG_IF_ERROR("listener_start", s->ee_listener->Start()));
+    gpr_mu_unlock(&s->mu);
+    return;
+  }
   sp = s->head;
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
@@ -584,7 +784,10 @@ static void tcp_server_unref(grpc_tcp_server* s) {
 static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
   s->shutdown_listeners = true;
-  // shutdown all fd's
+  if (grpc_event_engine::experimental::UseEventEngineListener()) {
+    s->ee_listener->ShutdownListeningFds();
+  }
+  /* shutdown all fd's */
   if (s->active_ports) {
     grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
@@ -611,6 +814,18 @@ 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()) {
+      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)));
+      return;
+    }
     grpc_pollset* read_notifier_pollset;
     grpc_resolved_address addr;
     memset(&addr, 0, sizeof(addr));

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

@@ -16,11 +16,16 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
-#define GRPC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
+#define GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
+#include "absl/container/flat_hash_map.h"
+
+#include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
@@ -99,6 +104,11 @@ struct grpc_tcp_server {
   // used to create slice allocators for endpoints, owned
   grpc_core::MemoryQuotaRefPtr memory_quota;
 
+  /* 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>
+      ee_listener = nullptr;
   /* used to store a pre-allocated FD assigned to a socket */
   int pre_allocated_fd;
 };
@@ -129,4 +139,4 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 // Ruturn true if the platform supports ifaddrs
 bool grpc_tcp_server_have_ifaddrs(void);
 
-#endif  // GRPC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H