grpc 1.60.0 → 1.62.0

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

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

@@ -22,18 +22,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
-bool g_event_engine_supports_fd = true;
-#else
-bool g_event_engine_supports_fd = false;
-#endif
-
 bool UseEventEngineClient() {
 // TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
 // available for other platforms.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
-#elif defined(GPR_WINDOWS)
+#elif defined(GPR_WINDOWS) && !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
   return true;
@@ -53,14 +48,5 @@ bool UseEventEngineListener() {
 #endif
 }
 
-bool EventEngineSupportsFd() {
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return g_event_engine_supports_fd;
-#else
-  return false;
-#endif
-}
-
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -25,8 +25,6 @@ bool UseEventEngineClient();
 
 bool UseEventEngineListener();
 
-bool EventEngineSupportsFd();
-
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/thread_pool/thread_count.cc

@@ -17,27 +17,48 @@
 
 #include <inttypes.h>
 
+#include <cstddef>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/time.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
 // -------- LivingThreadCount --------
 
-void LivingThreadCount::BlockUntilThreadCount(size_t desired_threads,
-                                              const char* why) {
-  constexpr grpc_core::Duration log_rate = grpc_core::Duration::Seconds(3);
+absl::Status LivingThreadCount::BlockUntilThreadCount(
+    size_t desired_threads, const char* why,
+    grpc_core::Duration stuck_timeout) {
+  grpc_core::Timestamp timeout_baseline = grpc_core::Timestamp::Now();
+  constexpr grpc_core::Duration log_rate = grpc_core::Duration::Seconds(5);
+  size_t prev_thread_count = 0;
   while (true) {
-    auto curr_threads = WaitForCountChange(desired_threads, log_rate);
-    if (curr_threads == desired_threads) break;
+    auto curr_threads = WaitForCountChange(desired_threads, log_rate / 2);
+    if (curr_threads == desired_threads) return absl::OkStatus();
+    auto elapsed = grpc_core::Timestamp::Now() - timeout_baseline;
+    if (curr_threads == prev_thread_count) {
+      if (elapsed > stuck_timeout) {
+        return absl::DeadlineExceededError(absl::StrFormat(
+            "Timed out after %f seconds", stuck_timeout.seconds()));
+      }
+    } else {
+      // the thread count has changed. Reset the timeout clock
+      prev_thread_count = curr_threads;
+      timeout_baseline = grpc_core::Timestamp::Now();
+    }
     GRPC_LOG_EVERY_N_SEC_DELAYED(
         log_rate.seconds(), GPR_DEBUG,
         "Waiting for thread pool to idle before %s. (%" PRIdPTR " to %" PRIdPTR
-        ")",
-        why, curr_threads, desired_threads);
+        "). Timing out in %0.f seconds.",
+        why, curr_threads, desired_threads,
+        (stuck_timeout - elapsed).seconds());
   }
 }
 

data/src/core/lib/event_engine/thread_pool/thread_count.h

@@ -151,7 +151,12 @@ class LivingThreadCount {
     --living_count_;
     cv_.SignalAll();
   }
-  void BlockUntilThreadCount(size_t desired_threads, const char* why)
+  // Blocks the calling thread until the desired number of threads is reached.
+  // If the thread count does not change for some given `stuck_timeout`
+  // duration, this method returns error. If the thread count does change, the
+  // timeout clock is reset.
+  absl::Status BlockUntilThreadCount(size_t desired_threads, const char* why,
+                                     grpc_core::Duration stuck_timeout)
       ABSL_LOCKS_EXCLUDED(mu_);
   size_t count() ABSL_LOCKS_EXCLUDED(mu_) {
     grpc_core::MutexLock lock(&mu_);

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -15,7 +15,6 @@
 // limitations under the License.
 //
 //
-
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
@@ -24,24 +23,36 @@
 
 #include <atomic>
 #include <chrono>
+#include <cstddef>
 #include <memory>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/thd_id.h>
 
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/examine_stack.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/gprpp/time.h"
 
+#ifdef GPR_POSIX_SYNC
+#include <csignal>
+#elif defined(GPR_WINDOWS)
+#include <signal.h>
+#endif
+
 // IWYU pragma: no_include <ratio>
 
 // ## Thread Pool Fork-handling
@@ -84,6 +95,13 @@
 // non-existent Lifeguard thread to finish. Trying a simple
 // `lifeguard_thread_.Join()` leads to memory access errors. This implementation
 // uses Notifications to coordinate startup and shutdown states.
+//
+// ## Debugging
+//
+// Set the environment variable GRPC_THREAD_POOL_VERBOSE_FAILURES=anything to
+// enable advanced debugging. When the pool takes too long to quiesce, a
+// backtrace will be printed for every running thread, and the process will
+// abort.
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -117,6 +135,37 @@ constexpr grpc_core::Duration kLifeguardMinSleepBetweenChecks{
 // Maximum time the lifeguard thread should sleep between checking for new work.
 constexpr grpc_core::Duration kLifeguardMaxSleepBetweenChecks{
     grpc_core::Duration::Seconds(1)};
+constexpr grpc_core::Duration kBlockUntilThreadCountTimeout{
+    grpc_core::Duration::Seconds(60)};
+
+#ifdef GPR_POSIX_SYNC
+const bool g_log_verbose_failures =
+    grpc_core::GetEnv("GRPC_THREAD_POOL_VERBOSE_FAILURES").has_value();
+constexpr int kDumpStackSignal = SIGUSR1;
+#elif defined(GPR_WINDOWS)
+const bool g_log_verbose_failures =
+    grpc_core::GetEnv("GRPC_THREAD_POOL_VERBOSE_FAILURES").has_value();
+constexpr int kDumpStackSignal = SIGTERM;
+#else
+constexpr bool g_log_verbose_failures = false;
+constexpr int kDumpStackSignal = -1;
+#endif
+
+std::atomic<size_t> g_reported_dump_count{0};
+
+void DumpSignalHandler(int /* sig */) {
+  const auto trace = grpc_core::GetCurrentStackTrace();
+  if (!trace.has_value()) {
+    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": Stack trace not available",
+            gpr_thd_currentid());
+  } else {
+    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": %s", gpr_thd_currentid(),
+            trace->c_str());
+  }
+  g_reported_dump_count.fetch_add(1);
+  grpc_core::Thread::Kill(gpr_thd_currentid());
+}
+
 }  // namespace
 
 thread_local WorkQueue* g_local_queue = nullptr;
