grpc 1.56.0 → 1.61.0

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

@@ -15,6 +15,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -23,7 +24,10 @@
 #include <sys/socket.h>  // IWYU pragma: keep
 #include <unistd.h>      // IWYU pragma: keep
 
+#include <atomic>
 #include <string>
+#include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -41,6 +45,7 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
 namespace grpc_event_engine {
@@ -136,6 +141,32 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       switch (errno) {
         case EINTR:
           continue;
+        case EMFILE:
+          // When the process runs out of fds, accept4() returns EMFILE. When
+          // this happens, the connection is left in the accept queue until
+          // either a read event triggers the on_read callback, or time has
+          // passed and the accept should be re-tried regardless. This callback
+          // is not cancelled, so a spurious wakeup may occur even when there's
+          // nothing to accept. This is not a performant code path, but if an fd
+          // limit has been reached, the system is likely in an unhappy state
+          // regardless.
+          GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s",
+                               "File descriptor limit reached. Retrying.");
+          handle_->NotifyOnRead(notify_on_accept_);
+          // Do not schedule another timer if one is already armed.
+          if (retry_timer_armed_.exchange(true)) return;
+          // Hold a ref while the retry timer is waiting, to prevent listener
+          // destruction and the races that would ensue.
+          Ref();
+          std::ignore =
+              engine_->RunAfter(grpc_core::Duration::Seconds(1), [this]() {
+                retry_timer_armed_.store(false);
+                if (!handle_->IsHandleShutdown()) {
+                  handle_->SetReadable();
+                }
+                Unref();
+              });
+          return;
         case EAGAIN:
         case ECONNABORTED:
           handle_->NotifyOnRead(notify_on_accept_);
@@ -151,11 +182,11 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     }
 
     // For UNIX sockets, the accept call might not fill up the member
-    // sun_path of sockaddr_un, so explicitly call getsockname to get it.
+    // sun_path of sockaddr_un, so explicitly call getpeername to get it.
     if (addr.address()->sa_family == AF_UNIX) {
       socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
-      if (getsockname(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
-        gpr_log(GPR_ERROR, "Closing acceptor. Failed getsockname: %s",
+      if (getpeername(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
+        gpr_log(GPR_ERROR, "Closing acceptor. Failed getpeername: %s",
                 strerror(errno));
         close(fd);
         // Shutting down the acceptor. Unref the ref grabbed in
@@ -197,15 +228,20 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
         listener_->memory_allocator_factory_->CreateMemoryAllocator(
             absl::StrCat("endpoint-tcp-server-connection: ", *peer_name)),
         /*options=*/listener_->options_);
-    // Call on_accept_ and then resume accepting new connections by continuing
-    // the parent for-loop.
-    listener_->on_accept_(
-        /*listener_fd=*/handle_->WrappedFd(), /*endpoint=*/std::move(endpoint),
-        /*is_external=*/false,
-        /*memory_allocator=*/
-        listener_->memory_allocator_factory_->CreateMemoryAllocator(
-            absl::StrCat("on-accept-tcp-server-connection: ", *peer_name)),
-        /*pending_data=*/nullptr);
+
+    grpc_core::EnsureRunInExecCtx([this, peer_name = std::move(*peer_name),
+                                   endpoint = std::move(endpoint)]() mutable {
+      // Call on_accept_ and then resume accepting new connections
+      // by continuing the parent for-loop.
+      listener_->on_accept_(
+          /*listener_fd=*/handle_->WrappedFd(),
+          /*endpoint=*/std::move(endpoint),
+          /*is_external=*/false,
+          /*memory_allocator=*/
+          listener_->memory_allocator_factory_->CreateMemoryAllocator(
+              absl::StrCat("on-accept-tcp-server-connection: ", peer_name)),
+          /*pending_data=*/nullptr);
+    });
   }
   GPR_UNREACHABLE_CODE(return);
 }
@@ -228,21 +264,24 @@ absl::Status PosixEngineListenerImpl::HandleExternalConnection(
         absl::StrCat("HandleExternalConnection: peer not connected: ",
                      peer_name.status().ToString()));
   }
-  auto endpoint = CreatePosixEndpoint(
-      /*handle=*/poller_->CreateHandle(fd, *peer_name,
-                                       poller_->CanTrackErrors()),
-      /*on_shutdown=*/nullptr, /*engine=*/engine_,
-      /*allocator=*/
-      memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
-          "external:endpoint-tcp-server-connection: ", *peer_name)),
-      /*options=*/options_);
-  on_accept_(
-      /*listener_fd=*/listener_fd, /*endpoint=*/std::move(endpoint),
-      /*is_external=*/true,
-      /*memory_allocator=*/
-      memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
-          "external:on-accept-tcp-server-connection: ", *peer_name)),
-      /*pending_data=*/pending_data);
+  grpc_core::EnsureRunInExecCtx([this, peer_name = std::move(*peer_name),
+                                 pending_data, listener_fd, fd]() mutable {
+    auto endpoint = CreatePosixEndpoint(
+        /*handle=*/poller_->CreateHandle(fd, peer_name,
+                                         poller_->CanTrackErrors()),
+        /*on_shutdown=*/nullptr, /*engine=*/engine_,
+        /*allocator=*/
+        memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
+            "external:endpoint-tcp-server-connection: ", peer_name)),
+        /*options=*/options_);
+    on_accept_(
+        /*listener_fd=*/listener_fd, /*endpoint=*/std::move(endpoint),
+        /*is_external=*/true,
+        /*memory_allocator=*/
+        memory_allocator_factory_->CreateMemoryAllocator(absl::StrCat(
+            "external:on-accept-tcp-server-connection: ", peer_name)),
+        /*pending_data=*/pending_data);
+  });
   return absl::OkStatus();
 }
 

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

