grpc 1.60.0 → 1.62.0

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

@@ -28,6 +28,7 @@
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -36,12 +37,15 @@
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h"
+#include "src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
@@ -90,6 +94,15 @@ class TimerForkCallbackMethods {
   static void PostforkChild() { g_timer_fork_manager->PostforkChild(); }
 };
 
+bool ShouldUseAresDnsResolver() {
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  auto resolver_env = grpc_core::ConfigVars::Get().DnsResolver();
+  return resolver_env.empty() || absl::EqualsIgnoreCase(resolver_env, "ares");
+#else   // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  return false;
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+}
+
 }  // namespace
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -242,11 +255,11 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
     MemoryAllocator&& allocator, const PosixTcpOptions& options,
     Duration timeout) {
   int err;
-  int saved_errno;
+  int connect_errno;
   do {
     err = connect(sock.Fd(), addr.address(), addr.size());
   } while (err < 0 && errno == EINTR);
-  saved_errno = errno;
+  connect_errno = (err < 0) ? errno : 0;
 
   auto addr_uri = ResolvedAddressToURI(addr);
   if (!addr_uri.ok()) {
@@ -261,13 +274,8 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
   PosixEventPoller* poller = poller_manager_->Poller();
   EventHandle* handle =
       poller->CreateHandle(sock.Fd(), name, poller->CanTrackErrors());
-  int64_t connection_id = 0;
-  if (saved_errno == EWOULDBLOCK || saved_errno == EINPROGRESS) {
-    // Connection is still in progress.
-    connection_id = last_connection_id_.fetch_add(1, std::memory_order_acq_rel);
-  }
 
-  if (err >= 0) {
+  if (connect_errno == 0) {
     // Connection already succeded. Return 0 to discourage any cancellation
     // attempts.
     Run([on_connect = std::move(on_connect),
@@ -277,18 +285,21 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  if (saved_errno != EWOULDBLOCK && saved_errno != EINPROGRESS) {
+  if (connect_errno != EWOULDBLOCK && connect_errno != EINPROGRESS) {
     // Connection already failed. Return 0 to discourage any cancellation
     // attempts.
     handle->OrphanHandle(nullptr, nullptr, "tcp_client_connect_error");
     Run([on_connect = std::move(on_connect),
-         ep = absl::FailedPreconditionError(
-             absl::StrCat("connect failed: ", "addr: ", addr_uri.value(),
-                          " error: ", std::strerror(saved_errno)))]() mutable {
+         ep = absl::FailedPreconditionError(absl::StrCat(
+             "connect failed: ", "addr: ", addr_uri.value(),
+             " error: ", std::strerror(connect_errno)))]() mutable {
       on_connect(std::move(ep));
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
+  // Connection is still in progress.
+  int64_t connection_id =
+      last_connection_id_.fetch_add(1, std::memory_order_acq_rel);
   AsyncConnect* ac = new AsyncConnect(
       std::move(on_connect), shared_from_this(), executor_.get(), handle,
       std::move(allocator), options, addr_uri.value(), connection_id);
@@ -517,49 +528,53 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
   return handle;
 }
 
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
-
 PosixEventEngine::PosixDNSResolver::PosixDNSResolver(
-    grpc_core::OrphanablePtr<AresResolver> ares_resolver)
-    : ares_resolver_(std::move(ares_resolver)) {}
+    grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver)
+    : dns_resolver_(std::move(dns_resolver)) {}
 
 void PosixEventEngine::PosixDNSResolver::LookupHostname(
     LookupHostnameCallback on_resolve, absl::string_view name,
     absl::string_view default_port) {
-  ares_resolver_->LookupHostname(name, default_port, std::move(on_resolve));
+  dns_resolver_->LookupHostname(std::move(on_resolve), name, default_port);
 }
 
 void PosixEventEngine::PosixDNSResolver::LookupSRV(LookupSRVCallback on_resolve,
                                                    absl::string_view name) {
-  ares_resolver_->LookupSRV(name, std::move(on_resolve));
+  dns_resolver_->LookupSRV(std::move(on_resolve), name);
 }
 
 void PosixEventEngine::PosixDNSResolver::LookupTXT(LookupTXTCallback on_resolve,
                                                    absl::string_view name) {
-  ares_resolver_->LookupTXT(name, std::move(on_resolve));
+  dns_resolver_->LookupTXT(std::move(on_resolve), name);
 }
 
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
-
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 PosixEventEngine::GetDNSResolver(
-    const EventEngine::DNSResolver::ResolverOptions& options) {
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
-  auto ares_resolver = AresResolver::CreateAresResolver(
-      options.dns_server,
-      std::make_unique<GrpcPolledFdFactoryPosix>(poller_manager_->Poller()),
-      shared_from_this());
-  if (!ares_resolver.ok()) {
-    return ares_resolver.status();
+    GRPC_UNUSED const EventEngine::DNSResolver::ResolverOptions& options) {
+#ifndef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+  grpc_core::Crash("Unable to get DNS resolver for this platform.");
+#else  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+  // If c-ares is supported on the platform, build according to user's
+  // configuration.
+  if (ShouldUseAresDnsResolver()) {
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+    GRPC_EVENT_ENGINE_DNS_TRACE("PosixEventEngine:%p creating AresResolver",
+                                this);
+    auto ares_resolver = AresResolver::CreateAresResolver(
+        options.dns_server,
+        std::make_unique<GrpcPolledFdFactoryPosix>(poller_manager_->Poller()),
+        shared_from_this());
+    if (!ares_resolver.ok()) {
+      return ares_resolver.status();
+    }
+    return std::make_unique<PosixEventEngine::PosixDNSResolver>(
+        std::move(*ares_resolver));
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
   }
-  return std::make_unique<PosixEventEngine::PosixDNSResolver>(
-      std::move(*ares_resolver));
-#else   // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
-  // TODO(yijiem): Implement a basic A/AAAA-only native resolver in
-  // PosixEventEngine.
-  (void)options;
-  grpc_core::Crash("unimplemented");
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
+  GRPC_EVENT_ENGINE_DNS_TRACE(
+      "PosixEventEngine:%p creating NativePosixDNSResolver", this);
+  return std::make_unique<NativePosixDNSResolver>(shared_from_this());
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 }
 
 bool PosixEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
@@ -642,7 +657,7 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-std::unique_ptr<PosixEndpointWithFdSupport>
+std::unique_ptr<EventEngine::Endpoint>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
@@ -686,7 +701,7 @@ PosixEventEngine::CreateListener(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
 PosixEventEngine::CreatePosixListener(
     PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
     absl::AnyInvocable<void(absl::Status)> on_shutdown,

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

@@ -34,11 +34,11 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 
-#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -141,11 +141,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
  public:
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
-    PosixDNSResolver() = delete;
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
     explicit PosixDNSResolver(
-        grpc_core::OrphanablePtr<AresResolver> ares_resolver);
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
+        grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver);
     void LookupHostname(LookupHostnameCallback on_resolve,
                         absl::string_view name,
                         absl::string_view default_port) override;
@@ -154,10 +151,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
     void LookupTXT(LookupTXTCallback on_resolve,
                    absl::string_view name) override;
 
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
    private:
-    grpc_core::OrphanablePtr<AresResolver> ares_resolver_;
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
+    grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver_;
   };
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -175,7 +170,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 
   ~PosixEventEngine() override;
 
-  std::unique_ptr<PosixEndpointWithFdSupport> CreatePosixEndpointFromFd(
+  std::unique_ptr<EventEngine::Endpoint> CreatePosixEndpointFromFd(
       int fd, const EndpointConfig& config,
       MemoryAllocator memory_allocator) override;
 
@@ -186,8 +181,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
       std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
       override;
 
-  absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
-  CreatePosixListener(
+  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> CreatePosixListener(
       PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       const EndpointConfig& config,
@@ -203,7 +197,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
   absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
-      const DNSResolver::ResolverOptions& options) override;
+      GRPC_UNUSED const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;
   // Caution!! The timer implementation cannot create any fds. See #20418.

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

@@ -44,7 +44,9 @@
 #include "src/core/lib/event_engine/posix_engine/posix_engine_listener.h"
 #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/event_engine/trace.h"
 #include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
@@ -124,6 +126,8 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::Start() {
 
 void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     absl::Status status) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Acceptor[%p]: NotifyOnAccept: %s", this,
+                                   status.ToString().c_str());
   if (!status.ok()) {
     // Shutting down the acceptor. Unref the ref grabbed in
     // AsyncConnectionAcceptor::Start().
@@ -173,7 +177,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
           return;
         default:
           gpr_log(GPR_ERROR, "Closing acceptor. Failed accept4: %s",
-                  strerror(errno));
+                  grpc_core::StrError(errno).c_str());
           // Shutting down the acceptor. Unref the ref grabbed in
           // AsyncConnectionAcceptor::Start().
           Unref();
@@ -186,12 +190,16 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     if (addr.address()->sa_family == AF_UNIX) {
       socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
       if (getpeername(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
-        gpr_log(GPR_ERROR, "Closing acceptor. Failed getpeername: %s",
-                strerror(errno));
+        auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
+        gpr_log(
+            GPR_ERROR,
+            "Failed getpeername: %s. Dropping the connection, and continuing "
+            "to listen on %s:%d.",
+            grpc_core::StrError(errno).c_str(),
+            listener_addr_uri.ok() ? listener_addr_uri->c_str() : "<unknown>",
+            socket_.port);
         close(fd);
-        // Shutting down the acceptor. Unref the ref grabbed in
-        // AsyncConnectionAcceptor::Start().
-        Unref();
+        handle_->NotifyOnRead(notify_on_accept_);
         return;
       }
       addr = EventEngine::ResolvedAddress(addr.address(), len);

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 {
@@ -176,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) {
@@ -241,6 +249,13 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     return absl::FailedPreconditionError(
         absl::StrCat("getifaddrs: ", std::strerror(errno)));
   }
+
+  static const bool is_ipv4_available = [] {
+    const int fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (fd >= 0) close(fd);
+    return fd >= 0;
+  }();
+
   for (ifa_it = ifa; ifa_it != nullptr; ifa_it = ifa_it->ifa_next) {
     ResolvedAddress addr;
     socklen_t len;
@@ -248,6 +263,9 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     if (ifa_it->ifa_addr == nullptr) {
       continue;
     } else if (ifa_it->ifa_addr->sa_family == AF_INET) {
+      if (!is_ipv4_available) {
+        continue;
+      }
       len = static_cast<socklen_t>(sizeof(sockaddr_in));
     } else if (ifa_it->ifa_addr->sa_family == AF_INET6) {
       len = static_cast<socklen_t>(sizeof(sockaddr_in6));

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

@@ -25,6 +25,7 @@
 #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"
@@ -75,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 */
@@ -83,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();
@@ -210,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;
 }
 

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>
 
@@ -75,6 +76,8 @@ struct PosixTcpOptions {
   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 {
@@ -89,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;
   }
@@ -98,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
@@ -113,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;
   }

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/query_extensions.h

@@ -0,0 +1,85 @@
+// Copyright 2023 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_QUERY_EXTENSIONS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_QUERY_EXTENSIONS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace endpoint_detail {
+
+template <typename Querying, typename... Es>
+struct QueryExtensionRecursion;
+
+template <typename Querying, typename E, typename... Es>
+struct QueryExtensionRecursion<Querying, E, Es...> {
+  static void* Query(absl::string_view id, Querying* p) {
+    if (id == E::EndpointExtensionName()) return static_cast<E*>(p);
+    return QueryExtensionRecursion<Querying, Es...>::Query(id, p);
+  }
+};
+
+template <typename Querying>
+struct QueryExtensionRecursion<Querying> {
+  static void* Query(absl::string_view, Querying*) { return nullptr; }
+};
+
+}  // namespace endpoint_detail
+
+// A helper class to derive from some set of base classes and export
+// QueryExtension for them all.
+// EventEngine Extensible object implementations which need to support different
+// extensions just need to derive from this class.
+template <typename EEClass, typename... Exports>
+class ExtendedType : public EEClass, public Exports... {
+ public:
+  void* QueryExtension(absl::string_view id) override {
+    return endpoint_detail::QueryExtensionRecursion<ExtendedType,
+                                                    Exports...>::Query(id,
+                                                                       this);
+  }
+};
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the endpoint.
+template <typename T>
+T* QueryExtension(EventEngine::Endpoint* endpoint) {
+  if (endpoint == nullptr) return nullptr;
+  return static_cast<T*>(endpoint->QueryExtension(T::EndpointExtensionName()));
+}
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the listener.
+template <typename T>
+T* QueryExtension(EventEngine::Listener* listener) {
+  return static_cast<T*>(listener->QueryExtension(T::EndpointExtensionName()));
+}
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the EventEngine.
+template <typename T>
+T* QueryExtension(EventEngine* engine) {
+  return static_cast<T*>(engine->QueryExtension(T::EndpointExtensionName()));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_QUERY_EXTENSIONS_H