@@ -125,6 +174,10 @@ thread_local WorkQueue* g_local_queue = nullptr;
 
 WorkStealingThreadPool::WorkStealingThreadPool(size_t reserve_threads)
     : pool_{std::make_shared<WorkStealingThreadPoolImpl>(reserve_threads)} {
+  if (g_log_verbose_failures) {
+    GRPC_EVENT_ENGINE_TRACE(
+        "%s", "WorkStealingThreadPool verbose failures are enabled");
+  }
   pool_->Start();
 }
 
@@ -221,8 +274,13 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   // running instead of zero.
   bool is_threadpool_thread = g_local_queue != nullptr;
   work_signal()->SignalAll();
-  living_thread_count_.BlockUntilThreadCount(is_threadpool_thread ? 1 : 0,
-                                             "shutting down");
+  auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
+      is_threadpool_thread ? 1 : 0, "shutting down",
+      g_log_verbose_failures ? kBlockUntilThreadCountTimeout
+                             : grpc_core::Duration::Infinity());
+  if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
+    DumpStacksAndCrash();
+  }
   GPR_ASSERT(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
   lifeguard_.BlockUntilShutdownAndReset();
@@ -262,7 +320,11 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
   gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::PrepareFork");
   SetForking(true);
   work_signal_.SignalAll();
-  living_thread_count_.BlockUntilThreadCount(0, "forking");
+  auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
+      0, "forking", kBlockUntilThreadCountTimeout);
+  if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
+    DumpStacksAndCrash();
+  }
   lifeguard_.BlockUntilShutdownAndReset();
 }
 