@@ -110,6 +110,8 @@ class PosixEngineListenerImpl
     }
     ListenerSocketsContainer::ListenerSocket& Socket() { return socket_; }
     ~AsyncConnectionAcceptor() {
+      // If uds socket, unlink it so that the corresponding file is deleted.
+      UnlinkIfUnixDomainSocket(*socket_.sock.LocalAddress());
       handle_->OrphanHandle(nullptr, nullptr, "");
       delete notify_on_accept_;
     }
@@ -121,6 +123,9 @@ class PosixEngineListenerImpl
     ListenerSocketsContainer::ListenerSocket socket_;
     EventHandle* handle_;
     PosixEngineClosure* notify_on_accept_;
+    // Tracks the status of a backup timer to retry accept4 calls after file
+    // descriptor exhaustion.
+    std::atomic<bool> retry_timer_armed_{false};
   };
   class ListenerAsyncAcceptors : public ListenerSocketsContainer {
    public:

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

@@ -25,6 +25,8 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_replace.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
@@ -44,8 +46,6 @@
 #include <netinet/in.h>  // IWYU pragma: keep
 #include <sys/socket.h>  // IWYU pragma: keep
 #include <unistd.h>      // IWYU pragma: keep
-
-#include "absl/strings/str_cat.h"
 #endif
 
 namespace grpc_event_engine {
@@ -148,7 +148,8 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
     }
   });
   if (PosixSocketWrapper::IsSocketReusePortSupported() &&
-      options.allow_reuse_port && socket.addr.address()->sa_family != AF_UNIX) {
+      options.allow_reuse_port && socket.addr.address()->sa_family != AF_UNIX &&
+      !ResolvedAddressIsVSock(socket.addr)) {
     GRPC_RETURN_IF_ERROR(socket.sock.SetSocketReusePort(1));
   }
 
@@ -164,7 +165,8 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
   GRPC_RETURN_IF_ERROR(socket.sock.SetSocketNonBlocking(1));
   GRPC_RETURN_IF_ERROR(socket.sock.SetSocketCloexec(1));
 
-  if (socket.addr.address()->sa_family != AF_UNIX) {
+  if (socket.addr.address()->sa_family != AF_UNIX &&
+      !ResolvedAddressIsVSock(socket.addr)) {
     GRPC_RETURN_IF_ERROR(socket.sock.SetSocketLowLatency(1));
     GRPC_RETURN_IF_ERROR(socket.sock.SetSocketReuseAddr(1));
     socket.sock.TrySetSocketTcpUserTimeout(options, false);
@@ -174,8 +176,16 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
       GRPC_FD_SERVER_LISTENER_USAGE, options));
 
   if (bind(fd, socket.addr.address(), socket.addr.size()) < 0) {
+    auto sockaddr_str = ResolvedAddressToString(socket.addr);
+    if (!sockaddr_str.ok()) {
+      gpr_log(GPR_ERROR, "Could not convert sockaddr to string: %s",
+              sockaddr_str.status().ToString().c_str());
+      sockaddr_str = "<unparsable>";
+    }
+    sockaddr_str = absl::StrReplaceAll(*sockaddr_str, {{"\0", "@"}});
     return absl::FailedPreconditionError(
-        absl::StrCat("Error in bind: ", std::strerror(errno)));
+        absl::StrCat("Error in bind for address '", *sockaddr_str,
+                     "': ", std::strerror(errno)));
   }
 
   if (listen(fd, GetMaxAcceptQueueSize()) < 0) {

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

@@ -17,16 +17,16 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 
 #include <errno.h>
-#include <inttypes.h>
 #include <limits.h>
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
@@ -76,6 +76,7 @@ int AdjustValue(int default_value, int min_value, int max_value,
   return *actual_value;
 }
 
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 // The default values for TCP_USER_TIMEOUT are currently configured to be in
 // line with the default values of KEEPALIVE_TIMEOUT as proposed in
 // https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md */
@@ -84,8 +85,6 @@ int kDefaultServerUserTimeoutMs = 20000;
 bool kDefaultClientUserTimeoutEnabled = false;
 bool kDefaultServerUserTimeoutEnabled = true;
 
-#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
-
 absl::Status ErrorForFd(
     int fd, const experimental::EventEngine::ResolvedAddress& addr) {
   if (fd >= 0) return absl::OkStatus();
@@ -128,10 +127,11 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
   if (options.tcp_receive_buffer_size != options.kReadBufferSizeUnset) {
     GRPC_RETURN_IF_ERROR(sock.SetSocketRcvBuf(options.tcp_receive_buffer_size));
   }
-  if (reinterpret_cast<const sockaddr*>(addr.address())->sa_family != AF_UNIX) {
-    // If its not a unix socket address.
+  if (addr.address()->sa_family != AF_UNIX && !ResolvedAddressIsVSock(addr)) {
+    // If its not a unix socket or vsock address.
     GRPC_RETURN_IF_ERROR(sock.SetSocketLowLatency(1));
     GRPC_RETURN_IF_ERROR(sock.SetSocketReuseAddr(1));
+    GRPC_RETURN_IF_ERROR(sock.SetSocketDscp(options.dscp));
     sock.TrySetSocketTcpUserTimeout(options, true);
   }
   GRPC_RETURN_IF_ERROR(sock.SetSocketNoSigpipeIfPossible());
@@ -184,6 +184,8 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.expand_wildcard_addrs =
       (AdjustValue(0, 1, INT_MAX,
                    config.GetInt(GRPC_ARG_EXPAND_WILDCARD_ADDRS)) != 0);
+  options.dscp = AdjustValue(PosixTcpOptions::kDscpNotSet, 0, 63,
+                             config.GetInt(GRPC_ARG_DSCP));
   options.allow_reuse_port = PosixSocketWrapper::IsSocketReusePortSupported();
   auto allow_reuse_port_value = config.GetInt(GRPC_ARG_ALLOW_REUSEPORT);
   if (allow_reuse_port_value.has_value()) {
@@ -208,6 +210,13 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
     options.socket_mutator =
         grpc_socket_mutator_ref(static_cast<grpc_socket_mutator*>(value));
   }
+  value =
+      config.GetVoidPointer(GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY);
+  if (value != nullptr) {
+    options.memory_allocator_factory =
+        static_cast<grpc_event_engine::experimental::MemoryAllocatorFactory*>(
+            value);
+  }
   return options;
 }
 
@@ -519,6 +528,39 @@ absl::Status PosixSocketWrapper::SetSocketLowLatency(int low_latency) {
   return absl::OkStatus();
 }
 
+// Set Differentiated Services Code Point (DSCP)
+absl::Status PosixSocketWrapper::SetSocketDscp(int dscp) {
+  if (dscp == PosixTcpOptions::kDscpNotSet) {
+    return absl::OkStatus();
+  }
+  // The TOS/TrafficClass byte consists of following bits:
+  // | 7 6 5 4 3 2 | 1 0 |
+  // |    DSCP     | ECN |
+  int newval = dscp << 2;
+  int val;
+  socklen_t intlen = sizeof(val);
+  // Get ECN bits from current IP_TOS value unless IPv6 only
+  if (0 == getsockopt(fd_, IPPROTO_IP, IP_TOS, &val, &intlen)) {
+    newval |= (val & 0x3);
+    if (0 != setsockopt(fd_, IPPROTO_IP, IP_TOS, &newval, sizeof(newval))) {
+      return absl::Status(
+          absl::StatusCode::kInternal,
+          absl::StrCat("setsockopt(IP_TOS): ", grpc_core::StrError(errno)));
+    }
+  }
+  // Get ECN from current Traffic Class value if IPv6 is available
+  if (0 == getsockopt(fd_, IPPROTO_IPV6, IPV6_TCLASS, &val, &intlen)) {
+    newval |= (val & 0x3);
+    if (0 !=
+        setsockopt(fd_, IPPROTO_IPV6, IPV6_TCLASS, &newval, sizeof(newval))) {
+      return absl::Status(absl::StatusCode::kInternal,
+                          absl::StrCat("setsockopt(IPV6_TCLASS): ",
+                                       grpc_core::StrError(errno)));
+    }
+  }
+  return absl::OkStatus();
+}
+
 #if GPR_LINUX == 1
 // For Linux, it will be detected to support TCP_USER_TIMEOUT
 #ifndef TCP_USER_TIMEOUT
@@ -712,7 +754,7 @@ absl::StatusOr<PosixSocketWrapper> PosixSocketWrapper::CreateDualStackSocket(
     }
     // If this isn't an IPv4 address, then return whatever we've got.
     if (!ResolvedAddressIsV4Mapped(addr, nullptr)) {
-      if (newfd <= 0) {
+      if (newfd < 0) {
         return ErrorForFd(newfd, addr);
       }
       dsmode = PosixSocketWrapper::DSMode::DSMODE_IPV6;
@@ -799,6 +841,10 @@ absl::Status PosixSocketWrapper::SetSocketReusePort(int /*reuse*/) {
   grpc_core::Crash("unimplemented");
 }
 
+absl::Status PosixSocketWrapper::SetSocketDscp(int /*dscp*/) {
+  grpc_core::Crash("unimplemented");
+}
+
 void PosixSocketWrapper::ConfigureDefaultTcpUserTimeout(bool /*enable*/,
                                                         int /*timeout*/,
                                                         bool /*is_client*/) {}

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

@@ -26,6 +26,7 @@
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
@@ -60,6 +61,7 @@ struct PosixTcpOptions {
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
   // Let the system decide the proper buffer size.
   static constexpr int kReadBufferSizeUnset = -1;
+  static constexpr int kDscpNotSet = -1;
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
@@ -71,8 +73,11 @@ struct PosixTcpOptions {
   int keep_alive_timeout_ms = 0;
   bool expand_wildcard_addrs = false;
   bool allow_reuse_port = false;
+  int dscp = kDscpNotSet;
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   struct grpc_socket_mutator* socket_mutator = nullptr;
+  grpc_event_engine::experimental::MemoryAllocatorFactory*
+      memory_allocator_factory = nullptr;
   PosixTcpOptions() = default;
   // Move ctor
   PosixTcpOptions(PosixTcpOptions&& other) noexcept {
@@ -87,6 +92,8 @@ struct PosixTcpOptions {
     }
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    memory_allocator_factory =
+        std::exchange(other.memory_allocator_factory, nullptr);
     CopyIntegerOptions(other);
     return *this;
   }
@@ -96,6 +103,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    memory_allocator_factory = other.memory_allocator_factory;
     CopyIntegerOptions(other);
   }
   // Copy assignment
@@ -111,6 +119,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    memory_allocator_factory = other.memory_allocator_factory;
     CopyIntegerOptions(other);
     return *this;
   }
@@ -135,6 +144,7 @@ struct PosixTcpOptions {
     keep_alive_timeout_ms = other.keep_alive_timeout_ms;
     expand_wildcard_addrs = other.expand_wildcard_addrs;
     allow_reuse_port = other.allow_reuse_port;
+    dscp = other.dscp;
   }
 };
 
@@ -182,6 +192,9 @@ class PosixSocketWrapper {
   // Set SO_REUSEPORT
   absl::Status SetSocketReusePort(int reuse);
 
+  // Set Differentiated Services Code Point (DSCP)
+  absl::Status SetSocketDscp(int dscp);
+
   // Override default Tcp user timeout values if necessary.
   void TrySetSocketTcpUserTimeout(const PosixTcpOptions& options,
                                   bool is_client);

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

@@ -77,46 +77,19 @@ class TimerList {
   TimerList(const TimerList&) = delete;
   TimerList& operator=(const TimerList&) = delete;
 
-  // Initialize *timer. When expired or canceled, closure will be called with
-  // error set to indicate if it expired (absl::OkStatus()) or was canceled
-  //(absl::CancelledError()). *closure is guaranteed to be called exactly once,
-  // and application code should check the error to determine how it was
-  // invoked. The application callback is also responsible for maintaining
-  // information about when to free up any user-level state. Behavior is
-  // undefined for a deadline of grpc_core::Timestamp::InfFuture().
+  // Initialize a Timer.
+  // When expired, the closure will be run. If the timer is canceled, the
+  // closure will not be run. Behavior is undefined for a deadline of
+  // grpc_core::Timestamp::InfFuture().
   void TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                  experimental::EventEngine::Closure* closure);
 
-  // Note that there is no timer destroy function. This is because the
-  // timer is a one-time occurrence with a guarantee that the callback will
-  // be called exactly once, either at expiration or cancellation. Thus, all
-  // the internal timer event management state is destroyed just before
-  // that callback is invoked. If the user has additional state associated with
-  // the timer, the user is responsible for determining when it is safe to
-  // destroy that state.
-
-  // Cancel an *timer.
-  // There are three cases:
-  // 1. We normally cancel the timer
-  // 2. The timer has already run
-  // 3. We can't cancel the timer because it is "in flight".
-
-  // In all of these cases, the cancellation is still considered successful.
-  // They are essentially distinguished in that the timer_cb will be run
-  // exactly once from either the cancellation (with error
-  // absl::CancelledError()) or from the activation (with error
-  // absl::OkStatus()).
-
-  // Note carefully that the callback function MAY occur in the same callstack
-  // as grpc_timer_cancel. It's expected that most timers will be cancelled
-  // (their primary use is to implement deadlines), and so this code is
-  // optimized such that cancellation costs as little as possible. Making
-  // callbacks run inline matches this aim.
-
-  // Requires: cancel() must happen after init() on a given timer
-  bool TimerCancel(Timer* timer) GRPC_MUST_USE_RESULT;
-
-  // iomgr internal api for dealing with timers
+  // Cancel a Timer.
+  // Returns false if the timer cannot be canceled. This will happen if the
+  // timer has already fired, or if its closure is currently running. The
+  // closure is guaranteed to run eventually if this method returns false.
+  // Otherwise, this returns true, and the closure will not be run.
+  GRPC_MUST_USE_RESULT bool TimerCancel(Timer* timer);
 
   // Check for timers to be run, and return them.
   // Return nullopt if timers could not be checked due to contention with

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

@@ -30,7 +30,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/thd.h"
 
 static thread_local bool g_timer_thread;
 
@@ -67,41 +66,32 @@ bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
 }
 
 void TimerManager::MainLoop() {
-  for (;;) {
-    grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
-    absl::optional<std::vector<experimental::EventEngine::Closure*>>
-        check_result = timer_list_->TimerCheck(&next);
-    GPR_ASSERT(check_result.has_value() &&
-               "ERROR: More than one MainLoop is running.");
-    if (!check_result->empty()) {
-      RunSomeTimers(std::move(*check_result));
-      continue;
-    }
-    if (!WaitUntil(next)) break;
+  grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
+  absl::optional<std::vector<experimental::EventEngine::Closure*>>
+      check_result = timer_list_->TimerCheck(&next);
+  GPR_ASSERT(check_result.has_value() &&
+             "ERROR: More than one MainLoop is running.");
+  bool timers_found = !check_result->empty();
+  if (timers_found) {
+    RunSomeTimers(std::move(*check_result));
   }
-  main_loop_exit_signal_->Notify();
+  thread_pool_->Run([this, next, timers_found]() {
+    if (!timers_found && !WaitUntil(next)) {
+      main_loop_exit_signal_->Notify();
+      return;
+    }
+    MainLoop();
+  });
 }
 
 bool TimerManager::IsTimerManagerThread() { return g_timer_thread; }
 
-void TimerManager::StartMainLoopThread() {
-  main_thread_ = grpc_core::Thread(
-      "timer_manager",
-      [](void* arg) {
-        auto self = static_cast<TimerManager*>(arg);
-        self->MainLoop();
-      },
-      this, nullptr,
-      grpc_core::Thread::Options().set_tracked(false).set_joinable(false));
-  main_thread_.Start();
-}
-
 TimerManager::TimerManager(
     std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool)
     : host_(this), thread_pool_(std::move(thread_pool)) {
   timer_list_ = std::make_unique<TimerList>(&host_);
   main_loop_exit_signal_.emplace();
-  StartMainLoopThread();
+  thread_pool_->Run([this]() { MainLoop(); });
 }
 
 grpc_core::Timestamp TimerManager::Host::Now() {
@@ -162,7 +152,7 @@ void TimerManager::RestartPostFork() {
   }
   shutdown_ = false;
   main_loop_exit_signal_.emplace();
-  StartMainLoopThread();
+  thread_pool_->Run([this]() { MainLoop(); });
 }
 
 void TimerManager::PrepareFork() { Shutdown(); }

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

@@ -36,7 +36,6 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/notification.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
@@ -80,7 +79,6 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
     TimerManager* const timer_manager_;
   };
 
-  void StartMainLoopThread();
   void RestartPostFork();
   void MainLoop();
   void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
@@ -103,7 +101,6 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = false;
   // actual timer implementation
   std::unique_ptr<TimerList> timer_list_;
-  grpc_core::Thread main_thread_;
   std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool_;
   absl::optional<grpc_core::Notification> main_loop_exit_signal_;
 };

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

@@ -279,6 +279,8 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
       elem = elem->next_;
       continue;
     }
+    g_timestamps_callback(elem->arg_, &(elem->ts_),
+                          absl::DeadlineExceededError("Ack timed out"));
     if (prev != nullptr) {
       prev->next_ = elem->next_;
       delete elem;

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

@@ -17,7 +17,6 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"

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

@@ -18,7 +18,6 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"

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

@@ -0,0 +1,55 @@
+// Copyright 2023 The gRPC Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_REF_COUNTED_DNS_RESOLVER_INTERFACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_REF_COUNTED_DNS_RESOLVER_INTERFACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/orphanable.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class RefCountedDNSResolverInterface
+    : public grpc_core::InternallyRefCounted<RefCountedDNSResolverInterface> {
+ public:
+  explicit RefCountedDNSResolverInterface(const char* trace = nullptr,
+                                          intptr_t initial_refcount = 1)
+      : grpc_core::InternallyRefCounted<RefCountedDNSResolverInterface>(
+            trace, initial_refcount) {}
+
+  virtual void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) = 0;
+
+  virtual void LookupSRV(
+      EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+      absl::string_view name) = 0;
+
+  virtual void LookupTXT(
+      EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+      absl::string_view name) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_REF_COUNTED_DNS_RESOLVER_INTERFACE_H