@@ -271,6 +333,37 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Postfork() {
   Start();
 }
 
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::TrackThread(
+    gpr_thd_id tid) {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  thds_.insert(tid);
+}
+
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::UntrackThread(
+    gpr_thd_id tid) {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  thds_.erase(tid);
+}
+
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::DumpStacksAndCrash() {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  gpr_log(GPR_ERROR,
+          "Pool did not quiesce in time, gRPC will not shut down cleanly. "
+          "Dumping all %zu thread stacks.",
+          thds_.size());
+  for (const auto tid : thds_) {
+    grpc_core::Thread::Signal(tid, kDumpStackSignal);
+  }
+  // If this is a thread pool thread, wait for one fewer thread.
+  auto ignore_thread_count = g_local_queue != nullptr ? 1 : 0;
+  while (living_thread_count_.count() - ignore_thread_count >
+         g_reported_dump_count.load()) {
+    absl::SleepFor(absl::Milliseconds(200));
+  }
+  grpc_core::Crash(
+      "Pool did not quiesce in time, gRPC will not shut down cleanly.");
+}
+
 // -------- WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard -----
 
 WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Lifeguard(
@@ -388,6 +481,14 @@ WorkStealingThreadPool::ThreadState::ThreadState(
       busy_count_idx_(pool_->busy_thread_count()->NextIndex()) {}
 
 void WorkStealingThreadPool::ThreadState::ThreadBody() {
+  if (g_log_verbose_failures) {
+#ifdef GPR_POSIX_SYNC
+    std::signal(kDumpStackSignal, DumpSignalHandler);
+#elif defined(GPR_WINDOWS)
+    signal(kDumpStackSignal, DumpSignalHandler);
+#endif
+    pool_->TrackThread(gpr_thd_currentid());
+  }
   g_local_queue = new BasicWorkQueue(pool_.get());
   pool_->theft_registry()->Enroll(g_local_queue);
   ThreadLocal::SetIsEventEngineThread(true);
@@ -410,6 +511,9 @@ void WorkStealingThreadPool::ThreadState::ThreadBody() {
   GPR_ASSERT(g_local_queue->Empty());
   pool_->theft_registry()->Unenroll(g_local_queue);
   delete g_local_queue;
+  if (g_log_verbose_failures) {
+    pool_->UntrackThread(gpr_thd_currentid());
+  }
 }
 
 void WorkStealingThreadPool::ThreadState::SleepIfRunning() {

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h

@@ -31,6 +31,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/thd_id.h>
 
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/event_engine/thread_pool/thread_count.h"
@@ -132,6 +133,9 @@ class WorkStealingThreadPool final : public ThreadPool {
     // Postfork parent and child have the same behavior.
     void PrepareFork();
     void Postfork();
+    // Thread ID tracking
+    void TrackThread(gpr_thd_id tid);
+    void UntrackThread(gpr_thd_id tid);
     // Accessor methods
     bool IsShutdown();
     bool IsForking();
@@ -172,6 +176,8 @@ class WorkStealingThreadPool final : public ThreadPool {
       std::atomic<bool> lifeguard_running_{false};
     };
 
+    void DumpStacksAndCrash();
+
     const size_t reserve_threads_;
     BusyThreadCount busy_thread_count_;
     LivingThreadCount living_thread_count_;
@@ -190,6 +196,9 @@ class WorkStealingThreadPool final : public ThreadPool {
     std::atomic<bool> throttled_{false};
     WorkSignal work_signal_;
     Lifeguard lifeguard_;
+    // Set of threads for verbose failure debugging
+    grpc_core::Mutex thd_set_mu_;
+    absl::flat_hash_set<gpr_thd_id> thds_ ABSL_GUARDED_BY(thd_set_mu_);
   };
 
   class ThreadState {

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

@@ -29,7 +29,8 @@ namespace grpc_event_engine {
 namespace experimental {
 
 std::string HandleToStringInternal(uintptr_t a, uintptr_t b) {
-  return absl::StrCat("{", a, ",", b, "}");
+  return absl::StrCat("{", absl::Hex(a, absl::kZeroPad16), ",",
+                      absl::Hex(b, absl::kZeroPad16), "}");
 }
 
 grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -24,6 +24,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/support/log_windows.h>
 

data/src/core/lib/event_engine/windows/native_windows_dns_resolver.cc

@@ -0,0 +1,115 @@
+// Copyright 2024 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.
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+#include <inttypes.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/windows/native_windows_dns_resolver.h"
+#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
+  std::vector<EventEngine::ResolvedAddress> addresses;
+  // parse name, splitting it into host and port parts
+  std::string host;
+  std::string port;
+  grpc_core::SplitHostPort(name, &host, &port);
+  if (host.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat("Unparseable name: ", name));
+  }
+  if (port.empty()) {
+    if (default_port.empty()) {
+      return absl::InvalidArgumentError(
+          absl::StrFormat("No port in name %s or default_port argument", name));
+    }
+    port = std::string(default_port);
+  }
+  // Call getaddrinfo
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
+  hints.ai_socktype = SOCK_STREAM;  // stream socket
+  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
+  struct addrinfo* result = nullptr;
+  int getaddrinfo_error =
+      getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  if (getaddrinfo_error != 0) {
+    return absl::UnknownError(
+        absl::StrFormat("Address lookup failed for %s os_error: %s", name,
+                        grpc_core::StatusToString(
+                            GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo"))
+                            .c_str()));
+  }
+  // Success path: collect and return all addresses
+  for (auto* resp = result; resp != nullptr; resp = resp->ai_next) {
+    addresses.emplace_back(resp->ai_addr, resp->ai_addrlen);
+  }
+  if (result) freeaddrinfo(result);
+  return addresses;
+}
+
+}  // namespace
+NativeWindowsDNSResolver::NativeWindowsDNSResolver(
+    std::shared_ptr<EventEngine> event_engine)
+    : event_engine_(std::move(event_engine)) {}
+
+void NativeWindowsDNSResolver::LookupHostname(
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+    absl::string_view name, absl::string_view default_port) {
+  event_engine_->Run(
+      [name, default_port, on_resolved = std::move(on_resolved)]() mutable {
+        on_resolved(LookupHostnameBlocking(name, default_port));
+      });
+}
+
+void NativeWindowsDNSResolver::LookupSRV(
+    EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up SRV records"));
+  });
+}
+
+void NativeWindowsDNSResolver::LookupTXT(
+    EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up TXT records"));
+  });
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_WINDOWS

data/src/core/lib/event_engine/windows/native_windows_dns_resolver.h

@@ -0,0 +1,51 @@
+// Copyright 2024 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_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// An asynchronous DNS resolver which uses the native platform's getaddrinfo
+// API. Only supports A/AAAA records.
+class NativeWindowsDNSResolver : public EventEngine::DNSResolver {
+ public:
+  explicit NativeWindowsDNSResolver(std::shared_ptr<EventEngine> event_engine);
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) override;
+
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+                 absl::string_view name) override;
+
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+                 absl::string_view name) override;
+
+ private:
+  std::shared_ptr<EventEngine> event_engine_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -37,6 +37,7 @@
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/grpc_polled_fd_windows.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/native_windows_dns_resolver.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 #include "src/core/lib/event_engine/windows/windows_listener.h"
@@ -204,17 +205,17 @@ WindowsEventEngine::WindowsDNSResolver::WindowsDNSResolver(
 void WindowsEventEngine::WindowsDNSResolver::LookupHostname(
     LookupHostnameCallback on_resolve, absl::string_view name,
     absl::string_view default_port) {
-  ares_resolver_->LookupHostname(name, default_port, std::move(on_resolve));
+  ares_resolver_->LookupHostname(std::move(on_resolve), name, default_port);
 }
 
 void WindowsEventEngine::WindowsDNSResolver::LookupSRV(
     LookupSRVCallback on_resolve, absl::string_view name) {
-  ares_resolver_->LookupSRV(name, std::move(on_resolve));
+  ares_resolver_->LookupSRV(std::move(on_resolve), name);
 }
 
 void WindowsEventEngine::WindowsDNSResolver::LookupTXT(
     LookupTXTCallback on_resolve, absl::string_view name) {
-  ares_resolver_->LookupTXT(name, std::move(on_resolve));
+  ares_resolver_->LookupTXT(std::move(on_resolve), name);
 }
 
 #endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
@@ -233,10 +234,9 @@ WindowsEventEngine::GetDNSResolver(
   return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
       std::move(*ares_resolver));
 #else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
-  // TODO(yijiem): Implement a basic A/AAAA-only native resolver in
-  // WindowsEventEngine.
-  (void)options;
-  grpc_core::Crash("unimplemented");
+  GRPC_EVENT_ENGINE_DNS_TRACE(
+      "WindowsEventEngine:%p creating NativeWindowsDNSResolver", this);
+  return std::make_unique<NativeWindowsDNSResolver>(shared_from_this());
 #endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }